diff --git a/.bazelrc b/.bazelrc new file mode 100644 index 000000000..8724ec1da --- /dev/null +++ b/.bazelrc @@ -0,0 +1,20 @@ +common --enable_bzlmod +# Use built-in protoc +common --incompatible_enable_proto_toolchain_resolution +common --@com_google_protobuf//bazel/toolchains:prefer_prebuilt_protoc=true + +# Ensure that we don't accidentally build protobuf or gRPC +common --per_file_copt=external/.*protobuf.*@--PROTOBUF_WAS_NOT_SUPPOSED_TO_BE_BUILT +common --host_per_file_copt=external/.*protobuf.*@--PROTOBUF_WAS_NOT_SUPPOSED_TO_BE_BUILT +common --per_file_copt=external/.*grpc.*@--GRPC_WAS_NOT_SUPPOSED_TO_BE_BUILT +common --host_per_file_copt=external/.*grpc.*@--GRPC_WAS_NOT_SUPPOSED_TO_BE_BUILT +build --java_runtime_version=remotejdk_11 +build --java_language_version=11 + + +# Hide Java 8 deprecation warnings. +common --javacopt=-Xlint:-options + +# Remove flag once https://github.com/google/cel-spec/issues/508 and rules_jvm_external is fixed. +common --incompatible_autoload_externally=proto_library,cc_proto_library,java_proto_library,java_test + diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 000000000..a3a0f42f2 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,39 @@ +--- +name: Bug report +about: Create a report to help us improve +title: "[BUG] " +labels: '' + +--- + +--- +name: Bug report +about: Create a report to help us improve + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Check which components this affects: + +- [ ] parser +- [ ] checker +- [ ] runtime + +Sample expression and input that reproduces the issue: +```cel +// sample expression string +``` + +Test setup: +```java +// test case in java +``` + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Additional context** +Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 000000000..59a173b91 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,23 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '' +labels: '' + +--- + +**Feature request checklist** + +- [ ] There are no issues that match the desired change +- [ ] The change is large enough it can't be addressed with a simple Pull Request +- [ ] If this is a bug, please file a [Bug Report](./ISSUE_TEMPLATE). + +**Change** +Summary of the proposed change and some details about what problem +it helps solve. + +**Example** +Replace this text with an example indicating the desired functionality. + +**Alternatives considered** +Briefly list alternative designs, or an example of the functionality to be replaced. diff --git a/.github/workflows/cross_artifact_dependencies_check.sh b/.github/workflows/cross_artifact_dependencies_check.sh new file mode 100755 index 000000000..0802a299a --- /dev/null +++ b/.github/workflows/cross_artifact_dependencies_check.sh @@ -0,0 +1,85 @@ +#!/bin/bash +# 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. + +set -o pipefail + +TARGETS=( + "//publish:cel" + "//publish:cel_common" + "//publish:cel_compiler" + "//publish:cel_runtime" + "//publish:cel_protobuf" + "//publish:cel_v1alpha1" +) + +echo "------------------------------------------------" +echo "Checking for duplicates..." +echo "------------------------------------------------" + +JDK8_FLAGS="--java_language_version=8 --java_runtime_version=8" +bazel build $JDK8_FLAGS "${TARGETS[@]}" || { echo "Bazel build failed"; exit 1; } + +( + for target in "${TARGETS[@]}"; do + # Locate the jar + jar_path=$(bazel cquery "$target" --output=files 2>/dev/null | grep '\-project.jar$') + + if [[ -z "$jar_path" ]]; then + echo "Error: Could not find -project.jar for target $target" >&2 + exit 1 + fi + + # Fix relative paths if running from a subdir. + if [[ ! -f "$jar_path" ]]; then + if [[ -f "../../$jar_path" ]]; then + jar_path="../../$jar_path" + else + echo "Error: File not found at $jar_path" >&2 + exit 1 + fi + fi + + echo "Inspecting: $target" >&2 + + # Extract classes and append the target name to the end of the line + # Format: dev/cel/expr/Expr.class //publish:cel_compiler + jar tf "$jar_path" | grep "\.class$" | awk -v tgt="$target" '{print $0, tgt}' + done +) | awk ' + # $1 is the Class Name, $2 is the Target Name + seen[$1] { + print "❌ DUPLICATE FOUND: " $1 + print " Present in: " seen[$1] + print " And in: " $2 + dupe=1 + next + } + { seen[$1] = $2 } + + END { if (dupe) exit 2 } +' + +EXIT_CODE=$? + +if [ $EXIT_CODE -eq 0 ]; then + echo "βœ… Success: No duplicate classes found." +elif [ $EXIT_CODE -eq 2 ]; then + echo "β›” Failure: Duplicate classes detected." +else + echo "πŸ’₯ Error: An unexpected error occurred (e.g., missing jar files). Exit Code: $EXIT_CODE" +fi + +exit $EXIT_CODE + diff --git a/.github/workflows/unwanted_deps.sh b/.github/workflows/unwanted_deps.sh new file mode 100755 index 000000000..c483f9730 --- /dev/null +++ b/.github/workflows/unwanted_deps.sh @@ -0,0 +1,49 @@ +#!/bin/bash +# Copyright 2024 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. + +# Script ran as part of Github CEL-Java CI to verify that the runtime jar does not contain unwanted dependencies. + +function checkUnwantedDeps { + target="$1" + unwanted_dep="$2" + + query="bazel query 'deps(${target})' --notool_deps --noimplicit_deps --output graph" + deps=$(eval $query) + + if echo "$deps" | grep "$unwanted_dep" > /dev/null; then + echo -e "$target contains unwanted dependency: $unwanted_dep!\n" + echo "$(echo "$deps" | grep "$unwanted_dep")" + exit 1 + fi +} + +# Do not include generated CEL protos in the jar +checkUnwantedDeps '//publish:cel_runtime' '@cel_spec' + +# cel_runtime does not support protolite +checkUnwantedDeps '//publish:cel_runtime' 'protobuf_java_util' +checkUnwantedDeps '//publish:cel' 'protobuf_java_util' + +# cel_runtime shouldn't depend on antlr +checkUnwantedDeps '//publish:cel_runtime' '@maven//:org_antlr_antlr4_runtime' + +# cel_runtime shouldn't depend on the protobuf_lite runtime +checkUnwantedDeps '//publish:cel_runtime' '@maven_android//:com_google_protobuf_protobuf_javalite' +checkUnwantedDeps '//publish:cel' '@maven_android//:com_google_protobuf_protobuf_javalite' + +# cel_runtime_android shouldn't depend on the full protobuf runtime or antlr +checkUnwantedDeps '//publish:cel_runtime_android' '@maven//:com_google_protobuf_protobuf_java' +checkUnwantedDeps '//publish:cel_runtime_android' '@maven//:org_antlr_antlr4_runtime' +exit 0 diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml new file mode 100644 index 000000000..94effd33b --- /dev/null +++ b/.github/workflows/workflow.yml @@ -0,0 +1,129 @@ +name: CEL-Java CI +run-name: Workflow started by ${{ github.actor }}. +on: + push: + branches: + - 'main' + pull_request: + branches: + - 'main' + +# Cancel previous workflows on the PR when there are multiple fast commits. +# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#concurrency +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.ref }} + cancel-in-progress: true + +jobs: + Bazel-Build-Java8: + runs-on: ubuntu-latest + timeout-minutes: 30 + steps: + - run: echo "πŸŽ‰ The job was automatically triggered by a ${{ github.event_name }} event." + - run: echo "🐧 Job is running on a ${{ runner.os }} server!" + - run: echo "πŸ”Ž The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}." + - name: Check out repository code + uses: actions/checkout@v6 + - name: Setup Bazel + uses: bazel-contrib/setup-bazel@0.18.0 + with: + # Avoid downloading Bazel every time. + bazelisk-cache: true + # Store build cache per workflow. + disk-cache: ${{ github.workflow }} + # Share repository cache between workflows. + repository-cache: true + # Prevent PRs from polluting cache + cache-save: ${{ github.event_name != 'pull_request' }} + - name: Bazel Output Version + run: bazelisk --version + - name: Java 8 Build + run: bazel build ... --java_language_version=8 --java_runtime_version=8 --build_tag_filters=-conformance_maven + - name: Unwanted Dependencies + run: .github/workflows/unwanted_deps.sh + - name: Cross-artifact Duplicate Classes Check + run: .github/workflows/cross_artifact_dependencies_check.sh + - run: echo "🍏 This job's status is ${{ job.status }}." + + Bazel-Tests: + runs-on: ubuntu-latest + timeout-minutes: 30 + steps: + - run: echo "πŸŽ‰ The job was automatically triggered by a ${{ github.event_name }} event." + - run: echo "🐧 Job is running on a ${{ runner.os }} server!" + - run: echo "πŸ”Ž The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}." + - name: Check out repository code + uses: actions/checkout@v6 + - name: Setup Bazel + uses: bazel-contrib/setup-bazel@0.18.0 + with: + # Avoid downloading Bazel every time. + bazelisk-cache: true + # Store build cache per workflow. + disk-cache: ${{ github.workflow }} + # Share repository cache between workflows. + repository-cache: true + # Prevent PRs from polluting cache + cache-save: ${{ github.event_name != 'pull_request' }} + - name: Bazel Output Version + run: bazelisk --version + - name: Bazel Test + # Exclude codelab exercises as they are intentionally made to fail + # Exclude maven conformance tests. They are only executed when there's version change. + run: bazelisk test ... --deleted_packages=//codelab/src/test/codelab --test_output=errors --test_tag_filters=-conformance_maven --build_tag_filters=-conformance_maven + - run: echo "🍏 This job's status is ${{ job.status }}." + + # -- Start of Maven Conformance Tests (Ran only when there's version changes) -- + Maven-Conformance: + runs-on: ubuntu-latest + timeout-minutes: 30 + steps: + - run: echo "πŸŽ‰ The job was automatically triggered by a ${{ github.event_name }} event." + - run: echo "🐧 Job is running on a ${{ runner.os }} server!" + - run: echo "πŸ”Ž The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}." + - name: Check out repository code + uses: actions/checkout@v6 + - name: Get changed files + id: changed_file + uses: tj-actions/changed-files@v47 + with: + files: publish/cel_version.bzl + - name: Setup Bazel + if: steps.changed_file.outputs.any_changed == 'true' + uses: bazel-contrib/setup-bazel@0.18.0 + with: + # Avoid downloading Bazel every time. + bazelisk-cache: true + # Store build cache per workflow. + disk-cache: ${{ github.workflow }} + # Share repository cache between workflows. + repository-cache: true + # Never write to the cache, strictly read-only + cache-save: false + - name: Verify Version Consistency + if: steps.changed_file.outputs.any_changed == 'true' + run: | + CEL_VERSION=$(grep 'CEL_VERSION =' publish/cel_version.bzl | cut -d '"' -f 2) + + MODULE_VERSION=$(grep 'CEL_VERSION =' MODULE.bazel | cut -d '"' -f 2) + + if [ -z "$CEL_VERSION" ] || [ -z "$MODULE_VERSION" ]; then + echo "❌ Error: Could not extract one or both version strings." + exit 1 + fi + + echo "Version in publish/cel_version.bzl: ${CEL_VERSION}" + echo "Version in MODULE.bazel: ${MODULE_VERSION}" + + if [ "$CEL_VERSION" != "$MODULE_VERSION" ]; then + echo "❌ Error: Version mismatch between files!" + exit 1 + fi + + echo "βœ… Versions match." + - name: Run Conformance Maven Test on Version Change + if: steps.changed_file.outputs.any_changed == 'true' + run: bazelisk test //conformance/src/test/java/dev/cel/conformance:conformance_maven --test_output=errors + - run: echo "🍏 This job's status is ${JOB_STATUS}." + env: + JOB_STATUS: ${{ job.status }} diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..3a2e0015d --- /dev/null +++ b/.gitignore @@ -0,0 +1,35 @@ +# Bazel +bazel-bin +bazel-examples +bazel-genfiles +bazel-cel-java +bazel-out +bazel-testlogs + +# IntelliJ IDEA +.idea +*.iml +*.ipr +*.iws +.ijwb + +# Eclipse +.classpath +.project +.settings +.gitignore +bin + +# OS X +.DS_Store + +# Maven (examples) +target + +# Temporary output dir for artifacts +mvn-artifacts + +*.swp +*.lock +.eclipse +.vscode diff --git a/BUILD.bazel b/BUILD.bazel new file mode 100644 index 000000000..024908625 --- /dev/null +++ b/BUILD.bazel @@ -0,0 +1,206 @@ +# Copyright 2022 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. + +# Includes package-wide build definitions for maven imported java targets +# that needs to be defined separately. + +load( + "@bazel_tools//tools/jdk:default_java_toolchain.bzl", + "BASE_JDK9_JVM_OPTS", + "DEFAULT_JAVACOPTS", + "DEFAULT_TOOLCHAIN_CONFIGURATION", + "default_java_toolchain", +) +load( + "@rules_java//java:defs.bzl", + "java_binary", + "java_library", + "java_package_configuration", + "java_plugin", +) +load("@rules_license//rules:license.bzl", "license") + +licenses(["notice"]) # Apache License 2.0 + +exports_files(["LICENSE"]) + +package(default_visibility = ["//visibility:public"]) + +license( + name = "license", + package_name = "cel", +) + +# Auto-value requires java_plugin to run the annotation processor + +java_plugin( + name = "auto_value_plugin", + processor_class = "com.google.auto.value.processor.AutoValueProcessor", + deps = [ + "@maven//:com_google_auto_value_auto_value", + "@maven//:com_google_auto_value_auto_value_annotations", + ], +) + +java_plugin( + name = "auto_builder_plugin", + processor_class = "com.google.auto.value.processor.AutoBuilderProcessor", + deps = [ + "@maven//:com_google_auto_value_auto_value", + "@maven//:com_google_auto_value_auto_value_annotations", + ], +) + +java_plugin( + name = "auto_one_of_plugin", + processor_class = "com.google.auto.value.processor.AutoOneOfProcessor", + deps = [ + "@maven//:com_google_auto_value_auto_value", + "@maven//:com_google_auto_value_auto_value_annotations", + ], +) + +java_library( + name = "auto_value", + exported_plugins = [ + ":auto_value_plugin", + ":auto_builder_plugin", + ":auto_one_of_plugin", + ], + neverlink = 1, + exports = [ + "@maven//:com_google_auto_value_auto_value_annotations", + ], +) + +# Truth requires both the core package and the extension to be exported. + +java_library( + name = "java_truth", + testonly = 1, + exports = [ + "@maven//:com_google_truth_extensions_truth_java8_extension", + "@maven//:com_google_truth_truth", + ], +) + +default_java_toolchain( + name = "repository_default_toolchain", + configuration = DEFAULT_TOOLCHAIN_CONFIGURATION, + javacopts = DEFAULT_JAVACOPTS, + jvm_opts = BASE_JDK9_JVM_OPTS, + package_configuration = [ + ":error_prone", + ], + source_version = "11", + target_version = "11", +) + +# This associates a set of javac flags with a set of packages +java_package_configuration( + name = "error_prone", + # keep sorted + javacopts = [ + "-Xep:AmbiguousMethodReference:ERROR", + "-Xep:BadAnnotationImplementation:ERROR", + "-Xep:BadComparable:ERROR", + "-Xep:BoxedPrimitiveConstructor:ERROR", + "-Xep:CannotMockFinalClass:ERROR", + "-Xep:CheckReturnValue:OFF", + "-Xep:ClassCanBeStatic:ERROR", + "-Xep:ClassNewInstance:ERROR", + "-Xep:DefaultCharset:ERROR", + "-Xep:DoubleCheckedLocking:ERROR", + "-Xep:ElementsCountedInLoop:ERROR", + "-Xep:EqualsHashCode:ERROR", + "-Xep:EqualsIncompatibleType:ERROR", + "-Xep:Finally:ERROR", + "-Xep:FloatingPointLiteralPrecision:ERROR", + "-Xep:FragmentInjection:ERROR", + "-Xep:FragmentNotInstantiable:ERROR", + "-Xep:FunctionalInterfaceClash:ERROR", + "-Xep:FutureReturnValueIgnored:ERROR", + "-Xep:GetClassOnEnum:ERROR", + "-Xep:ImmutableAnnotationChecker:ERROR", + "-Xep:ImmutableEnumChecker:ERROR", + "-Xep:IncompatibleModifiers:ERROR", + "-Xep:InjectOnConstructorOfAbstractClass:ERROR", + "-Xep:InputStreamSlowMultibyteRead:ERROR", + "-Xep:IterableAndIterator:ERROR", + "-Xep:JUnit3FloatingPointComparisonWithoutDelta:ERROR", + "-Xep:JUnitAmbiguousTestClass:ERROR", + "-Xep:Java8ApiChecker:ERROR", + "-Xep:LiteralClassName:ERROR", + "-Xep:MissingCasesInEnumSwitch:ERROR", + "-Xep:MissingFail:ERROR", + "-Xep:MissingOverride:ERROR", + "-Xep:MutableConstantField:ERROR", + "-Xep:NarrowingCompoundAssignment:ERROR", + "-Xep:NonAtomicVolatileUpdate:ERROR", + "-Xep:NonOverridingEquals:ERROR", + "-Xep:NullableConstructor:ERROR", + "-Xep:NullablePrimitive:ERROR", + "-Xep:NullableVoid:ERROR", + "-Xep:OperatorPrecedence:ERROR", + "-Xep:OverridesGuiceInjectableMethod:ERROR", + "-Xep:PreconditionsInvalidPlaceholder:ERROR", + "-Xep:ProtoFieldPreconditionsCheckNotNull:ERROR", + "-Xep:ProtocolBufferOrdinal:ERROR", + "-Xep:ReferenceEquality:ERROR", + "-Xep:RemoveUnusedImports:ERROR", + "-Xep:RequiredModifiers:ERROR", + "-Xep:ShortCircuitBoolean:ERROR", + "-Xep:SimpleDateFormatConstant:ERROR", + "-Xep:StaticGuardedByInstance:ERROR", + "-Xep:StringEquality:ERROR", + "-Xep:SynchronizeOnNonFinalField:ERROR", + "-Xep:TruthConstantAsserts:ERROR", + "-Xep:TypeParameterShadowing:ERROR", + "-Xep:TypeParameterUnusedInFormals:ERROR", + "-Xep:URLEqualsHashCode:ERROR", + "-Xep:UnsynchronizedOverridesSynchronized:ERROR", + "-Xep:UnusedMethod:ERROR", + "-Xep:UnusedVariable:ERROR", + "-Xep:WaitNotInLoop:ERROR", + "-Xep:WildcardImport:ERROR", + "-XepDisableWarningsInGeneratedCode", + "-XepExcludedPaths:.*/bazel-out/.*", + ], + packages = ["error_prone_packages"], +) + +# This is a regular package_group, which is used to specify a set of packages to apply flags to +package_group( + name = "error_prone_packages", + packages = [ + "//...", + ], +) + +java_binary( + name = "antlr4_tool", + main_class = "org.antlr.v4.Tool", + runtime_deps = ["@antlr4_jar//jar"], +) + +# These two package groups are to allow proper bidrectional sync with g3 +package_group( + name = "internal", + packages = ["//..."], +) + +package_group( + name = "android_allow_list", + packages = ["//..."], +) diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 000000000..7fb48ef20 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,93 @@ +# Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of +experience, education, socio-economic status, nationality, personal appearance, +race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, or to ban temporarily or permanently any +contributor for other behaviors that they deem inappropriate, threatening, +offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +This Code of Conduct also applies outside the project spaces when the Project +Steward has a reasonable belief that an individual's behavior may have a +negative impact on the project or its community. + +## Conflict Resolution + +We do not believe that all conflict is bad; healthy debate and disagreement +often yield positive results. However, it is never okay to be disrespectful or +to engage in behavior that violates the project’s code of conduct. + +If you see someone violating the code of conduct, you are encouraged to address +the behavior directly with those involved. Many issues can be resolved quickly +and easily, and this gives people more control over the outcome of their +dispute. If you are unable to resolve the matter for any reason, or if the +behavior is threatening or harassing, report it. We are dedicated to providing +an environment where participants feel welcome and safe. + +Reports should be directed to *cel-conduct@google.com*, the Project Steward(s) +for *Common Expression Language (CEL)*. It is the Project Steward’s duty to +receive and address reported violations of the code of conduct. They will then +work with a committee consisting of representatives from the Open Source +Programs Office and the Google Open Source Strategy team. If for any reason you +are uncomfortable reaching out to the Project Steward, please email +opensource@google.com. + +We will investigate every complaint, but you may not receive a direct response. +We will use our discretion in determining when and how to follow up on reported +incidents, which may range from not taking action to permanent expulsion from +the project and project-sponsored spaces. We will notify the accused of the +report and provide them an opportunity to discuss it before any action is taken. +The identity of the reporter will be omitted from the details of the report +supplied to the accused. In potentially harmful situations, such as ongoing +harassment or threats to anyone's safety, we may take action without notice. + +## Attribution + +This Code of Conduct is adapted from the Contributor Covenant, version 1.4, +available at +https://www.contributor-covenant.org/version/1/4/code-of-conduct.html \ No newline at end of file diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 000000000..47634bc4c --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,33 @@ +# How to Contribute + +We'd love to accept your patches and contributions to this project. + +## Before you begin + +### Sign our Contributor License Agreement + +Contributions to this project must be accompanied by a +[Contributor License Agreement](https://cla.developers.google.com/about) (CLA). +You (or your employer) retain the copyright to your contribution; this simply +gives us permission to use and redistribute your contributions as part of the +project. + +If you or your current employer have already signed the Google CLA (even if it +was for a different project), you probably don't need to do it again. + +Visit to see your current agreements or to +sign a new one. + +### Review our Community Guidelines + +This project follows [Google's Open Source Community +Guidelines](https://opensource.google/conduct/). + +## Contribution process + +### Code Reviews + +All submissions, including submissions by project members, require review. We +use GitHub pull requests for this purpose. Consult +[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more +information on using pull requests. \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 000000000..d64569567 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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 + + http://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. diff --git a/MODULE.bazel b/MODULE.bazel new file mode 100644 index 000000000..fcaf041ba --- /dev/null +++ b/MODULE.bazel @@ -0,0 +1,140 @@ +# Copyright 2025 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. + +module( + name = "cel_java", +) + +bazel_dep(name = "bazel_skylib", version = "1.9.0") +bazel_dep(name = "rules_jvm_external", version = "6.10") +bazel_dep(name = "protobuf", version = "33.4", repo_name = "com_google_protobuf") # see https://github.com/bazelbuild/rules_android/issues/373 +bazel_dep(name = "googleapis", version = "0.0.0-20260223-edfe7983", repo_name = "com_google_googleapis") +bazel_dep(name = "rules_pkg", version = "1.2.0") +bazel_dep(name = "rules_license", version = "1.0.0") +bazel_dep(name = "rules_proto", version = "7.1.0") +bazel_dep(name = "rules_java", version = "9.3.0") +bazel_dep(name = "rules_android", version = "0.7.1") +bazel_dep(name = "rules_shell", version = "0.6.1") +bazel_dep(name = "googleapis-java", version = "1.0.0") +bazel_dep(name = "cel-spec", version = "0.25.1", repo_name = "cel_spec") +bazel_dep(name = "rules_go", version = "0.50.1") + +# Required by cel-spec to satisfy gazelle transitive dependency +go_sdk = use_extension("@rules_go//go:extensions.bzl", "go_sdk") +go_sdk.download(version = "1.23.0") + +switched_rules = use_extension("@com_google_googleapis//:extensions.bzl", "switched_rules") +switched_rules.use_languages(java = True) +use_repo(switched_rules, "com_google_googleapis_imports") + +maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven") + +GUAVA_VERSION = "33.5.0" + +TRUTH_VERSION = "1.4.4" + +PROTOBUF_JAVA_VERSION = "4.33.5" + +CEL_VERSION = "0.13.1" + +# Compile only artifacts +[ + maven.artifact( + artifact = artifact, + group = group, + neverlink = True, + version = version, + ) + for group, artifact, version in [coord.split(":") for coord in [ + "com.google.code.findbugs:annotations:3.0.1", + "com.google.errorprone:error_prone_annotations:2.42.0", + ]] +] + +# Test only artifacts +[ + maven.artifact( + testonly = True, + artifact = artifact, + group = group, + version = version, + ) + for group, artifact, version in [coord.split(":") for coord in [ + "org.mockito:mockito-core:4.11.0", + "io.github.classgraph:classgraph:4.8.179", + "com.google.testparameterinjector:test-parameter-injector:1.18", + "com.google.guava:guava-testlib:" + GUAVA_VERSION + "-jre", + "com.google.truth.extensions:truth-java8-extension:" + TRUTH_VERSION, + "com.google.truth.extensions:truth-proto-extension:" + TRUTH_VERSION, + "com.google.truth.extensions:truth-liteproto-extension:" + TRUTH_VERSION, + "com.google.truth:truth:" + TRUTH_VERSION, + ]] +] + +maven.install( + name = "maven", + # keep sorted + artifacts = [ + "com.google.auto.value:auto-value:1.11.0", + "com.google.auto.value:auto-value-annotations:1.11.0", + "com.google.guava:guava:" + GUAVA_VERSION + "-jre", + "com.google.protobuf:protobuf-java:" + PROTOBUF_JAVA_VERSION, + "com.google.protobuf:protobuf-java-util:" + PROTOBUF_JAVA_VERSION, + "com.google.re2j:re2j:1.8", + "info.picocli:picocli:4.7.7", + "org.antlr:antlr4-runtime:4.13.2", + "org.freemarker:freemarker:2.3.34", + "org.jspecify:jspecify:1.0.0", + "org.threeten:threeten-extra:1.8.0", + "org.yaml:snakeyaml:2.5", + ], + repositories = [ + "https://maven.google.com", + "https://repo1.maven.org/maven2", + ], +) +maven.install( + name = "maven_android", + # keep sorted + artifacts = [ + "com.google.guava:guava:" + GUAVA_VERSION + "-android", + "com.google.protobuf:protobuf-javalite:" + PROTOBUF_JAVA_VERSION, + ], + repositories = [ + "https://maven.google.com", + "https://repo1.maven.org/maven2", + ], +) + +# Conformance test only + +maven.install( + name = "maven_conformance", + artifacts = [ + "dev.cel:cel:" + CEL_VERSION, + "dev.cel:compiler:" + CEL_VERSION, + "dev.cel:runtime:" + CEL_VERSION, + ], + repositories = [ + "https://maven.google.com", + "https://repo1.maven.org/maven2", + "https://central.sonatype.com/repository/maven-snapshots/", + ], +) +use_repo(maven, "maven", "maven_android", "maven_conformance") + +non_module_dependencies = use_extension("//:repositories.bzl", "non_module_dependencies") +use_repo(non_module_dependencies, "antlr4_jar") +use_repo(non_module_dependencies, "bazel_common") +use_repo(non_module_dependencies, "cel_policy") diff --git a/README.md b/README.md index f9a2b8294..e2424a85c 100644 --- a/README.md +++ b/README.md @@ -28,19 +28,78 @@ scripting language is too resource intensive. --- +* [Quick Start](#quick-start) * [Overview](#overview) * [Environment Setup](#environment-setup) - * [Parse and Check](#parse-and-check) - * [Macros](#macros) - * [Evaluate](#evaluate) - * [Errors](#Errors) -* [Examples](examples/README.md) + * [Parsing](#parsing) + * [Checking](#checking) + * [Macros](#macros) + * [Evaluation](#evaluation) + * [Errors](#errors) + * [Extensions](#extensions) * [Install](#install) * [Common Questions](#common-questions) * [License](#license) --- +## Quick Start + +### Install + +CEL-Java is available in Maven Central Repository. [Download the JARs here][8] or add the following to your build dependencies: + +**Maven (pom.xml)**: + +```xml + + dev.cel + cel + 0.13.1 + +``` + +**Gradle** + +```gradle +implementation 'dev.cel:cel:0.13.1' +``` + +Then run this example: + +```java +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +public class HelloWorld { + // Construct the compilation and runtime environments. + // These instances are immutable and thus trivially thread-safe and amenable to caching. + private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder().addVar("my_var", SimpleType.STRING).build(); + private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder().build(); + + public void run() throws CelValidationException, CelEvaluationException { + // Compile the expression into an Abstract Syntax Tree. + CelAbstractSyntaxTree ast = CEL_COMPILER.compile("my_var + '!'").getAst(); + + // Plan an executable program instance. + CelRuntime.Program program = CEL_RUNTIME.createProgram(ast); + + // Evaluate the program with an input variable. + String result = (String) program.eval(Map.of("my_var", "Hello World")); + System.out.println(result); // 'Hello World!' + } +} +``` + ## Overview Determine the variables and functions you want to provide to CEL. Parse and @@ -49,22 +108,91 @@ against some input. Checking is optional, but strongly encouraged. ### Environment Setup -This section will be completed once parser and type-checker has been added. +Configuration for the entire CEL stack can be done all at once via the +`CelFactory.standardCelBuilder()`, or can be composed into compilation and +evaluation via the `CelCompilerFactory` and `CelRuntimeFactory`. + +The simplest form of CEL usage is as follows: + +```java +Cel cel = CelFactory.standardCelBuilder().build(); +``` + +More commonly, your application will want to configure type-checking separately +from the runtime. Use `CelCompilerFactory` to construct a compilation +environment and declare the types, macros, variables, and functions to use with +your CEL application: + +```java +// Example environment for the following expression: +// resource.name.startsWith('/groups/' + group) +CelCompiler cel = CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.HAS) + .setContainer("google.rpc.context.AttributeContext") + .addMessageTypes(AttributeContext.getDescriptor()) + .addVar("resource", + StructTypeReference.create("google.rpc.context.AttributeContext.Resource")) + .addVar("group", SimpleType.STRING) + .build(); +``` + +More information about the features which are supported on the builder may be +found in the [`CelCompilerBuilder`][9]. + +### Parsing + +Some CEL use cases only require parsing of an expression in order to be useful. +For example, one example might want to check whether the expression contains any +nested comprehensions, or possibly to pass the parsed expression to a C++ or Go +binary for evaluation. Presently, Java does not support parse-only evaluation. + +```java +CelValidationResult parseResult = + cel.parse("resource.name.startsWith('/groups/' + group)"); +try { + return parseResult.getAst(); +} catch (CelValidationException e) { + // Handle exception... +} +``` + +### Checking + +Type-checking is performed on `CelAbstractSyntaxTree` values to ensure that the +expression is well formed and all variable and function references are defined. -### Parse and Check +Type-checking can be performed immediately after parsing an expression: -Parsing and type-checking support are currently not available in Java but will -be added in the near future. In the interim, you may consider -leveraging [Go implementation of CEL][4] -to produce a type-checked expression to evaluate it in CEL-Java. +```java +try { + CelValidationResult parseResult = + cel.parse("resource.name.startsWith('/groups/' + group)"); + CelValidationResult checkResult = cel.check(parseResult.getAst()); + return checkResult.getAst(); +} catch (CelValidationException e) { + // Handle exception... +} +``` + +Or, the parse and type-check can be combined into the `compile` call. This is +likely the more common need. + +```java +CelValidationResult compileResult = + cel.compile("resource.name.startsWith('/groups/' + group)"); +try { + return compileResult.getAst(); +} catch (CelValidationException e) { + // Handle exception... +} +``` #### Macros -Macros are optional but enabled by default. Macros were introduced to support -optional CEL features that might not be desired in all use cases without the -syntactic burden and complexity such features might desire if they were part of -the core CEL syntax. Macros are expanded at parse time and their expansions are -type-checked at check time. +Macros were introduced to support optional CEL features that might not be +desired in all use cases without the syntactic burden and complexity such +features might desire if they were part of the core CEL syntax. Macros are +expanded at parse time and their expansions are type-checked at check time. For example, when macros are enabled it is possible to support bounded iteration / fold operators. The macros `all`, `exists`, `exists_one`, `filter`, and `map` @@ -88,28 +216,37 @@ has(message.field) Both cases traditionally require special syntax at the language level, but these features are exposed via macros in CEL. -### Evaluate - -Now, evaluate for fun and profit. The evaluation is thread-safe and side-effect -free. Many different inputs can be sent to the same `cel.Program` and if fields -are present in the input, but not referenced in the expression, they are -ignored. +Refer to the [CEL Specification][10] for full listings of available macros. To +leverage them, simply set the desired macros via `setStandardMacros` on the +builder: ```java -import dev.cel.common.CelAbstractSyntaxTree; -import dev.cel.runtime.CelRuntimeFactory; +CelCompiler.standardCelBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) +``` -CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); -CelAbstractSyntaxTree ast = CelAbstractSyntaxTree.fromCheckedExpr(checkedExpr); +### Evaluation +Expressions can be evaluated using once they are type-checked/compiled by +creating a `CelRuntime.Program` from a `CelAbstractSyntaxTree`: + +```java +CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); try { - CelRuntime.Program program=celRuntime.createProgram(ast); - Object evaluatedResult=program.eval(parameterValues); -} catch(CelEvaluationException e) { - throw new IllegalArgumentException("Evaluation error has occurred.",e); + CelRuntime.Program program = celRuntime.createProgram(compileResult.getAst()); + return program.eval( + ImmutableMap.of( + "resource", Resource.newBuilder().setName("/groups/").build(), + "group", "admin" + )); +} catch (CelEvaluationException e) { + // Handle evaluation exceptions ... } ``` +The evaluation is thread-safe and side effect free thus many different inputs can +be sent to the same `cel.Program`. + #### Partial State In distributed apps it is not uncommon to have edge caches and central services. @@ -127,7 +264,7 @@ robust to evaluation against dynamic data types such as JSON inputs. In the following truth-table, the symbols `` and `` represent error or unknown values, with the `?` indicating that the branch is not taken due to -short-circuiting. When the result is `` this means that the both args are +short-circuiting. When the result is `` this means that both the args are possibly relevant to the result. | Expression | Result | @@ -149,14 +286,42 @@ possibly relevant to the result. ### Errors -This section will be completed once parser and type-checker has been added. +Parse and check errors have friendly error messages with pointers to where the +issues occur in source: + +```sh +ERROR: :1:40: undefined field 'undefined' + | TestAllTypes{single_int32: 1, undefined: 2} + | .......................................^`, +``` + +Both the parsed and checked expressions contain source position information +about each node that appears in the output AST. This information can be used +to determine error locations at evaluation time as well. -## Install +### Extensions + +CEL-Java offers a suite of [canonical extensions][11] to support commonly +needed features that falls outside the CEL specification. + +Examples: + +```java +// String manipulation +'hello hello'.replace('he', 'we') // returns 'wello wello' +'hello hello hello'.split(' ') // returns ['hello', 'hello', 'hello'] -CEL-Go supports `modules` and uses semantic versioning. For more info see -the [Go Modules](https://github.com/golang/go/wiki/Modules) docs. +// Math extensions +math.greatest(-42.0, -21.5, -100.0) // -21.5 +math.least(-42.0, -21.5, -100.0) // -100.0 -And of course, there is always the option to build from source directly. +// Proto extensions +proto.getExt(msg, google.expr.proto2.test.int32_ext) // returns int value + +// Local bindings +cel.bind(a, 'hello', + cel.bind(b, 'world', a + b + b + a)) // "helloworldworldhello" +``` ## Common Questions @@ -189,36 +354,36 @@ runtime bindings and error handling to do the right thing. ### Where can I learn more about the language? * See the [CEL Spec][1] for the specification and conformance test suite. -* Ask for support on the [CEL Go Discuss][2] Google group. +* Ask for support on the [CEL Java Discuss][2] Google group. ### How can I contribute? * See [CONTRIBUTING.md](./CONTRIBUTING.md) to get started. -* Use [GitHub Issues][4] to request features or report bugs. -* +* Use [GitHub Issues][7] to request features or report bugs. + ### Dependencies Java 8 or newer is required. -| Library | Version | Details | -|-----------------------|---------|----------------------| -| [Guava][2] | TBD | N/A | -| [RE2/J][3] | TBD | N/A | -| [Protocol Buffers][4] | TBD | Full or lite runtime | -| [ANTLR4][5] | TBD | Java runtime | +| Library | Details | +|-----------------------|----------------------| +| [Guava][3] | N/A | +| [RE2/J][4] | N/A | +| [Protocol Buffers][5] | Full or lite runtime | +| [ANTLR4][6] | Java runtime | ## License Released under the [Apache License](LICENSE). -Disclaimer: This is not an official Google product. - -[1]: https://github.com/google/cel-spec - +[1]: https://github.com/cel-expr/cel-spec [2]: https://groups.google.com/forum/#!forum/cel-java-discuss - -[3]: https://github.com/google/cel-cpp - -[4]: https://github.com/google/cel-go - -[5]: https://github.com/google/cel-java/issues \ No newline at end of file +[3]: https://github.com/google/guava +[4]: https://github.com/google/re2j +[5]: https://github.com/protocolbuffers/protobuf/tree/master/java +[6]: https://github.com/antlr/antlr4/tree/master/runtime/Java +[7]: https://github.com/cel-expr/cel-java/issues +[8]: https://search.maven.org/search?q=g:dev.cel +[9]: https://github.com/cel-expr/cel-java/blob/main/compiler/src/main/java/dev/cel/compiler/CelCompilerBuilder.java +[10]: https://github.com/cel-expr/cel-spec/blob/master/doc/langdef.md#macros +[11]: https://github.com/cel-expr/cel-java/blob/main/extensions/src/main/java/dev/cel/extensions/README.md diff --git a/antlr.bzl b/antlr.bzl new file mode 100644 index 000000000..3361366f2 --- /dev/null +++ b/antlr.bzl @@ -0,0 +1,203 @@ +# Copyright 2023 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. + +"""Build rules to create Java code from an ANTLR4 grammar.""" + +def antlr4_java_lexer(name, src, package, visibility = None, imports = None, compatible_with = []): + """Generates the java source corresponding to an antlr4 lexer definition. + + Args: + name: The name of the build rule. + src: The antlr4 g4 file containing the lexer rules. + package: The Java package to place the output in. + visibility: The standard Bazel visibility attribute. + imports: A list of antlr4 source imports to use when building the lexer. + compatible_with: The standard Bazel compatible_with attribute. + """ + suffixes = ("%s.java", "%s.tokens") + imports = imports or [] + + import_srcs = [] + for imp in imports: + import_srcs.append(imp) + if not imp.endswith(".g4"): + continue + import_srcs.append("%s.tokens" % imp[:-3]) + file_prefix = src[:-3] if src.endswith(".g4") else src + outs = _make_outs(file_prefix, suffixes) + native.genrule( + name = name, + srcs = [src] + import_srcs, + visibility = visibility, + outs = outs, + tags = _make_tags(package, outs), + cmd = ("mkdir $$$$.tmp ; " + "cp $(SRCS) $$$$.tmp/ ; " + "cd $$$$.tmp ; " + + ("../$(location //:antlr4_tool) " + src + + " -package " + package + " -Werror ; ") + "cd .. ; " + "".join( + [ + " cp $$$$.tmp/%s $(@D)/ ;" % filepath + for filepath in _make_outs(file_prefix, suffixes) + ], + ) + "rm -rf $$$$.tmp"), + heuristic_label_expansion = 0, + tools = [ + "//:antlr4_tool", + ], + compatible_with = compatible_with, + ) + +def antlr4_java_parser( + name, + src, + package, + visibility = None, + imports = None, + listener = True, + visitor = False, + compatible_with = []): + """Generates the java source corresponding to an antlr4 parser definition. + + Args: + name: The name of the build rule. + src: The antlr4 g4 file containing the parser rules. + package: The Java package to place the output in. + visibility: The standard Blaze visibility attribute. + imports: A list of antlr4 source imports to use when building the parser. + listener: Whether or not to include listener generated files. + visitor: Whether or not to include visitor generated files. + compatible_with: The standard Blaze compatible_with attribute. + """ + suffixes = ("%s.java", "%s.tokens") + visitor_flag = " " + if visitor: + visitor_flag = " -visitor" + suffixes += ("%sBaseVisitor.java", "%sVisitor.java") + listener_flag = " " + if listener: + suffixes += ("%sBaseListener.java", "%sListener.java") + else: + listener_flag = " -no-listener" + imports = imports or [] + import_srcs = [] + for imp in imports: + import_srcs.append(imp) + if not imp.endswith(".g4"): + continue + import_srcs.append("%s.tokens" % imp[:-3]) + file_prefix = src[:-3] if src.endswith(".g4") else src + outs = _make_outs(file_prefix, suffixes) + + native.genrule( + name = name, + srcs = [src] + import_srcs, + visibility = visibility, + outs = outs, + tags = _make_tags(package, outs), + cmd = ("mkdir $$$$.tmp ; " + "cp $(SRCS) $$$$.tmp/ ; " + "cd $$$$.tmp ; " + + ("../$(location //:antlr4_tool) " + src + + visitor_flag + listener_flag + " -package " + package + " ; ") + + "cd .. ; " + ( + "".join([ + " cp $$$$.tmp/%s $(@D)/ ;" % filepath + for filepath in _make_outs( + file_prefix, + suffixes, + ) + ]) + ) + "rm -rf $$$$.tmp"), + heuristic_label_expansion = 0, + tools = [ + "//:antlr4_tool", + ], + compatible_with = compatible_with, + ) + +def antlr4_java_combined( + name, + src, + package, + visibility = None, + imports = None, + listener = True, + visitor = False, + compatible_with = []): + """Generates the java source corresponding to an antlr4 grammar definition. + + This genrule assumes that 'src' starts with 'grammar' and not + '(lexer|parser) grammar' + + Args: + name: The name of the build rule. + src: The antlr4 g4 file containing the rules. + package: The Java package to place the output in. + visibility: The standard Blaze visibility attribute. + imports: A list of antlr4 source imports to use when building the parser. + listener: Whether or not to include listener generated files. + visitor: Whether or not to include visitor generated files. + compatible_with: The standard Blaze compatible_with attribute. + """ + suffixes = ("%sLexer.java", "%sParser.java", "%s.tokens") + visitor_flag = " " + if visitor: + visitor_flag = " -visitor" + suffixes += ("%sBaseVisitor.java", "%sVisitor.java") + listener_flag = " " + if listener: + suffixes += ("%sBaseListener.java", "%sListener.java") + else: + listener_flag = " -no-listener" + imports = imports or [] + import_srcs = [] + for imp in imports: + import_srcs.append(imp) + if not imp.endswith(".g4"): + continue + import_srcs.append("%s.tokens" % imp[:-3]) + file_prefix = src[:-3] if src.endswith(".g4") else src + outs = _make_outs(file_prefix, suffixes) + + native.genrule( + name = name, + srcs = [src] + import_srcs, + visibility = visibility, + outs = outs, + tags = _make_tags(package, outs), + cmd = ("mkdir $$$$.tmp ; " + "cp $(SRCS) $$$$.tmp/ ; " + "cd $$$$.tmp ; " + + ("../$(location //:antlr4_tool) " + src + + visitor_flag + listener_flag + " -package " + package + " ; ") + + "cd .. ; " + ( + "".join([ + " cp $$$$.tmp/%s $(@D)/ ;" % filepath + for filepath in _make_outs( + file_prefix, + suffixes, + ) + ]) + ) + "rm -rf $$$$.tmp"), + heuristic_label_expansion = 0, + tools = [ + "//:antlr4_tool", + ], + compatible_with = compatible_with, + ) + +def _make_outs(file_prefix, suffixes): + return [file_suffix % file_prefix for file_suffix in suffixes] + +def _make_tags(package, outs): + tags = [] + for file in outs: + if file.endswith(".java"): + tags.append("generated_java_class=%s.%s" % (package, file[:-5])) + return tags diff --git a/bundle/BUILD.bazel b/bundle/BUILD.bazel new file mode 100644 index 000000000..1eaf0bec8 --- /dev/null +++ b/bundle/BUILD.bazel @@ -0,0 +1,41 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "cel", + exports = [ + "//bundle/src/main/java/dev/cel/bundle:cel", + "//bundle/src/main/java/dev/cel/bundle:cel_factory", + ], +) + +java_library( + name = "environment", + exports = ["//bundle/src/main/java/dev/cel/bundle:environment"], +) + +java_library( + name = "environment_exception", + exports = ["//bundle/src/main/java/dev/cel/bundle:environment_exception"], +) + +java_library( + name = "environment_yaml_parser", + exports = ["//bundle/src/main/java/dev/cel/bundle:environment_yaml_parser"], +) + +java_library( + name = "environment_exporter", + exports = ["//bundle/src/main/java/dev/cel/bundle:environment_exporter"], +) + +java_library( + name = "cel_impl", + testonly = 1, + visibility = ["//:internal"], + exports = ["//bundle/src/main/java/dev/cel/bundle:cel_impl"], +) diff --git a/bundle/src/main/java/dev/cel/bundle/BUILD.bazel b/bundle/src/main/java/dev/cel/bundle/BUILD.bazel new file mode 100644 index 000000000..716442849 --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/BUILD.bazel @@ -0,0 +1,197 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//bundle:__pkg__", + "//publish:__pkg__", + ], +) + +CEL_SOURCES = [ + "Cel.java", + "CelBuilder.java", +] + +java_library( + name = "cel", + srcs = CEL_SOURCES, + tags = [ + ], + deps = [ + "//checker:checker_legacy_environment", + "//checker:proto_type_mask", + "//checker:standard_decl", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common/types:type_providers", + "//common/values:cel_value_provider", + "//compiler:compiler_builder", + "//parser:macro", + "//runtime", + "//runtime:function_binding", + "//runtime:standard_functions", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "cel_factory", + srcs = ["CelFactory.java"], + tags = [ + ], + deps = [ + ":cel", + ":cel_impl", + "//checker", + "//common:options", + "//compiler", + "//compiler:compiler_builder", + "//parser", + "//runtime", + "//runtime:runtime_planner_impl", + ], +) + +java_library( + name = "cel_impl", + srcs = ["CelImpl.java"], + tags = [ + ], + deps = [ + ":cel", + "//checker:checker_builder", + "//checker:proto_type_mask", + "//checker:standard_decl", + "//checker:type_provider_legacy", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common/internal:env_visitor", + "//common/internal:file_descriptor_converter", + "//common/types:cel_proto_types", + "//common/types:type_providers", + "//common/values:cel_value_provider", + "//compiler:compiler_builder", + "//parser:macro", + "//parser:parser_builder", + "//runtime", + "//runtime:function_binding", + "//runtime:runtime_planner_impl", + "//runtime:standard_functions", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "environment", + srcs = [ + "CelEnvironment.java", + ], + tags = [ + ], + deps = [ + ":environment_exception", + ":required_fields_checker", + "//:auto_value", + "//bundle:cel", + "//checker:proto_type_mask", + "//checker:standard_decl", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common:source", + "//common/types", + "//common/types:type_providers", + "//compiler:compiler_builder", + "//extensions", + "//parser:macro", + "//runtime", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "environment_exception", + srcs = [ + "CelEnvironmentException.java", + ], + tags = [ + ], + deps = ["//common:cel_exception"], +) + +java_library( + name = "environment_yaml_parser", + srcs = [ + "CelEnvironmentYamlParser.java", + "CelEnvironmentYamlSerializer.java", + ], + tags = [ + ], + deps = [ + ":environment", + ":environment_exception", + "//common:compiler_common", + "//common:container", + "//common/formats:file_source", + "//common/formats:parser_context", + "//common/formats:yaml_helper", + "//common/formats:yaml_parser_context_impl", + "//common/internal", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + "@maven//:org_yaml_snakeyaml", + ], +) + +java_library( + name = "environment_exporter", + srcs = [ + "CelEnvironmentExporter.java", + ], + tags = [ + ], + deps = [ + ":environment", + "//:auto_value", + "//bundle:cel", + "//checker:checker_builder", + "//checker:standard_decl", + "//common:compiler_common", + "//common:options", + "//common/internal:env_visitor", + "//common/types:cel_proto_types", + "//common/types:type_providers", + "//compiler:compiler_builder", + "//extensions", + "//extensions:extension_library", + "//parser:macro", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "required_fields_checker", + srcs = [ + "RequiredFieldsChecker.java", + ], + visibility = ["//visibility:private"], + deps = [ + "//:auto_value", + "@maven//:com_google_guava_guava", + ], +) diff --git a/bundle/src/main/java/dev/cel/bundle/Cel.java b/bundle/src/main/java/dev/cel/bundle/Cel.java new file mode 100644 index 000000000..677a4af2c --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/Cel.java @@ -0,0 +1,25 @@ +// Copyright 2022 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.bundle; + +import javax.annotation.concurrent.ThreadSafe; +import dev.cel.compiler.CelCompiler; +import dev.cel.runtime.CelRuntime; + +/** Cel interface for parse, type-check, and evaluation of CEL programs. */ +@ThreadSafe +public interface Cel extends CelCompiler, CelRuntime { + CelBuilder toCelBuilder(); +} diff --git a/bundle/src/main/java/dev/cel/bundle/CelBuilder.java b/bundle/src/main/java/dev/cel/bundle/CelBuilder.java new file mode 100644 index 000000000..f603b479f --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/CelBuilder.java @@ -0,0 +1,339 @@ +// Copyright 2022 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.bundle; + +import dev.cel.expr.Decl; +import dev.cel.expr.Type; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.Message; +import dev.cel.checker.CelStandardDeclarations; +import dev.cel.checker.ProtoTypeMask; +import dev.cel.checker.TypeProvider; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelVarDecl; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.values.CelValueProvider; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntimeLibrary; +import dev.cel.runtime.CelStandardFunctions; +import java.util.function.Function; + +/** Interface for building an instance of Cel. */ +public interface CelBuilder { + + /** Set the {@code CelOptions} used to enable fixes and feautres for this CEL instance. */ + @CanIgnoreReturnValue + CelBuilder setOptions(CelOptions options); + + /** Set the {@link CelStandardMacro} values for use with this instance. */ + @CanIgnoreReturnValue + CelBuilder setStandardMacros(CelStandardMacro... macros); + + /** Set the {@link CelStandardMacro} values for use with this instance. */ + @CanIgnoreReturnValue + CelBuilder setStandardMacros(Iterable macros); + + /** + * Registers the given macros, replacing any previous macros with the same key. + * + *

Use this to register a set of user-defined custom macro implementation for the parser. For + * registering macros defined as part of CEL standard library, use {@link #setStandardMacros} + * instead. + * + *

Custom macros should not use the same function names as the ones found in {@link + * CelStandardMacro} (ex: has, all, exists, etc.). Build method will throw if both standard macros + * and custom macros are set with the same name. + */ + @CanIgnoreReturnValue + CelBuilder addMacros(CelMacro... macros); + + /** + * Registers the given macros, replacing any previous macros with the same key. + * + *

Use this to register a set of user-defined custom macro implementation for the parser. For + * registering macros defined as part of CEL standard library, use {@link #setStandardMacros} + * instead. + * + *

Custom macros should not use the same function names as the ones found in {@link + * CelStandardMacro} (ex: has, all, exists, etc.). Build method will throw if both standard macros + * and custom macros are set with the same name. + */ + @CanIgnoreReturnValue + CelBuilder addMacros(Iterable macros); + + /** Retrieves the currently configured {@link CelContainer} in the builder. */ + CelContainer container(); + + /** + * Set the {@link CelContainer} to use as the namespace for resolving CEL expression variables and + * functions. + */ + @CanIgnoreReturnValue + CelBuilder setContainer(CelContainer container); + + /** Add a variable declaration with a given {@code name} and {@link Type}. */ + @CanIgnoreReturnValue + CelBuilder addVar(String name, Type type); + + /** Add a variable declaration with a given {@code name} and {@link CelType}. */ + @CanIgnoreReturnValue + CelBuilder addVar(String name, CelType type); + + /** Add variable and function {@code declarations} to the CEL environment. */ + @CanIgnoreReturnValue + CelBuilder addDeclarations(Decl... declarations); + + /** Add variable and function {@code declarations} to the CEL environment. */ + @CanIgnoreReturnValue + CelBuilder addDeclarations(Iterable declarations); + + /** Add function declaration {@code CelFunctionDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelBuilder addFunctionDeclarations(CelFunctionDecl... celFunctionDecls); + + /** Add function declaration {@code CelFunctionDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelBuilder addFunctionDeclarations(Iterable celFunctionDecls); + + /** Add variable declaration {@code CelVarDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelBuilder addVarDeclarations(CelVarDecl... celVarDecls); + + /** Add variable declaration {@code CelVarDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelBuilder addVarDeclarations(Iterable celVarDecls); + + /** + * Add one or more {@link ProtoTypeMask} values. The {@code ProtoTypeMask} values will be used to + * compute a set of {@code Decl} values using a protobuf message's fields as the names and types + * of the variables if {@link ProtoTypeMask#fieldsAreVariableDeclarations} is {@code true}. + * + *

Note, this feature may not work with custom {@link TypeProvider} implementations out of the + * box, as it requires the implementation of {@link TypeProvider#lookupFieldNames} to return the + * set of all fields declared on the protobuf type. + */ + @CanIgnoreReturnValue + CelBuilder addProtoTypeMasks(ProtoTypeMask... typeMasks); + + /** + * Add one or more {@link ProtoTypeMask} values. The {@code ProtoTypeMask} values will be used to + * compute a set of {@code Decl} values using a protobuf message's fields as the names and types + * of the variables if {@link ProtoTypeMask#fieldsAreVariableDeclarations} is {@code true}. + * + *

Note, this feature may not work with custom {@link TypeProvider} implementations out of the + * box, as it requires the implementation of {@link TypeProvider#lookupFieldNames} to return the + * set of all fields declared on the protobuf type. + */ + @CanIgnoreReturnValue + CelBuilder addProtoTypeMasks(Iterable typeMasks); + + /** + * Add one or more {@link CelFunctionBinding} objects to the CEL runtime. + * + *

Functions with duplicate overload ids will be replaced in favor of the new overload. + */ + @CanIgnoreReturnValue + CelBuilder addFunctionBindings(CelFunctionBinding... bindings); + + /** + * Bind a collection of {@link CelFunctionBinding} objects to the runtime. + * + *

Functions with duplicate overload ids will be replaced in favor of the new overload. + */ + @CanIgnoreReturnValue + CelBuilder addFunctionBindings(Iterable bindings); + + /** Adds bindings for functions that are allowed to be late-bound (resolved at execution time). */ + @CanIgnoreReturnValue + CelBuilder addLateBoundFunctions(String... lateBoundFunctionNames); + + /** Adds bindings for functions that are allowed to be late-bound (resolved at execution time). */ + @CanIgnoreReturnValue + CelBuilder addLateBoundFunctions(Iterable lateBoundFunctionNames); + + /** Set the expected {@code resultType} for the type-checked expression. */ + @CanIgnoreReturnValue + CelBuilder setResultType(CelType resultType); + + /** + * Set the expected {@code resultType} in proto format described in checked.proto for the + * type-checked expression. + */ + @CanIgnoreReturnValue + CelBuilder setProtoResultType(Type resultType); + + /** + * Set a custom type factory for the runtime. + * + *

Note: it is valid to combine type factory methods within the runtime. Only the options which + * have been configured will be used. + * + *

The type creation search order is as follows: + * + *

    + *
  • Custom type factory ({@link #setTypeFactory}) + *
  • Custom descriptor set {{@link #addMessageTypes}) + *
+ */ + @CanIgnoreReturnValue + CelBuilder setTypeFactory(Function typeFactory); + + /** + * Sets the {@code celValueProvider} for resolving values during evaluation. The provided value + * provider will be used first before falling back to the built-in {@link + * dev.cel.common.values.ProtoMessageValueProvider} for resolving protobuf messages. + * + *

Note that {@link CelOptions#enableCelValue()} must be enabled or this method will be a + * no-op. + */ + @CanIgnoreReturnValue + CelBuilder setValueProvider(CelValueProvider celValueProvider); + + /** + * Set the {@code typeProvider} for use with type-checking expressions. + * + * @deprecated Use {@link #setTypeProvider(CelTypeProvider)} instead. + */ + @CanIgnoreReturnValue + @Deprecated + CelBuilder setTypeProvider(TypeProvider typeProvider); + + /** Set the {@code celTypeProvider} for use with type-checking expressions. */ + @CanIgnoreReturnValue + CelBuilder setTypeProvider(CelTypeProvider celTypeProvider); + + /** + * Add message {@link Descriptor}s to the use for type-checking and object creation at + * interpretation time. + * + *

This method may be safely combined with {@link #setTypeFactory}, {@link #setTypeProvider}, + * and {@link #addFileTypes} calls. + * + *

If either a {@code typeFactory} or {@code typeProvider} are configured, these classes will + * take precedence over any dynamic resolution of data related to the descriptors. + */ + @CanIgnoreReturnValue + CelBuilder addMessageTypes(Descriptor... descriptors); + + /** + * Add message {@link Descriptor}s to the use for type-checking and object creation at + * interpretation time. + * + *

This method may be safely combined with {@link #setTypeFactory}, {@link #setTypeProvider}, + * and {@link #addFileTypes} calls. + * + *

If either a {@code typeFactory} or {@code typeProvider} are configured, these classes will + * take precedence over any dynamic resolution of data related to the descriptors. + */ + @CanIgnoreReturnValue + CelBuilder addMessageTypes(Iterable descriptors); + + /** + * Add {@link FileDescriptor}s to the use for type-checking, and for object creation at + * interpretation time. + * + *

This method may be safely combined with {@link #setTypeFactory}, {@link #setTypeProvider}, + * and {@link #addMessageTypes} calls. + * + *

If either a {@code typeFactory} or {@code typeProvider} are configured, these classes will + * take precedence over any dynamic resolution of data related to the descriptors. + */ + @CanIgnoreReturnValue + CelBuilder addFileTypes(FileDescriptor... fileDescriptors); + + /** + * Add {@link FileDescriptor}s to the use for type-checking, and for object creation at + * interpretation time. + * + *

This method may be safely combined with {@link #setTypeFactory}, {@link #setTypeProvider}, + * and {@link #addMessageTypes} calls. + * + *

If either a {@code typeFactory} or {@code typeProvider} are configured, these classes will + * take precedence over any dynamic resolution of data related to the descriptors. + */ + @CanIgnoreReturnValue + CelBuilder addFileTypes(Iterable fileDescriptors); + + /** + * Add all of the {@link FileDescriptor}s in a {@code FileDescriptorSet} to the use for + * type-checking, and for object creation at interpretation time. + * + *

This method may be safely combined with {@link #setTypeFactory}, {@link #setTypeProvider}, + * and {@link #addMessageTypes} calls. + * + *

If either a {@code typeFactory} or {@code typeProvider} are configured, these classes will + * take precedence over any dynamic resolution of data related to the descriptors. + */ + @CanIgnoreReturnValue + CelBuilder addFileTypes(FileDescriptorSet fileDescriptorSet); + + /** Enable or disable the standard CEL library functions and variables */ + @CanIgnoreReturnValue + CelBuilder setStandardEnvironmentEnabled(boolean value); + + /** Adds one or more libraries for parsing and type-checking. */ + @CanIgnoreReturnValue + CelBuilder addCompilerLibraries(CelCompilerLibrary... libraries); + + /** Adds a collection of libraries for parsing and type-checking. */ + @CanIgnoreReturnValue + CelBuilder addCompilerLibraries(Iterable libraries); + + /** Adds one or more libraries for runtime. */ + @CanIgnoreReturnValue + CelBuilder addRuntimeLibraries(CelRuntimeLibrary... libraries); + + /** Adds a collection of libraries for runtime. */ + @CanIgnoreReturnValue + CelBuilder addRuntimeLibraries(Iterable libraries); + + /** + * Override the standard declarations for the type-checker. This can be used to subset the + * standard environment to only expose the desired declarations to the type-checker. {@link + * #setStandardEnvironmentEnabled(boolean)} must be set to false for this to take effect. + */ + @CanIgnoreReturnValue + CelBuilder setStandardDeclarations(CelStandardDeclarations standardDeclarations); + + /** + * Override the standard functions for the runtime. This can be used to subset the standard + * environment to only expose the desired function overloads to the runtime. + * + *

{@link #setStandardEnvironmentEnabled(boolean)} must be set to false for this to take + * effect. + */ + @CanIgnoreReturnValue + CelBuilder setStandardFunctions(CelStandardFunctions standardFunctions); + + /** + * Sets a proto ExtensionRegistry to assist with unpacking Any messages containing a proto2 + extension field. + */ + @CanIgnoreReturnValue + CelBuilder setExtensionRegistry(ExtensionRegistry extensionRegistry); + + /** Construct a new {@code Cel} instance from the provided configuration. */ + Cel build(); +} diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java new file mode 100644 index 000000000..ccbaef61b --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java @@ -0,0 +1,1112 @@ +// Copyright 2025 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.bundle; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.auto.value.AutoValue; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector; +import dev.cel.checker.CelStandardDeclarations; +import dev.cel.checker.CelStandardDeclarations.StandardFunction; +import dev.cel.checker.CelStandardDeclarations.StandardOverload; +import dev.cel.checker.ProtoTypeMask; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelVarDecl; +import dev.cel.common.Source; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeParamType; +import dev.cel.common.types.TypeType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerBuilder; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.extensions.CelExtensions; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeLibrary; +import java.util.Arrays; +import java.util.Optional; +import java.util.function.ObjIntConsumer; + +/** + * CelEnvironment is a native representation of a CEL environment for compiler and runtime. This + * object is amenable to being serialized into YAML, textproto or other formats as needed. + */ +@AutoValue +public abstract class CelEnvironment { + + @VisibleForTesting + static final ImmutableMap CEL_EXTENSION_CONFIG_MAP = + ImmutableMap.of( + "bindings", CanonicalCelExtension.BINDINGS, + "encoders", CanonicalCelExtension.ENCODERS, + "lists", CanonicalCelExtension.LISTS, + "math", CanonicalCelExtension.MATH, + "optional", CanonicalCelExtension.OPTIONAL, + "protos", CanonicalCelExtension.PROTOS, + "regex", CanonicalCelExtension.REGEX, + "sets", CanonicalCelExtension.SETS, + "strings", CanonicalCelExtension.STRINGS, + "two-var-comprehensions", CanonicalCelExtension.COMPREHENSIONS); + + private static final ImmutableMap> LIMIT_HANDLERS = + ImmutableMap.of( + "cel.limit.expression_code_points", + CelOptions.Builder::maxExpressionCodePointSize, + "cel.limit.parse_error_recovery", + CelOptions.Builder::maxParseErrorRecoveryLimit, + "cel.limit.parse_recursion_depth", + CelOptions.Builder::maxParseRecursionDepth); + + private static final ImmutableMap FEATURE_HANDLERS = + ImmutableMap.of( + "cel.feature.macro_call_tracking", + CelOptions.Builder::populateMacroCalls, + "cel.feature.backtick_escape_syntax", + CelOptions.Builder::enableQuotedIdentifierSyntax, + "cel.feature.cross_type_numeric_comparisons", + CelOptions.Builder::enableHeterogeneousNumericComparisons); + + /** Environment source in textual format (ex: textproto, YAML). */ + public abstract Optional source(); + + /** Name of the environment. */ + public abstract String name(); + + /** Container, which captures default namespace and aliases for value resolution. */ + public abstract Optional container(); + + /** + * An optional description of the environment (example: location of the file containing the config + * content). + */ + public abstract String description(); + + /** Converts this {@code CelEnvironment} object into a builder. */ + public abstract Builder toBuilder(); + + /** + * Canonical extensions to enable in the environment, such as Optional, String and Math + * extensions. + */ + public abstract ImmutableSet extensions(); + + /** New variable declarations to add in the compilation environment. */ + public abstract ImmutableSet variables(); + + /** New function declarations to add in the compilation environment. */ + public abstract ImmutableSet functions(); + + /** Standard library subset (which macros, functions to include/exclude) */ + public abstract Optional standardLibrarySubset(); + + /** Feature flags to enable in the environment. */ + public abstract ImmutableSet features(); + + /** Limits to set in the environment. */ + public abstract ImmutableSet limits(); + + /** Context variable to enable in the environment. */ + public abstract Optional contextVariable(); + + /** Builder for {@link CelEnvironment}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract ImmutableSet.Builder extensionsBuilder(); + + // For testing only, to empty out the source. + abstract Builder setSource(Optional source); + + public abstract Builder setSource(Source source); + + public abstract Builder setName(String name); + + public abstract Builder setDescription(String description); + + public abstract Builder setContainer(CelContainer container); + + @CanIgnoreReturnValue + public Builder setContainer(String container) { + return setContainer(CelContainer.ofName(container)); + } + + @CanIgnoreReturnValue + public Builder addExtensions(ExtensionConfig... extensions) { + checkNotNull(extensions); + return addExtensions(Arrays.asList(extensions)); + } + + @CanIgnoreReturnValue + public Builder addExtensions(Iterable extensions) { + checkNotNull(extensions); + this.extensionsBuilder().addAll(extensions); + return this; + } + + @CanIgnoreReturnValue + public Builder setVariables(VariableDecl... variables) { + return setVariables(ImmutableSet.copyOf(variables)); + } + + public abstract Builder setVariables(ImmutableSet variables); + + @CanIgnoreReturnValue + public Builder setFunctions(FunctionDecl... functions) { + return setFunctions(ImmutableSet.copyOf(functions)); + } + + public abstract Builder setFunctions(ImmutableSet functions); + + public abstract Builder setStandardLibrarySubset(LibrarySubset stdLibrarySubset); + + @CanIgnoreReturnValue + public Builder setFeatures(FeatureFlag... featureFlags) { + return setFeatures(ImmutableSet.copyOf(featureFlags)); + } + + public abstract Builder setFeatures(ImmutableSet featureFlags); + + @CanIgnoreReturnValue + public Builder setLimits(Limit... limits) { + return setLimits(ImmutableSet.copyOf(limits)); + } + + public abstract Builder setLimits(ImmutableSet limits); + + public abstract Builder setContextVariable(ContextVariable contextVariable); + + abstract CelEnvironment autoBuild(); + + @CheckReturnValue + public final CelEnvironment build() { + CelEnvironment env = autoBuild(); + LibrarySubset librarySubset = env.standardLibrarySubset().orElse(null); + if (librarySubset != null) { + if (!librarySubset.includedMacros().isEmpty() + && !librarySubset.excludedMacros().isEmpty()) { + throw new IllegalArgumentException( + "Invalid subset: cannot both include and exclude macros"); + } + if (!librarySubset.includedFunctions().isEmpty() + && !librarySubset.excludedFunctions().isEmpty()) { + throw new IllegalArgumentException( + "Invalid subset: cannot both include and exclude functions"); + } + } + return env; + } + } + + /** Creates a new builder to construct a {@link CelEnvironment} instance. */ + public static Builder newBuilder() { + return new AutoValue_CelEnvironment.Builder() + .setName("") + .setDescription("") + .setVariables(ImmutableSet.of()) + .setFunctions(ImmutableSet.of()) + .setFeatures(ImmutableSet.of()) + .setLimits(ImmutableSet.of()); + } + + /** Extends the provided {@link CelCompiler} environment with this configuration. */ + public CelCompiler extend(CelCompiler celCompiler, CelOptions celOptions) + throws CelEnvironmentException { + celOptions = applyEnvironmentOptions(celOptions); + try { + CelTypeProvider celTypeProvider = celCompiler.getTypeProvider(); + CelCompilerBuilder compilerBuilder = + celCompiler + .toCompilerBuilder() + .setOptions(celOptions) + .setTypeProvider(celTypeProvider) + .addVarDeclarations( + variables().stream() + .map(v -> v.toCelVarDecl(celTypeProvider)) + .collect(toImmutableList())) + .addFunctionDeclarations( + functions().stream() + .map(f -> f.toCelFunctionDecl(celTypeProvider)) + .collect(toImmutableList())); + + container().ifPresent(compilerBuilder::setContainer); + + addAllCompilerExtensions(compilerBuilder, celOptions); + + applyStandardLibrarySubset(compilerBuilder); + + contextVariable() + .ifPresent( + cv -> + compilerBuilder.addProtoTypeMasks( + ProtoTypeMask.ofAllFields(cv.typeName()).withFieldsAsVariableDeclarations())); + + return compilerBuilder.build(); + } catch (RuntimeException e) { + throw new CelEnvironmentException(e.getMessage(), e); + } + } + + /** Extends the provided {@link Cel} environment with this configuration. */ + public Cel extend(Cel cel, CelOptions celOptions) throws CelEnvironmentException { + celOptions = applyEnvironmentOptions(celOptions); + try { + // Casting is necessary to only extend the compiler here + CelCompiler celCompiler = extend((CelCompiler) cel, celOptions); + + CelRuntime celRuntime = extendRuntime(cel, celOptions); + + return CelFactory.combine(celCompiler, celRuntime); + } catch (RuntimeException e) { + throw new CelEnvironmentException(e.getMessage(), e); + } + } + + private CelOptions applyEnvironmentOptions(CelOptions celOptions) { + CelOptions.Builder optionsBuilder = celOptions.toBuilder(); + for (FeatureFlag featureFlag : features()) { + BooleanOptionConsumer consumer = FEATURE_HANDLERS.get(featureFlag.name()); + if (consumer == null) { + throw new IllegalArgumentException("Unknown feature flag: " + featureFlag.name()); + } + consumer.accept(optionsBuilder, featureFlag.enabled()); + } + for (Limit limit : limits()) { + int value = limit.value() < 0 ? -1 : limit.value(); + ObjIntConsumer consumer = LIMIT_HANDLERS.get(limit.name()); + if (consumer == null) { + throw new IllegalArgumentException("Unknown limit: " + limit.name()); + } + consumer.accept(optionsBuilder, value); + } + return optionsBuilder.build(); + } + + private void addAllCompilerExtensions( + CelCompilerBuilder celCompilerBuilder, CelOptions celOptions) { + // TODO: Add capability to accept user defined exceptions + for (ExtensionConfig extensionConfig : extensions()) { + CanonicalCelExtension extension = getExtensionOrThrow(extensionConfig.name()); + if (extension.compilerExtensionProvider() != null) { + CelCompilerLibrary celCompilerLibrary = + extension + .compilerExtensionProvider() + .getCelCompilerLibrary(celOptions, extensionConfig.version()); + celCompilerBuilder.addLibraries(celCompilerLibrary); + } + } + } + + private CelRuntime extendRuntime(CelRuntime celRuntime, CelOptions celOptions) { + CelRuntimeBuilder celRuntimeBuilder = celRuntime.toRuntimeBuilder(); + celRuntimeBuilder.setOptions(celOptions); + // TODO: Add capability to accept user defined exceptions + for (ExtensionConfig extensionConfig : extensions()) { + CanonicalCelExtension extension = getExtensionOrThrow(extensionConfig.name()); + if (extension.runtimeExtensionProvider() != null) { + CelRuntimeLibrary celRuntimeLibrary = + extension + .runtimeExtensionProvider() + .getCelRuntimeLibrary(celOptions, extensionConfig.version()); + celRuntimeBuilder.addLibraries(celRuntimeLibrary); + } + } + return celRuntimeBuilder.build(); + } + + private void applyStandardLibrarySubset(CelCompilerBuilder compilerBuilder) { + if (!standardLibrarySubset().isPresent()) { + return; + } + + LibrarySubset librarySubset = standardLibrarySubset().get(); + if (librarySubset.disabled()) { + compilerBuilder.setStandardEnvironmentEnabled(false); + return; + } + + if (librarySubset.macrosDisabled()) { + compilerBuilder.setStandardMacros(ImmutableList.of()); + } else if (!librarySubset.includedMacros().isEmpty()) { + compilerBuilder.setStandardMacros( + librarySubset.includedMacros().stream() + .flatMap(name -> getStandardMacrosOrThrow(name).stream()) + .collect(toImmutableSet())); + } else if (!librarySubset.excludedMacros().isEmpty()) { + ImmutableSet set = + librarySubset.excludedMacros().stream() + .flatMap(name -> getStandardMacrosOrThrow(name).stream()) + .collect(toImmutableSet()); + compilerBuilder.setStandardMacros( + CelStandardMacro.STANDARD_MACROS.stream() + .filter(macro -> !set.contains(macro)) + .collect(toImmutableSet())); + } + + if (!librarySubset.includedFunctions().isEmpty()) { + ImmutableSet includedFunctions = librarySubset.includedFunctions(); + compilerBuilder + .setStandardEnvironmentEnabled(false) + .setStandardDeclarations( + CelStandardDeclarations.newBuilder() + .filterFunctions( + (function, overload) -> + FunctionSelector.matchesAny(function, overload, includedFunctions)) + .build()); + } else if (!librarySubset.excludedFunctions().isEmpty()) { + ImmutableSet excludedFunctions = librarySubset.excludedFunctions(); + compilerBuilder + .setStandardEnvironmentEnabled(false) + .setStandardDeclarations( + CelStandardDeclarations.newBuilder() + .filterFunctions( + (function, overload) -> + !FunctionSelector.matchesAny(function, overload, excludedFunctions)) + .build()); + } + } + + private static ImmutableSet getStandardMacrosOrThrow(String macroName) { + ImmutableSet.Builder builder = ImmutableSet.builder(); + for (CelStandardMacro macro : CelStandardMacro.STANDARD_MACROS) { + if (macro.getFunction().equals(macroName)) { + builder.add(macro); + } + } + ImmutableSet macros = builder.build(); + if (macros.isEmpty()) { + throw new IllegalArgumentException("unrecognized standard macro `" + macroName + "'"); + } + return macros; + } + + private static CanonicalCelExtension getExtensionOrThrow(String extensionName) { + CanonicalCelExtension extension = CEL_EXTENSION_CONFIG_MAP.get(extensionName); + if (extension == null) { + throw new IllegalArgumentException("Unrecognized extension: " + extensionName); + } + + return extension; + } + + /** Represents a context variable declaration. */ + @AutoValue + public abstract static class ContextVariable { + /** Fully qualified type name of the context variable. */ + public abstract String typeName(); + + public static ContextVariable create(String typeName) { + return new AutoValue_CelEnvironment_ContextVariable(typeName); + } + } + + /** Represents a policy variable declaration. */ + @AutoValue + public abstract static class VariableDecl { + + /** Fully qualified variable name. */ + public abstract String name(); + + /** The type of the variable. */ + public abstract TypeDecl type(); + + public abstract Optional description(); + + /** Builder for {@link VariableDecl}. */ + @AutoValue.Builder + public abstract static class Builder implements RequiredFieldsChecker { + + public abstract Optional name(); + + public abstract Optional type(); + + public abstract VariableDecl.Builder setName(String name); + + public abstract VariableDecl.Builder setType(TypeDecl typeDecl); + + public abstract VariableDecl.Builder setDescription(String name); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of( + RequiredField.of("name", this::name), RequiredField.of("type", this::type)); + } + + /** Builds a new instance of {@link VariableDecl}. */ + public abstract VariableDecl build(); + } + + public static VariableDecl.Builder newBuilder() { + return new AutoValue_CelEnvironment_VariableDecl.Builder(); + } + + /** Creates a new builder to construct a {@link VariableDecl} instance. */ + public static VariableDecl create(String name, TypeDecl type) { + return newBuilder().setName(name).setType(type).build(); + } + + /** Converts this policy variable declaration into a {@link CelVarDecl}. */ + public CelVarDecl toCelVarDecl(CelTypeProvider celTypeProvider) { + return CelVarDecl.newVarDeclaration(name(), type().toCelType(celTypeProvider)); + } + } + + /** Represents a policy function declaration. */ + @AutoValue + public abstract static class FunctionDecl { + + public abstract String name(); + + public abstract Optional description(); + + public abstract ImmutableSet overloads(); + + /** Builder for {@link FunctionDecl}. */ + @AutoValue.Builder + public abstract static class Builder implements RequiredFieldsChecker { + + public abstract Optional name(); + + public abstract Optional> overloads(); + + public abstract FunctionDecl.Builder setName(String name); + + public abstract FunctionDecl.Builder setDescription(String description); + + public abstract FunctionDecl.Builder setOverloads(ImmutableSet overloads); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of( + RequiredField.of("name", this::name), RequiredField.of("overloads", this::overloads)); + } + + /** Builds a new instance of {@link FunctionDecl}. */ + public abstract FunctionDecl build(); + } + + /** Creates a new builder to construct a {@link FunctionDecl} instance. */ + public static FunctionDecl.Builder newBuilder() { + return new AutoValue_CelEnvironment_FunctionDecl.Builder(); + } + + /** Creates a new {@link FunctionDecl} with the provided function name and its overloads. */ + public static FunctionDecl create(String name, ImmutableSet overloads) { + return newBuilder().setName(name).setOverloads(overloads).build(); + } + + /** Converts this policy function declaration into a {@link CelFunctionDecl}. */ + public CelFunctionDecl toCelFunctionDecl(CelTypeProvider celTypeProvider) { + return CelFunctionDecl.newFunctionDeclaration( + name(), + overloads().stream() + .map(o -> o.toCelOverloadDecl(celTypeProvider)) + .collect(toImmutableList())); + } + } + + /** Represents an overload declaration on a policy function. */ + @AutoValue + public abstract static class OverloadDecl { + + /** + * A unique overload ID. Required. This should follow the typical naming convention used in CEL + * (e.g: targetType_func_argType1_argType...) + */ + public abstract String id(); + + /** Target of the function overload if it's a receiver style (example: foo in `foo.f(...)`) */ + public abstract Optional target(); + + /** List of function overload type values. */ + public abstract ImmutableList arguments(); + + /** Examples for the overload. */ + public abstract ImmutableList examples(); + + /** Return type of the overload. Required. */ + public abstract TypeDecl returnType(); + + /** Builder for {@link OverloadDecl}. */ + @AutoValue.Builder + public abstract static class Builder implements RequiredFieldsChecker { + + public abstract Optional id(); + + public abstract Optional returnType(); + + public abstract OverloadDecl.Builder setId(String overloadId); + + public abstract OverloadDecl.Builder setTarget(TypeDecl target); + + // This should stay package-private to encourage add/set methods to be used instead. + abstract ImmutableList.Builder argumentsBuilder(); + + abstract ImmutableList.Builder examplesBuilder(); + + public abstract OverloadDecl.Builder setArguments(ImmutableList args); + + @CanIgnoreReturnValue + public OverloadDecl.Builder addExamples(Iterable examples) { + this.examplesBuilder().addAll(checkNotNull(examples)); + return this; + } + + @CanIgnoreReturnValue + public OverloadDecl.Builder addExamples(String... examples) { + return addExamples(Arrays.asList(examples)); + } + + @CanIgnoreReturnValue + public OverloadDecl.Builder addArguments(Iterable args) { + this.argumentsBuilder().addAll(checkNotNull(args)); + return this; + } + + @CanIgnoreReturnValue + public OverloadDecl.Builder addArguments(TypeDecl... args) { + return addArguments(Arrays.asList(args)); + } + + public abstract OverloadDecl.Builder setReturnType(TypeDecl returnType); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of( + RequiredField.of("id", this::id), RequiredField.of("return", this::returnType)); + } + + /** Builds a new instance of {@link OverloadDecl}. */ + @CheckReturnValue + public abstract OverloadDecl build(); + } + + /** Creates a new builder to construct a {@link OverloadDecl} instance. */ + public static OverloadDecl.Builder newBuilder() { + return new AutoValue_CelEnvironment_OverloadDecl.Builder().setArguments(ImmutableList.of()); + } + + /** Converts this policy function overload into a {@link CelOverloadDecl}. */ + public CelOverloadDecl toCelOverloadDecl(CelTypeProvider celTypeProvider) { + CelOverloadDecl.Builder builder = + CelOverloadDecl.newBuilder() + .setIsInstanceFunction(false) + .setOverloadId(id()) + .setResultType(returnType().toCelType(celTypeProvider)); + + target() + .ifPresent( + t -> + builder + .setIsInstanceFunction(true) + .addParameterTypes(t.toCelType(celTypeProvider))); + + for (TypeDecl type : arguments()) { + builder.addParameterTypes(type.toCelType(celTypeProvider)); + } + + return builder.build(); + } + } + + /** + * Represents an abstract type declaration used to declare functions and variables in a policy. + */ + @AutoValue + public abstract static class TypeDecl { + + public abstract String name(); + + public abstract ImmutableList params(); + + public abstract boolean isTypeParam(); + + /** Builder for {@link TypeDecl}. */ + @AutoValue.Builder + public abstract static class Builder implements RequiredFieldsChecker { + + public abstract Optional name(); + + public abstract TypeDecl.Builder setName(String name); + + // This should stay package-private to encourage add/set methods to be used instead. + abstract ImmutableList.Builder paramsBuilder(); + + public abstract TypeDecl.Builder setParams(ImmutableList typeDecls); + + @CanIgnoreReturnValue + public TypeDecl.Builder addParams(TypeDecl... params) { + return addParams(Arrays.asList(params)); + } + + @CanIgnoreReturnValue + public TypeDecl.Builder addParams(Iterable params) { + this.paramsBuilder().addAll(checkNotNull(params)); + return this; + } + + public abstract TypeDecl.Builder setIsTypeParam(boolean isTypeParam); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of(RequiredField.of("type_name", this::name)); + } + + @CheckReturnValue + public abstract TypeDecl build(); + } + + /** Creates a new {@link TypeDecl} with the provided name. */ + public static TypeDecl create(String name) { + return newBuilder().setName(name).build(); + } + + public static TypeDecl.Builder newBuilder() { + return new AutoValue_CelEnvironment_TypeDecl.Builder().setIsTypeParam(false); + } + + /** Converts this type declaration into a {@link CelType}. */ + public CelType toCelType(CelTypeProvider celTypeProvider) { + switch (name()) { + case "list": + if (params().size() != 1) { + throw new IllegalArgumentException( + "List type has unexpected param count: " + params().size()); + } + + CelType elementType = params().get(0).toCelType(celTypeProvider); + return ListType.create(elementType); + case "map": + if (params().size() != 2) { + throw new IllegalArgumentException( + "Map type has unexpected param count: " + params().size()); + } + + CelType keyType = params().get(0).toCelType(celTypeProvider); + CelType valueType = params().get(1).toCelType(celTypeProvider); + return MapType.create(keyType, valueType); + case "type": + checkState( + params().size() == 1, "Expected 1 parameter for type, got %s", params().size()); + return TypeType.create(params().get(0).toCelType(celTypeProvider)); + default: + if (isTypeParam()) { + return TypeParamType.create(name()); + } + + if (name().equals("dyn")) { + return SimpleType.DYN; + } + + CelType simpleType = SimpleType.findByName(name()).orElse(null); + if (simpleType != null) { + return simpleType; + } + + if (name().equals(OptionalType.NAME)) { + checkState( + params().size() == 1, + "Optional type must have exactly 1 parameter. Found %s", + params().size()); + return OptionalType.create(params().get(0).toCelType(celTypeProvider)); + } + + return celTypeProvider + .findType(name()) + .orElseThrow(() -> new IllegalArgumentException("Undefined type name: " + name())); + } + } + } + + /** Represents a feature flag that can be enabled in the environment. */ + @AutoValue + public abstract static class FeatureFlag { + /** Normalized name of the feature flag. */ + public abstract String name(); + + /** Whether the feature is enabled or disabled. */ + public abstract boolean enabled(); + + public static FeatureFlag create(String name, boolean enabled) { + return new AutoValue_CelEnvironment_FeatureFlag(name, enabled); + } + } + + /** + * Represents a configurable limit in the environment. + * + *

A negative value indicates no limit. If not specified, the limit should be set to the + * library default. + */ + @AutoValue + public abstract static class Limit { + /** Normalized name of the limit (e.g. cel.limit.expression_code_points */ + public abstract String name(); + + /** The value of the limit, -1 means no limit. */ + public abstract int value(); + + public static Limit create(String name, int value) { + return new AutoValue_CelEnvironment_Limit(name, value); + } + } + + /** + * Represents a configuration for a canonical CEL extension that can be enabled in the + * environment. + */ + @AutoValue + public abstract static class ExtensionConfig { + + /** Name of the extension (ex: bindings, optional, math, etc).". */ + public abstract String name(); + + /** + * Version of the extension. Presently, this field is ignored as CEL-Java extensions are not + * versioned. + */ + public abstract int version(); + + /** Builder for {@link ExtensionConfig}. */ + @AutoValue.Builder + public abstract static class Builder implements RequiredFieldsChecker { + + public abstract Optional name(); + + public abstract Optional version(); + + public abstract ExtensionConfig.Builder setName(String name); + + public abstract ExtensionConfig.Builder setVersion(int version); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of(RequiredField.of("name", this::name)); + } + + /** Builds a new instance of {@link ExtensionConfig}. */ + public abstract ExtensionConfig build(); + } + + /** Creates a new builder to construct a {@link ExtensionConfig} instance. */ + public static ExtensionConfig.Builder newBuilder() { + return new AutoValue_CelEnvironment_ExtensionConfig.Builder().setVersion(0); + } + + /** Create a new extension config with the specified name and version set to 0. */ + public static ExtensionConfig of(String name) { + return of(name, 0); + } + + /** Create a new extension config with the specified name and version. */ + public static ExtensionConfig of(String name, int version) { + return newBuilder().setName(name).setVersion(version).build(); + } + + /** Create a new extension config with the specified name and the latest version. */ + public static ExtensionConfig latest(String name) { + return of(name, Integer.MAX_VALUE); + } + } + + @AutoValue + abstract static class Alias { + abstract String alias(); + + abstract String qualifiedName(); + + static Builder newBuilder() { + return new AutoValue_CelEnvironment_Alias.Builder(); + } + + @AutoValue.Builder + abstract static class Builder implements RequiredFieldsChecker { + + abstract Optional alias(); + + abstract Optional qualifiedName(); + + abstract Builder setAlias(String alias); + + abstract Builder setQualifiedName(String qualifiedName); + + abstract Alias build(); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of( + RequiredField.of("alias", this::alias), + RequiredField.of("qualified_name", this::qualifiedName)); + } + } + } + + @VisibleForTesting + enum CanonicalCelExtension { + BINDINGS((options, version) -> CelExtensions.bindings()), + PROTOS((options, version) -> CelExtensions.protos()), + ENCODERS( + (options, version) -> CelExtensions.encoders(options), + (options, version) -> CelExtensions.encoders(options)), + MATH( + (options, version) -> CelExtensions.math(options, version), + (options, version) -> CelExtensions.math(options, version)), + OPTIONAL( + (options, version) -> CelExtensions.optional(version), + (options, version) -> CelExtensions.optional(version)), + STRINGS( + (options, version) -> CelExtensions.strings(), + (options, version) -> CelExtensions.strings()), + SETS( + (options, version) -> CelExtensions.sets(options), + (options, version) -> CelExtensions.sets(options)), + REGEX((options, version) -> CelExtensions.regex(), (options, version) -> CelExtensions.regex()), + LISTS((options, version) -> CelExtensions.lists(), (options, version) -> CelExtensions.lists()), + COMPREHENSIONS( + (options, version) -> CelExtensions.comprehensions(), + (options, version) -> CelExtensions.comprehensions()); + + @SuppressWarnings("ImmutableEnumChecker") + private final CompilerExtensionProvider compilerExtensionProvider; + + @SuppressWarnings("ImmutableEnumChecker") + private final RuntimeExtensionProvider runtimeExtensionProvider; + + interface CompilerExtensionProvider { + CelCompilerLibrary getCelCompilerLibrary(CelOptions options, int version); + } + + interface RuntimeExtensionProvider { + CelRuntimeLibrary getCelRuntimeLibrary(CelOptions options, int version); + } + + CompilerExtensionProvider compilerExtensionProvider() { + return compilerExtensionProvider; + } + + RuntimeExtensionProvider runtimeExtensionProvider() { + return runtimeExtensionProvider; + } + + CanonicalCelExtension(CompilerExtensionProvider compilerExtensionProvider) { + this.compilerExtensionProvider = compilerExtensionProvider; + this.runtimeExtensionProvider = null; // Not all extensions augment the runtime. + } + + CanonicalCelExtension( + CompilerExtensionProvider compilerExtensionProvider, + RuntimeExtensionProvider runtimeExtensionProvider) { + this.compilerExtensionProvider = compilerExtensionProvider; + this.runtimeExtensionProvider = runtimeExtensionProvider; + } + } + + /** + * LibrarySubset indicates a subset of the macros and function supported by a subsettable library. + */ + @AutoValue + public abstract static class LibrarySubset { + + /** + * Disabled indicates whether the library has been disabled, typically only used for + * default-enabled libraries like stdlib. + */ + public abstract boolean disabled(); + + /** DisableMacros disables macros for the given library. */ + public abstract boolean macrosDisabled(); + + /** IncludeMacros specifies a set of macro function names to include in the subset. */ + public abstract ImmutableSet includedMacros(); + + /** + * ExcludeMacros specifies a set of macro function names to exclude from the subset. + * + *

Note: if IncludedMacros is non-empty, then ExcludedMacros is ignored. + */ + public abstract ImmutableSet excludedMacros(); + + /** + * IncludeFunctions specifies a set of functions to include in the subset. + * + *

Note: the overloads specified in the subset need only specify their ID. + * + *

Note: if IncludedFunctions is non-empty, then ExcludedFunctions is ignored. + */ + public abstract ImmutableSet includedFunctions(); + + /** + * ExcludeFunctions specifies the set of functions to exclude from the subset. + * + *

Note: the overloads specified in the subset need only specify their ID. + */ + public abstract ImmutableSet excludedFunctions(); + + public static Builder newBuilder() { + return new AutoValue_CelEnvironment_LibrarySubset.Builder() + .setMacrosDisabled(false) + .setIncludedMacros(ImmutableSet.of()) + .setExcludedMacros(ImmutableSet.of()) + .setIncludedFunctions(ImmutableSet.of()) + .setExcludedFunctions(ImmutableSet.of()); + } + + /** Builder for {@link LibrarySubset}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setDisabled(boolean disabled); + + public abstract Builder setMacrosDisabled(boolean disabled); + + public abstract Builder setIncludedMacros(ImmutableSet includedMacros); + + public abstract Builder setExcludedMacros(ImmutableSet excludedMacros); + + public abstract Builder setIncludedFunctions( + ImmutableSet includedFunctions); + + public abstract Builder setExcludedFunctions( + ImmutableSet excludedFunctions); + + @CheckReturnValue + public abstract LibrarySubset build(); + } + + /** + * Represents a function selector, which can be used to configure included/excluded library + * functions. + */ + @AutoValue + public abstract static class FunctionSelector { + + public abstract String name(); + + public abstract ImmutableSet overloads(); + + /** Builder for {@link FunctionSelector}. */ + @AutoValue.Builder + public abstract static class Builder implements RequiredFieldsChecker { + + public abstract Optional name(); + + public abstract Builder setName(String name); + + public abstract Builder setOverloads(ImmutableSet overloads); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of(RequiredField.of("name", this::name)); + } + + /** Builds a new instance of {@link FunctionSelector}. */ + public abstract FunctionSelector build(); + } + + /** Creates a new builder to construct a {@link FunctionSelector} instance. */ + public static FunctionSelector.Builder newBuilder() { + return new AutoValue_CelEnvironment_LibrarySubset_FunctionSelector.Builder() + .setOverloads(ImmutableSet.of()); + } + + public static FunctionSelector create(String name, ImmutableSet overloads) { + return newBuilder() + .setName(name) + .setOverloads( + overloads.stream() + .map(id -> OverloadSelector.newBuilder().setId(id).build()) + .collect(toImmutableSet())) + .build(); + } + + private static boolean matchesAny( + StandardFunction function, + StandardOverload overload, + ImmutableSet selectors) { + String functionName = function.functionDecl().name(); + for (FunctionSelector functionSelector : selectors) { + if (!functionSelector.name().equals(functionName)) { + continue; + } + + if (functionSelector.overloads().isEmpty()) { + return true; + } + + String overloadId = overload.celOverloadDecl().overloadId(); + for (OverloadSelector overloadSelector : functionSelector.overloads()) { + if (overloadSelector.id().equals(overloadId)) { + return true; + } + } + } + return false; + } + } + + /** Represents an overload selector on a function selector. */ + @AutoValue + public abstract static class OverloadSelector { + + /** An overload ID. Required. Follows the same format as {@link OverloadDecl#id()} */ + public abstract String id(); + + /** Builder for {@link OverloadSelector}. */ + @AutoValue.Builder + public abstract static class Builder implements RequiredFieldsChecker { + + public abstract Optional id(); + + public abstract Builder setId(String overloadId); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of(RequiredField.of("id", this::id)); + } + + /** Builds a new instance of {@link OverloadSelector}. */ + @CheckReturnValue + public abstract OverloadSelector build(); + } + + /** Creates a new builder to construct a {@link OverloadSelector} instance. */ + public static OverloadSelector.Builder newBuilder() { + return new AutoValue_CelEnvironment_LibrarySubset_OverloadSelector.Builder(); + } + } + } + + @FunctionalInterface + private interface BooleanOptionConsumer { + void accept(CelOptions.Builder options, boolean value); + } +} diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentException.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentException.java new file mode 100644 index 000000000..58bb5cdb9 --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentException.java @@ -0,0 +1,29 @@ +// Copyright 2025 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.bundle; + +import dev.cel.common.CelException; + +/** Checked exception thrown when a CEL environment is misconfigured. */ +public final class CelEnvironmentException extends CelException { + + CelEnvironmentException(String message) { + super(message); + } + + CelEnvironmentException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java new file mode 100644 index 000000000..d233fd36f --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java @@ -0,0 +1,520 @@ +// Copyright 2025 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.bundle; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static java.util.Arrays.stream; + +import dev.cel.expr.Decl; +import dev.cel.expr.Decl.FunctionDecl; +import dev.cel.expr.Decl.FunctionDecl.Overload; +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.ListMultimap; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.bundle.CelEnvironment.ExtensionConfig; +import dev.cel.bundle.CelEnvironment.LibrarySubset; +import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector; +import dev.cel.bundle.CelEnvironment.OverloadDecl; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.checker.CelStandardDeclarations.StandardFunction; +import dev.cel.checker.CelStandardDeclarations.StandardIdentifier; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelVarDecl; +import dev.cel.common.internal.EnvVisitable; +import dev.cel.common.internal.EnvVisitor; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.compiler.CelCompiler; +import dev.cel.extensions.CelExtensionLibrary; +import dev.cel.extensions.CelExtensions; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelStandardMacro; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * {@code CelEnvironmentExporter} can be used to export the configuration of a {@link Cel} instance + * as a {@link CelEnvironment} object. + * + *

This exporter captures details such as: + * + *

    + *
  • Standard library subset: Functions and their overloads that are either included or + * excluded. + *
  • Extension libraries: Names and versions of the extension libraries in use. + *
  • Custom declarations: Functions and variables not part of standard or extension libraries. + *
+ * + *

The exporter provides options to control the behavior of the export process, such as the + * maximum number of excluded standard functions and overloads before switching to an inclusion + * strategy. + */ +@AutoValue +public abstract class CelEnvironmentExporter { + + /** + * Maximum number of excluded standard functions and macros before switching to a format that + * enumerates all included functions and macros. The default is 5. + * + *

This setting is primarily for stylistic preferences and the intended use of the resulting + * YAML file. + * + *

For example, if you want almost all the standard library with only a few exceptions (e.g., + * to ban a specific function), you would favor an exclusion-based approach by setting an + * appropriate threshold. + * + *

If you want full control over what is available to the CEL runtime, where no function is + * included unless fully vetted, you would favor an inclusion-based approach by setting the + * threshold to 0. This may result in a more verbose YAML file. + */ + abstract int maxExcludedStandardFunctions(); + + /** + * Maximum number of excluded standard function overloads before switching to a exhaustive + * enumeration of included overloads. The default is 15. + */ + abstract int maxExcludedStandardFunctionOverloads(); + + abstract ImmutableSet> + extensionLibraries(); + + /** Builder for {@link CelEnvironmentExporter}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setMaxExcludedStandardFunctions(int count); + + public abstract Builder setMaxExcludedStandardFunctionOverloads(int count); + + abstract ImmutableSet.Builder> + extensionLibrariesBuilder(); + + @CanIgnoreReturnValue + public Builder addStandardExtensions(CelOptions options) { + addExtensionLibraries( + CelExtensions.getExtensionLibrary("bindings", options), + CelExtensions.getExtensionLibrary("encoders", options), + CelExtensions.getExtensionLibrary("lists", options), + CelExtensions.getExtensionLibrary("math", options), + CelExtensions.getExtensionLibrary("protos", options), + CelExtensions.getExtensionLibrary("regex", options), + CelExtensions.getExtensionLibrary("sets", options), + CelExtensions.getExtensionLibrary("strings", options)); + // TODO: add support for remaining standard extensions + return this; + } + + @CanIgnoreReturnValue + public Builder addExtensionLibraries( + CelExtensionLibrary... libraries) { + extensionLibrariesBuilder().add(libraries); + return this; + } + + abstract CelEnvironmentExporter autoBuild(); + + public CelEnvironmentExporter build() { + return autoBuild(); + } + } + + /** Creates a new builder to construct a {@link CelEnvironmentExporter} instance. */ + public static CelEnvironmentExporter.Builder newBuilder() { + return new AutoValue_CelEnvironmentExporter.Builder() + .setMaxExcludedStandardFunctions(5) + .setMaxExcludedStandardFunctionOverloads(15); + } + + /** + * Exports a {@link CelEnvironment} that describes the configuration of the given {@link Cel} + * instance. + * + *

The exported environment includes: + * + *

    + *
  • Standard library subset: functions and their overloads that are either included or + * excluded from the standard library. + *
  • Extension libraries: names and versions of the extension libraries that are used. + *
  • Custom declarations: functions and variables that are not part of the standard library or + * any of the extension libraries. + *
+ */ + public CelEnvironment export(Cel cel) { + return export((CelCompiler) cel); + } + + /** + * Exports a {@link CelEnvironment} that describes the configuration of the given {@link + * CelCompiler} instance. + * + *

The exported environment includes: + * + *

    + *
  • Standard library subset: functions and their overloads that are either included or + * excluded from the standard library. + *
  • Extension libraries: names and versions of the extension libraries that are used. + *
  • Custom declarations: functions and variables that are not part of the standard library or + * any of the extension libraries. + *
+ */ + public CelEnvironment export(CelCompiler cel) { + // Inventory is a full set of declarations and macros that are found in the configuration of + // the supplied CEL instance. + // + // Once we have the inventory, we attempt to identify sources of these declarations as + // standard library and extensions. The identified subsets will be removed from the inventory. + // + // Whatever is left will be included in the Environment as custom declarations. + + // Checker builder is used to access some parts of the config not exposed in the EnvVisitable + // interface. + CelCheckerBuilder checkerBuilder = cel.toCheckerBuilder(); + + CelEnvironment.Builder envBuilder = + CelEnvironment.newBuilder().setContainer(checkerBuilder.container()); + addOptions(envBuilder, checkerBuilder.options()); + + Set inventory = new HashSet<>(); + collectInventory(inventory, cel); + addExtensionConfigsAndRemoveFromInventory(envBuilder, inventory); + addStandardLibrarySubsetAndRemoveFromInventory(envBuilder, inventory); + addCustomDecls(envBuilder, inventory); + return envBuilder.build(); + } + + private void addOptions(CelEnvironment.Builder envBuilder, CelOptions options) { + // The set of features supported in the exported environment in Go is pretty limited right now. + ImmutableSet.Builder featureFlags = ImmutableSet.builder(); + if (options.enableHeterogeneousNumericComparisons()) { + featureFlags.add( + CelEnvironment.FeatureFlag.create("cel.feature.cross_type_numeric_comparisons", true)); + } + if (options.enableQuotedIdentifierSyntax()) { + featureFlags.add( + CelEnvironment.FeatureFlag.create("cel.feature.backtick_escape_syntax", true)); + } + if (options.populateMacroCalls()) { + featureFlags.add(CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true)); + } + envBuilder.setFeatures(featureFlags.build()); + ImmutableSet.Builder limits = ImmutableSet.builder(); + if (options.maxExpressionCodePointSize() != CelOptions.DEFAULT.maxExpressionCodePointSize()) { + limits.add( + CelEnvironment.Limit.create( + "cel.limit.expression_code_points", options.maxExpressionCodePointSize())); + } + if (options.maxParseErrorRecoveryLimit() != CelOptions.DEFAULT.maxParseErrorRecoveryLimit()) { + limits.add( + CelEnvironment.Limit.create( + "cel.limit.parse_error_recovery", options.maxParseErrorRecoveryLimit())); + } + if (options.maxParseRecursionDepth() != CelOptions.DEFAULT.maxParseRecursionDepth()) { + limits.add( + CelEnvironment.Limit.create( + "cel.limit.parse_recursion_depth", options.maxParseRecursionDepth())); + } + envBuilder.setLimits(limits.build()); + } + + /** + * Collects all function overloads, variable declarations and macros from the given {@link Cel} + * instance and stores them in a map. + */ + private void collectInventory(Set inventory, CelCompiler cel) { + Preconditions.checkArgument(cel instanceof EnvVisitable); + ((EnvVisitable) cel) + .accept( + new EnvVisitor() { + @Override + public void visitDecl(String name, List decls) { + for (Decl decl : decls) { + if (decl.hasFunction()) { + FunctionDecl function = decl.getFunction(); + for (Overload overload : function.getOverloadsList()) { + inventory.add( + NamedOverload.create( + decl.getName(), CelOverloadDecl.overloadToCelOverload(overload))); + } + } else if (decl.hasIdent()) { + inventory.add( + CelVarDecl.newVarDeclaration( + decl.getName(), + CelProtoTypes.typeToCelType(decl.getIdent().getType()))); + } + } + } + + @Override + public void visitMacro(CelMacro macro) { + inventory.add(macro); + } + }); + } + + /** + * Iterates through the available extension libraries, checks if they are included in the + * inventory, and adds them to the environment builder. Only the highest version of a library is + * added to the builder. If the extension is identified, all corresponding items are removed from + * the inventory. + */ + private void addExtensionConfigsAndRemoveFromInventory( + CelEnvironment.Builder envBuilder, Set inventory) { + ArrayList featureSets = new ArrayList<>(); + + for (CelExtensionLibrary extensionLibrary : + extensionLibraries()) { + for (CelExtensionLibrary.FeatureSet featureSet : extensionLibrary.versions()) { + featureSets.add(NamedFeatureSet.create(extensionLibrary.name(), featureSet)); + } + } + + featureSets.sort( + Comparator.comparing(NamedFeatureSet::name) + .thenComparing(nfs -> nfs.featureSet().version()) + .reversed()); + + Set includedExtensions = new HashSet<>(); + for (NamedFeatureSet lib : featureSets) { + if (includedExtensions.contains(lib.name())) { + // We only need to infer the highest version library, so we can skip lower versions + continue; + } + + if (checkIfExtensionIsIncludedAndRemoveFromInventory(inventory, lib.featureSet())) { + envBuilder.addExtensions(ExtensionConfig.of(lib.name(), lib.featureSet().version())); + includedExtensions.add(lib.name()); + } + } + } + + private boolean checkIfExtensionIsIncludedAndRemoveFromInventory( + Set inventory, CelExtensionLibrary.FeatureSet featureSet) { + ImmutableSet functions = featureSet.functions(); + ArrayList includedFeatures = new ArrayList<>(functions.size()); + for (CelFunctionDecl function : functions) { + for (CelOverloadDecl overload : function.overloads()) { + NamedOverload feature = NamedOverload.create(function.name(), overload); + if (!inventory.contains(feature)) { + return false; + } + includedFeatures.add(feature); + } + } + + ImmutableSet macros = featureSet.macros(); + for (CelMacro macro : macros) { + if (!inventory.contains(macro)) { + return false; + } + includedFeatures.add(macro); + } + + // TODO - Add checks for variables. + + inventory.removeAll(includedFeatures); + return true; + } + + private void addStandardLibrarySubsetAndRemoveFromInventory( + CelEnvironment.Builder envBuilder, Set inventory) { + // Claim standard identifiers for the standard library + for (StandardIdentifier value : StandardIdentifier.values()) { + inventory.remove( + CelVarDecl.newVarDeclaration(value.identDecl().name(), value.identDecl().type())); + } + + Set excludedFunctions = new HashSet<>(); + Set includedFunctions = new HashSet<>(); + ListMultimap excludedOverloads = ArrayListMultimap.create(); + ListMultimap includedOverloads = ArrayListMultimap.create(); + + stream(StandardFunction.values()) + .map(StandardFunction::functionDecl) + .forEach( + decl -> { + String functionName = decl.name(); + boolean anyOverloadIncluded = false; + boolean allOverloadsIncluded = true; + for (CelOverloadDecl overload : decl.overloads()) { + NamedOverload item = NamedOverload.create(functionName, overload); + if (inventory.remove(item)) { + anyOverloadIncluded = true; + includedOverloads.put(functionName, overload.overloadId()); + } else { + allOverloadsIncluded = false; + excludedOverloads.put(functionName, overload.overloadId()); + } + } + if (!anyOverloadIncluded) { + excludedFunctions.add(functionName); + } + if (allOverloadsIncluded) { + includedFunctions.add(functionName); + } + }); + + Set excludedMacros = new HashSet<>(); + Set includedMacros = new HashSet<>(); + stream(CelStandardMacro.values()) + .map(celStandardMacro -> celStandardMacro.getDefinition()) + .forEach( + macro -> { + if (inventory.remove(macro)) { + includedMacros.add(macro.getFunction()); + } else { + excludedMacros.add(macro.getFunction()); + } + }); + + LibrarySubset.Builder subsetBuilder = LibrarySubset.newBuilder().setDisabled(false); + if (excludedFunctions.size() + excludedMacros.size() <= maxExcludedStandardFunctions() + && excludedOverloads.size() <= maxExcludedStandardFunctionOverloads()) { + subsetBuilder + .setExcludedFunctions(buildFunctionSelectors(excludedFunctions, excludedOverloads)) + .setExcludedMacros(ImmutableSet.copyOf(excludedMacros)); + } else { + subsetBuilder + .setIncludedFunctions(buildFunctionSelectors(includedFunctions, includedOverloads)) + .setIncludedMacros(ImmutableSet.copyOf(includedMacros)); + } + + envBuilder.setStandardLibrarySubset(subsetBuilder.build()); + } + + private ImmutableSet buildFunctionSelectors( + Set functions, ListMultimap functionToOverloadsMap) { + ImmutableSet.Builder functionSelectors = ImmutableSet.builder(); + for (String excludedFunction : functions) { + functionSelectors.add(FunctionSelector.create(excludedFunction, ImmutableSet.of())); + } + + for (String functionName : functionToOverloadsMap.keySet()) { + if (functions.contains(functionName)) { + continue; + } + functionSelectors.add( + FunctionSelector.create( + functionName, ImmutableSet.copyOf(functionToOverloadsMap.get(functionName)))); + } + return functionSelectors.build(); + } + + private void addCustomDecls(CelEnvironment.Builder envBuilder, Set inventory) { + // Group "orphaned" function overloads and vars by their names + ListMultimap extraOverloads = ArrayListMultimap.create(); + Map extraVars = new HashMap<>(); + for (Object item : inventory) { + if (item instanceof NamedOverload) { + extraOverloads.put( + ((NamedOverload) item).functionName(), ((NamedOverload) item).overload()); + } else if (item instanceof CelVarDecl) { + extraVars.put(((CelVarDecl) item).name(), ((CelVarDecl) item).type()); + } + } + + if (!extraOverloads.isEmpty()) { + ImmutableSet.Builder functionDeclBuilder = + ImmutableSet.builder(); + for (String functionName : extraOverloads.keySet()) { + functionDeclBuilder.add( + CelEnvironment.FunctionDecl.create( + functionName, + extraOverloads.get(functionName).stream() + .map(this::toCelEnvOverloadDecl) + .collect(toImmutableSet()))); + } + envBuilder.setFunctions(functionDeclBuilder.build()); + } + + if (!extraVars.isEmpty()) { + ImmutableSet.Builder varDeclBuilder = ImmutableSet.builder(); + for (String ident : extraVars.keySet()) { + varDeclBuilder.add( + CelEnvironment.VariableDecl.create(ident, toCelEnvTypeDecl(extraVars.get(ident)))); + } + envBuilder.setVariables(varDeclBuilder.build()); + } + } + + private CelEnvironment.OverloadDecl toCelEnvOverloadDecl(CelOverloadDecl overload) { + OverloadDecl.Builder builder = + OverloadDecl.newBuilder() + .setId(overload.overloadId()) + .setReturnType(toCelEnvTypeDecl(overload.resultType())); + + if (overload.isInstanceFunction()) { + builder + .setTarget(toCelEnvTypeDecl(overload.parameterTypes().get(0))) + .setArguments( + overload.parameterTypes().stream() + .skip(1) + .map(this::toCelEnvTypeDecl) + .collect(toImmutableList())); + } else { + builder.setArguments( + overload.parameterTypes().stream() + .map(this::toCelEnvTypeDecl) + .collect(toImmutableList())); + } + return builder.build(); + } + + private CelEnvironment.TypeDecl toCelEnvTypeDecl(CelType type) { + return CelEnvironment.TypeDecl.newBuilder() + .setName(type.name()) + .setIsTypeParam(type.kind() == CelKind.TYPE_PARAM) + .addParams( + type.parameters().stream().map(this::toCelEnvTypeDecl).collect(toImmutableList())) + .build(); + } + + /** Wrapper for CelOverloadDecl, associating it with the corresponding function name. */ + @AutoValue + abstract static class NamedOverload { + abstract String functionName(); + + abstract CelOverloadDecl overload(); + + static NamedOverload create(String functionName, CelOverloadDecl overload) { + return new AutoValue_CelEnvironmentExporter_NamedOverload(functionName, overload); + } + } + + /** + * Wrapper for CelExtensionLibrary.FeatureSet, associating it with the corresponding library name. + */ + @AutoValue + abstract static class NamedFeatureSet { + abstract String name(); + + abstract CelExtensionLibrary.FeatureSet featureSet(); + + static NamedFeatureSet create(String name, CelExtensionLibrary.FeatureSet featureSet) { + return new AutoValue_CelEnvironmentExporter_NamedFeatureSet(name, featureSet); + } + } +} diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java new file mode 100644 index 000000000..14f1c93d8 --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java @@ -0,0 +1,948 @@ +// Copyright 2025 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.bundle; + +import static dev.cel.common.formats.YamlHelper.ERROR; +import static dev.cel.common.formats.YamlHelper.assertRequiredFields; +import static dev.cel.common.formats.YamlHelper.assertYamlType; +import static dev.cel.common.formats.YamlHelper.newBoolean; +import static dev.cel.common.formats.YamlHelper.newInteger; +import static dev.cel.common.formats.YamlHelper.newString; +import static dev.cel.common.formats.YamlHelper.parseYamlSource; +import static dev.cel.common.formats.YamlHelper.validateYamlType; +import static java.util.Collections.singletonList; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.bundle.CelEnvironment.Alias; +import dev.cel.bundle.CelEnvironment.ContextVariable; +import dev.cel.bundle.CelEnvironment.ExtensionConfig; +import dev.cel.bundle.CelEnvironment.FunctionDecl; +import dev.cel.bundle.CelEnvironment.LibrarySubset; +import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector; +import dev.cel.bundle.CelEnvironment.LibrarySubset.OverloadSelector; +import dev.cel.bundle.CelEnvironment.OverloadDecl; +import dev.cel.bundle.CelEnvironment.TypeDecl; +import dev.cel.bundle.CelEnvironment.VariableDecl; +import dev.cel.common.CelContainer; +import dev.cel.common.CelIssue; +import dev.cel.common.formats.CelFileSource; +import dev.cel.common.formats.ParserContext; +import dev.cel.common.formats.YamlHelper.YamlNodeType; +import dev.cel.common.formats.YamlParserContextImpl; +import dev.cel.common.internal.CelCodePointArray; +import java.util.Optional; +import org.jspecify.annotations.Nullable; +import org.yaml.snakeyaml.DumperOptions.FlowStyle; +import org.yaml.snakeyaml.nodes.MappingNode; +import org.yaml.snakeyaml.nodes.Node; +import org.yaml.snakeyaml.nodes.NodeTuple; +import org.yaml.snakeyaml.nodes.ScalarNode; +import org.yaml.snakeyaml.nodes.SequenceNode; +import org.yaml.snakeyaml.nodes.Tag; + +/** + * CelEnvironmentYamlParser intakes a YAML document that describes the structure of a CEL + * environment, parses it then creates a {@link CelEnvironment}. + */ +public final class CelEnvironmentYamlParser { + // Sentinel values to be returned for various declarations when parsing failure is encountered. + private static final TypeDecl ERROR_TYPE_DECL = TypeDecl.create(ERROR); + private static final VariableDecl ERROR_VARIABLE_DECL = + VariableDecl.create(ERROR, ERROR_TYPE_DECL); + private static final FunctionDecl ERROR_FUNCTION_DECL = + FunctionDecl.create(ERROR, ImmutableSet.of()); + private static final ExtensionConfig ERROR_EXTENSION_DECL = ExtensionConfig.of(ERROR); + private static final FunctionSelector ERROR_FUNCTION_SELECTOR = + FunctionSelector.create(ERROR, ImmutableSet.of()); + private static final Alias ERROR_ALIAS = + Alias.newBuilder().setAlias(ERROR).setQualifiedName(ERROR).build(); + + /** Generates a new instance of {@code CelEnvironmentYamlParser}. */ + public static CelEnvironmentYamlParser newInstance() { + return new CelEnvironmentYamlParser(); + } + + /** Parsers the input {@code environmentYamlSource} and returns a {@link CelEnvironment}. */ + public CelEnvironment parse(String environmentYamlSource) throws CelEnvironmentException { + return parse(environmentYamlSource, ""); + } + + /** + * Parses the input {@code environmentYamlSource} and returns a {@link CelEnvironment}. + * + *

The {@code description} may be used to help tailor error messages for the location where the + * {@code environmentYamlSource} originates, e.g. a file name or form UI element. + */ + public CelEnvironment parse(String environmentYamlSource, String description) + throws CelEnvironmentException { + CelEnvironmentYamlParser.ParserImpl parser = new CelEnvironmentYamlParser.ParserImpl(); + + return parser.parseYaml(environmentYamlSource, description); + } + + private CelContainer parseContainer(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + // Syntax variant 1: "container: `str`" + if (validateYamlType(node, YamlNodeType.STRING, YamlNodeType.TEXT)) { + return CelContainer.ofName(newString(ctx, node)); + } + + // Syntax variant 2: + // container + // name: str + // abbreviations: + // - a1 + // - a2 + // aliases: + // - alias: a1 + // qualified_name: q1 + // - alias: a2 + // qualified_name: q2 + if (!assertYamlType(ctx, valueId, node, YamlNodeType.MAP)) { + return CelContainer.ofName(ERROR); + } + + CelContainer.Builder builder = CelContainer.newBuilder(); + MappingNode variableMap = (MappingNode) node; + for (NodeTuple nodeTuple : variableMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "name": + builder.setName(newString(ctx, valueNode)); + break; + case "aliases": + ImmutableSet aliases = parseAliases(ctx, valueNode); + for (Alias alias : aliases) { + builder.addAlias(alias.alias(), alias.qualifiedName()); + } + break; + case "abbreviations": + builder.addAbbreviations(parseAbbreviations(ctx, valueNode)); + break; + default: + ctx.reportError(keyId, String.format("Unsupported container tag: %s", keyName)); + break; + } + } + + return builder.build(); + } + + private ImmutableSet parseFeatures( + ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + if (!validateYamlType(node, YamlNodeType.LIST, YamlNodeType.TEXT)) { + ctx.reportError(valueId, "Unsupported features format"); + } + + ImmutableSet.Builder featureFlags = ImmutableSet.builder(); + + SequenceNode featureListNode = (SequenceNode) node; + for (Node featureMapNode : featureListNode.getValue()) { + long featureMapId = ctx.collectMetadata(featureMapNode); + if (!assertYamlType(ctx, featureMapId, featureMapNode, YamlNodeType.MAP)) { + continue; + } + + MappingNode featureMap = (MappingNode) featureMapNode; + String name = ""; + boolean enabled = true; + for (NodeTuple nodeTuple : featureMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "name": + name = newString(ctx, valueNode); + break; + case "enabled": + enabled = newBoolean(ctx, valueNode); + break; + default: + ctx.reportError(keyId, String.format("Unsupported feature tag: %s", keyName)); + break; + } + } + if (name.isEmpty()) { + ctx.reportError(featureMapId, "Missing required attribute(s): name"); + continue; + } + featureFlags.add(CelEnvironment.FeatureFlag.create(name, enabled)); + } + return featureFlags.build(); + } + + private ImmutableSet parseLimits(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + if (!validateYamlType(node, YamlNodeType.LIST, YamlNodeType.TEXT)) { + ctx.reportError(valueId, "Unsupported limits format"); + } + + ImmutableSet.Builder limits = ImmutableSet.builder(); + + SequenceNode featureListNode = (SequenceNode) node; + for (Node featureMapNode : featureListNode.getValue()) { + long featureMapId = ctx.collectMetadata(featureMapNode); + if (!assertYamlType(ctx, featureMapId, featureMapNode, YamlNodeType.MAP)) { + continue; + } + + MappingNode featureMap = (MappingNode) featureMapNode; + String name = ""; + Optional value = Optional.empty(); + // Shorthand syntax for limit: "cel.limit.foo: 1" + if (featureMap.getValue().size() == 1) { + NodeTuple nodeTuple = featureMap.getValue().get(0); + Node keyNode = nodeTuple.getKeyNode(); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + if (!keyName.equals("name") && !keyName.equals("value")) { + limits.add(CelEnvironment.Limit.create(keyName, newInteger(ctx, valueNode))); + continue; + } + // Fall through to check against the long syntax. + } + // Long syntax for limit: + // limits: + // - name: cel.limit.foo + // value: 1 + for (NodeTuple nodeTuple : featureMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "name": + name = newString(ctx, valueNode); + break; + case "value": + value = Optional.of(newInteger(ctx, valueNode)); + break; + default: + ctx.reportError(keyId, String.format("Unsupported limits tag: %s", keyName)); + break; + } + } + if (name.isEmpty()) { + ctx.reportError(featureMapId, "Missing required attribute(s): name"); + continue; + } + if (!value.isPresent()) { + ctx.reportError(featureMapId, "Missing required attribute(s): value"); + continue; + } + limits.add(CelEnvironment.Limit.create(name, value.get())); + } + return limits.build(); + } + + private ImmutableSet parseAliases(ParserContext ctx, Node node) { + ImmutableSet.Builder aliasSetBuilder = ImmutableSet.builder(); + long valueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + return aliasSetBuilder.build(); + } + + SequenceNode variableListNode = (SequenceNode) node; + for (Node elementNode : variableListNode.getValue()) { + aliasSetBuilder.add(parseAlias(ctx, elementNode)); + } + + return aliasSetBuilder.build(); + } + + private Alias parseAlias(ParserContext ctx, Node node) { + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) { + return ERROR_ALIAS; + } + + Alias.Builder builder = Alias.newBuilder(); + MappingNode attrMap = (MappingNode) node; + for (NodeTuple nodeTuple : attrMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "alias": + builder.setAlias(newString(ctx, valueNode)); + break; + case "qualified_name": + builder.setQualifiedName(newString(ctx, valueNode)); + break; + default: + ctx.reportError(keyId, String.format("Unsupported alias tag: %s", keyName)); + break; + } + } + + if (!assertRequiredFields(ctx, id, builder.getMissingRequiredFieldNames())) { + return ERROR_ALIAS; + } + + return builder.build(); + } + + private ImmutableSet parseAbbreviations(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + return ImmutableSet.of(ERROR); + } + + ImmutableSet.Builder builder = ImmutableSet.builder(); + SequenceNode nameListNode = (SequenceNode) node; + for (Node elementNode : nameListNode.getValue()) { + long elementId = ctx.collectMetadata(elementNode); + if (!assertYamlType(ctx, elementId, elementNode, YamlNodeType.STRING)) { + return ImmutableSet.of(ERROR); + } + + builder.add(((ScalarNode) elementNode).getValue()); + } + return builder.build(); + } + + private ContextVariable parseContextVariable(ParserContext ctx, Node node) { + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) { + return ContextVariable.create(""); + } + + MappingNode mapNode = (MappingNode) node; + String typeName = ""; + for (NodeTuple nodeTuple : mapNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "type_name": + typeName = newString(ctx, valueNode); + break; + default: + ctx.reportError(keyId, String.format("Unsupported context_variable tag: %s", keyName)); + break; + } + } + + if (typeName.isEmpty()) { + ctx.reportError(id, "Missing required attribute(s): type_name"); + } + + return ContextVariable.create(typeName); + } + + private ImmutableSet parseVariables(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + ImmutableSet.Builder variableSetBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + return variableSetBuilder.build(); + } + + SequenceNode variableListNode = (SequenceNode) node; + for (Node elementNode : variableListNode.getValue()) { + variableSetBuilder.add(parseVariable(ctx, elementNode)); + } + + return variableSetBuilder.build(); + } + + private VariableDecl parseVariable(ParserContext ctx, Node node) { + long variableId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, variableId, node, YamlNodeType.MAP)) { + return ERROR_VARIABLE_DECL; + } + + MappingNode variableMap = (MappingNode) node; + VariableDecl.Builder builder = VariableDecl.newBuilder(); + TypeDecl.Builder typeDeclBuilder = null; + for (NodeTuple nodeTuple : variableMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "name": + builder.setName(newString(ctx, valueNode)); + break; + case "description": + builder.setDescription(newString(ctx, valueNode)); + break; + case "type": + if (typeDeclBuilder != null) { + ctx.reportError( + keyId, + String.format( + "'type' tag cannot be used together with inlined 'type_name', 'is_type_param'" + + " or 'params': %s", + keyName)); + break; + } + builder.setType(parseTypeDecl(ctx, valueNode)); + break; + case "type_name": + case "is_type_param": + case "params": + if (typeDeclBuilder == null) { + typeDeclBuilder = TypeDecl.newBuilder(); + } + typeDeclBuilder = parseInlinedTypeDecl(ctx, keyId, keyNode, valueNode, typeDeclBuilder); + break; + default: + ctx.reportError(keyId, String.format("Unsupported variable tag: %s", keyName)); + break; + } + } + + if (typeDeclBuilder != null) { + if (!assertRequiredFields(ctx, variableId, typeDeclBuilder.getMissingRequiredFieldNames())) { + return ERROR_VARIABLE_DECL; + } + builder.setType(typeDeclBuilder.build()); + } + + if (!assertRequiredFields(ctx, variableId, builder.getMissingRequiredFieldNames())) { + return ERROR_VARIABLE_DECL; + } + + return builder.build(); + } + + private ImmutableSet parseFunctions(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + ImmutableSet.Builder functionSetBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + return functionSetBuilder.build(); + } + + SequenceNode functionListNode = (SequenceNode) node; + for (Node elementNode : functionListNode.getValue()) { + functionSetBuilder.add(parseFunction(ctx, elementNode)); + } + + return functionSetBuilder.build(); + } + + private FunctionDecl parseFunction(ParserContext ctx, Node node) { + long functionId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, functionId, node, YamlNodeType.MAP)) { + return ERROR_FUNCTION_DECL; + } + + MappingNode functionMap = (MappingNode) node; + FunctionDecl.Builder builder = FunctionDecl.newBuilder(); + for (NodeTuple nodeTuple : functionMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "name": + builder.setName(newString(ctx, valueNode)); + break; + case "overloads": + builder.setOverloads(parseOverloads(ctx, valueNode)); + break; + case "description": + builder.setDescription(newString(ctx, valueNode).trim()); + break; + default: + ctx.reportError(keyId, String.format("Unsupported function tag: %s", keyName)); + break; + } + } + + if (!assertRequiredFields(ctx, functionId, builder.getMissingRequiredFieldNames())) { + return ERROR_FUNCTION_DECL; + } + + return builder.build(); + } + + private static ImmutableSet parseOverloads(ParserContext ctx, Node node) { + long listId = ctx.collectMetadata(node); + ImmutableSet.Builder overloadSetBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, listId, node, YamlNodeType.LIST)) { + return overloadSetBuilder.build(); + } + + SequenceNode overloadListNode = (SequenceNode) node; + for (Node overloadMapNode : overloadListNode.getValue()) { + long overloadMapId = ctx.collectMetadata(overloadMapNode); + if (!assertYamlType(ctx, overloadMapId, overloadMapNode, YamlNodeType.MAP)) { + continue; + } + + MappingNode mapNode = (MappingNode) overloadMapNode; + OverloadDecl.Builder overloadDeclBuilder = OverloadDecl.newBuilder(); + for (NodeTuple nodeTuple : mapNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "id": + overloadDeclBuilder.setId(newString(ctx, valueNode)); + break; + case "args": + overloadDeclBuilder.addArguments(parseOverloadArguments(ctx, valueNode)); + break; + case "return": + overloadDeclBuilder.setReturnType(parseTypeDecl(ctx, valueNode)); + break; + case "target": + overloadDeclBuilder.setTarget(parseTypeDecl(ctx, valueNode)); + break; + case "examples": + overloadDeclBuilder.addExamples(parseOverloadExamples(ctx, valueNode)); + break; + default: + ctx.reportError(keyId, String.format("Unsupported overload tag: %s", fieldName)); + break; + } + } + + if (assertRequiredFields( + ctx, overloadMapId, overloadDeclBuilder.getMissingRequiredFieldNames())) { + overloadSetBuilder.add(overloadDeclBuilder.build()); + } + } + + return overloadSetBuilder.build(); + } + + private static ImmutableList parseOverloadExamples(ParserContext ctx, Node node) { + long listValueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, listValueId, node, YamlNodeType.LIST)) { + return ImmutableList.of(); + } + SequenceNode paramsListNode = (SequenceNode) node; + ImmutableList.Builder builder = ImmutableList.builder(); + for (Node elementNode : paramsListNode.getValue()) { + long elementNodeId = ctx.collectMetadata(elementNode); + if (!assertYamlType(ctx, elementNodeId, elementNode, YamlNodeType.STRING)) { + continue; + } + + builder.add(((ScalarNode) elementNode).getValue()); + } + + return builder.build(); + } + + private static ImmutableList parseOverloadArguments( + ParserContext ctx, Node node) { + long listValueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, listValueId, node, YamlNodeType.LIST)) { + return ImmutableList.of(); + } + SequenceNode paramsListNode = (SequenceNode) node; + ImmutableList.Builder builder = ImmutableList.builder(); + for (Node elementNode : paramsListNode.getValue()) { + builder.add(parseTypeDecl(ctx, elementNode)); + } + + return builder.build(); + } + + private static ImmutableSet parseExtensions(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + ImmutableSet.Builder extensionConfigBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + return extensionConfigBuilder.build(); + } + + SequenceNode extensionListNode = (SequenceNode) node; + for (Node elementNode : extensionListNode.getValue()) { + extensionConfigBuilder.add(parseExtension(ctx, elementNode)); + } + + return extensionConfigBuilder.build(); + } + + private static ExtensionConfig parseExtension(ParserContext ctx, Node node) { + long extensionId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, extensionId, node, YamlNodeType.MAP)) { + return ERROR_EXTENSION_DECL; + } + + MappingNode extensionMap = (MappingNode) node; + ExtensionConfig.Builder builder = ExtensionConfig.newBuilder(); + for (NodeTuple nodeTuple : extensionMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "name": + builder.setName(newString(ctx, valueNode)); + break; + case "version": + if (validateYamlType(valueNode, YamlNodeType.INTEGER)) { + builder.setVersion(newInteger(ctx, valueNode)); + break; + } else if (validateYamlType(valueNode, YamlNodeType.STRING, YamlNodeType.TEXT)) { + String versionStr = newString(ctx, valueNode); + if (versionStr.equals("latest")) { + builder.setVersion(Integer.MAX_VALUE); + break; + } + + Integer versionInt = tryParse(versionStr); + if (versionInt != null) { + builder.setVersion(versionInt); + break; + } + // Fall-through + } + ctx.reportError(keyId, String.format("Unsupported version tag: %s", keyName)); + break; + default: + ctx.reportError(keyId, String.format("Unsupported extension tag: %s", keyName)); + break; + } + } + + if (!assertRequiredFields(ctx, extensionId, builder.getMissingRequiredFieldNames())) { + return ERROR_EXTENSION_DECL; + } + + return builder.build(); + } + + private static LibrarySubset parseLibrarySubset(ParserContext ctx, Node node) { + LibrarySubset.Builder builder = LibrarySubset.newBuilder().setDisabled(false); + MappingNode subsetMap = (MappingNode) node; + for (NodeTuple nodeTuple : subsetMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "disabled": + builder.setDisabled(newBoolean(ctx, valueNode)); + break; + case "disable_macros": + builder.setMacrosDisabled(newBoolean(ctx, valueNode)); + break; + case "include_macros": + builder.setIncludedMacros(parseMacroNameSet(ctx, valueNode)); + break; + case "exclude_macros": + builder.setExcludedMacros(parseMacroNameSet(ctx, valueNode)); + break; + case "include_functions": + builder.setIncludedFunctions(parseFunctionSelectors(ctx, valueNode)); + break; + case "exclude_functions": + builder.setExcludedFunctions(parseFunctionSelectors(ctx, valueNode)); + break; + default: + ctx.reportError(keyId, String.format("Unsupported library subset tag: %s", keyName)); + break; + } + } + return builder.build(); + } + + private static ImmutableSet parseMacroNameSet(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + return ImmutableSet.of(ERROR); + } + + ImmutableSet.Builder builder = ImmutableSet.builder(); + SequenceNode nameListNode = (SequenceNode) node; + for (Node elementNode : nameListNode.getValue()) { + long elementId = ctx.collectMetadata(elementNode); + if (!assertYamlType(ctx, elementId, elementNode, YamlNodeType.STRING)) { + return ImmutableSet.of(ERROR); + } + + builder.add(((ScalarNode) elementNode).getValue()); + } + return builder.build(); + } + + private static ImmutableSet parseFunctionSelectors( + ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + ImmutableSet.Builder functionSetBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + return functionSetBuilder.build(); + } + + SequenceNode functionListNode = (SequenceNode) node; + for (Node elementNode : functionListNode.getValue()) { + functionSetBuilder.add(parseFunctionSelector(ctx, elementNode)); + } + + return functionSetBuilder.build(); + } + + private static FunctionSelector parseFunctionSelector(ParserContext ctx, Node node) { + FunctionSelector.Builder builder = FunctionSelector.newBuilder(); + long functionId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, functionId, node, YamlNodeType.MAP)) { + return ERROR_FUNCTION_SELECTOR; + } + + MappingNode functionMap = (MappingNode) node; + for (NodeTuple nodeTuple : functionMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "name": + builder.setName(newString(ctx, valueNode)); + break; + case "overloads": + builder.setOverloads(parseFunctionOverloadsSelector(ctx, valueNode)); + break; + default: + ctx.reportError(keyId, String.format("Unsupported function selector tag: %s", keyName)); + break; + } + } + + if (!assertRequiredFields(ctx, functionId, builder.getMissingRequiredFieldNames())) { + return ERROR_FUNCTION_SELECTOR; + } + + return builder.build(); + } + + private static ImmutableSet parseFunctionOverloadsSelector( + ParserContext ctx, Node node) { + long listId = ctx.collectMetadata(node); + ImmutableSet.Builder overloadSetBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, listId, node, YamlNodeType.LIST)) { + return overloadSetBuilder.build(); + } + + SequenceNode overloadListNode = (SequenceNode) node; + for (Node overloadMapNode : overloadListNode.getValue()) { + long overloadMapId = ctx.collectMetadata(overloadMapNode); + if (!assertYamlType(ctx, overloadMapId, overloadMapNode, YamlNodeType.MAP)) { + continue; + } + + MappingNode mapNode = (MappingNode) overloadMapNode; + OverloadSelector.Builder overloadDeclBuilder = OverloadSelector.newBuilder(); + for (NodeTuple nodeTuple : mapNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "id": + overloadDeclBuilder.setId(newString(ctx, valueNode)); + break; + default: + ctx.reportError( + keyId, String.format("Unsupported overload selector tag: %s", fieldName)); + break; + } + } + + if (assertRequiredFields( + ctx, overloadMapId, overloadDeclBuilder.getMissingRequiredFieldNames())) { + overloadSetBuilder.add(overloadDeclBuilder.build()); + } + } + + return overloadSetBuilder.build(); + } + + private static @Nullable Integer tryParse(String str) { + try { + return Integer.parseInt(str); + } catch (NumberFormatException e) { + return null; + } + } + + @CanIgnoreReturnValue + private static TypeDecl.Builder parseInlinedTypeDecl( + ParserContext ctx, long keyId, Node keyNode, Node valueNode, TypeDecl.Builder builder) { + if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) { + return builder; + } + + // Create a synthetic node to make this behave as if a `type: ` parent node actually exists. + MappingNode mapNode = + new MappingNode( + Tag.MAP, /* value= */ singletonList(new NodeTuple(keyNode, valueNode)), FlowStyle.AUTO); + + return parseTypeDeclFields(ctx, mapNode, builder); + } + + private static TypeDecl parseTypeDecl(ParserContext ctx, Node node) { + TypeDecl.Builder builder = TypeDecl.newBuilder(); + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) { + return ERROR_TYPE_DECL; + } + + MappingNode mapNode = (MappingNode) node; + return parseTypeDeclFields(ctx, mapNode, builder).build(); + } + + @CanIgnoreReturnValue + private static TypeDecl.Builder parseTypeDeclFields( + ParserContext ctx, MappingNode mapNode, TypeDecl.Builder builder) { + for (NodeTuple nodeTuple : mapNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "type_name": + builder.setName(newString(ctx, valueNode)); + break; + case "is_type_param": + builder.setIsTypeParam(newBoolean(ctx, valueNode)); + break; + case "params": + long listValueId = ctx.collectMetadata(valueNode); + if (!assertYamlType(ctx, listValueId, valueNode, YamlNodeType.LIST)) { + break; + } + SequenceNode paramsListNode = (SequenceNode) valueNode; + for (Node elementNode : paramsListNode.getValue()) { + builder.addParams(parseTypeDecl(ctx, elementNode)); + } + break; + default: + ctx.reportError(keyId, String.format("Unsupported type decl tag: %s", fieldName)); + break; + } + } + return builder; + } + + private class ParserImpl { + + private CelEnvironment parseYaml(String source, String description) + throws CelEnvironmentException { + Node node; + try { + node = + parseYamlSource(source) + .orElseThrow( + () -> + new CelEnvironmentException( + String.format("YAML document empty or malformed: %s", source))); + } catch (RuntimeException e) { + throw new CelEnvironmentException("YAML document is malformed: " + e.getMessage(), e); + } + + CelFileSource environmentSource = + CelFileSource.newBuilder(CelCodePointArray.fromString(source)) + .setDescription(description) + .build(); + ParserContext ctx = YamlParserContextImpl.newInstance(environmentSource); + CelEnvironment.Builder builder = parseConfig(ctx, node); + environmentSource = + environmentSource.toBuilder().setPositionsMap(ctx.getIdToOffsetMap()).build(); + + if (!ctx.getIssues().isEmpty()) { + throw new CelEnvironmentException( + CelIssue.toDisplayString(ctx.getIssues(), environmentSource)); + } + + return builder.setSource(environmentSource).build(); + } + + private CelEnvironment.Builder parseConfig(ParserContext ctx, Node node) { + CelEnvironment.Builder builder = CelEnvironment.newBuilder(); + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) { + return builder; + } + + MappingNode rootNode = (MappingNode) node; + for (NodeTuple nodeTuple : rootNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "name": + builder.setName(newString(ctx, valueNode)); + break; + case "description": + builder.setDescription(newString(ctx, valueNode)); + break; + case "container": + builder.setContainer(parseContainer(ctx, valueNode)); + break; + case "variables": + builder.setVariables(parseVariables(ctx, valueNode)); + break; + case "functions": + builder.setFunctions(parseFunctions(ctx, valueNode)); + break; + case "extensions": + builder.addExtensions(parseExtensions(ctx, valueNode)); + break; + case "stdlib": + builder.setStandardLibrarySubset(parseLibrarySubset(ctx, valueNode)); + break; + case "features": + builder.setFeatures(parseFeatures(ctx, valueNode)); + break; + case "limits": + builder.setLimits(parseLimits(ctx, valueNode)); + break; + case "context_variable": + builder.setContextVariable(parseContextVariable(ctx, valueNode)); + break; + default: + ctx.reportError(id, "Unknown config tag: " + fieldName); + // continue handling the rest of the nodes + } + } + + return builder; + } + } + + private CelEnvironmentYamlParser() {} +} diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java new file mode 100644 index 000000000..9d5b4b69e --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java @@ -0,0 +1,293 @@ +// Copyright 2025 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.bundle; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import dev.cel.bundle.CelEnvironment.Alias; +import dev.cel.bundle.CelEnvironment.LibrarySubset; +import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector; +import dev.cel.bundle.CelEnvironment.LibrarySubset.OverloadSelector; +import dev.cel.common.CelContainer; +import java.util.Comparator; +import java.util.Map; +import org.yaml.snakeyaml.DumperOptions; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.nodes.Node; +import org.yaml.snakeyaml.representer.Represent; +import org.yaml.snakeyaml.representer.Representer; + +/** Serializes a CelEnvironment into a YAML file. */ +public final class CelEnvironmentYamlSerializer extends Representer { + + private static DumperOptions initDumperOptions() { + DumperOptions options = new DumperOptions(); + options.setIndent(2); + options.setPrettyFlow(true); + options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK); + return options; + } + + private static final DumperOptions YAML_OPTIONS = initDumperOptions(); + + private static final CelEnvironmentYamlSerializer INSTANCE = new CelEnvironmentYamlSerializer(); + + private CelEnvironmentYamlSerializer() { + super(YAML_OPTIONS); + this.multiRepresenters.put(CelEnvironment.class, new RepresentCelEnvironment()); + this.multiRepresenters.put(CelEnvironment.VariableDecl.class, new RepresentVariableDecl()); + this.multiRepresenters.put(CelEnvironment.FunctionDecl.class, new RepresentFunctionDecl()); + this.multiRepresenters.put(CelEnvironment.OverloadDecl.class, new RepresentOverloadDecl()); + this.multiRepresenters.put(CelEnvironment.TypeDecl.class, new RepresentTypeDecl()); + this.multiRepresenters.put( + CelEnvironment.ExtensionConfig.class, new RepresentExtensionConfig()); + this.multiRepresenters.put(CelEnvironment.LibrarySubset.class, new RepresentLibrarySubset()); + this.multiRepresenters.put( + CelEnvironment.LibrarySubset.FunctionSelector.class, new RepresentFunctionSelector()); + this.multiRepresenters.put( + CelEnvironment.LibrarySubset.OverloadSelector.class, new RepresentOverloadSelector()); + this.multiRepresenters.put(CelEnvironment.Alias.class, new RepresentAlias()); + this.multiRepresenters.put(CelContainer.class, new RepresentContainer()); + this.multiRepresenters.put(CelEnvironment.FeatureFlag.class, new RepresentFeatureFlag()); + this.multiRepresenters.put(CelEnvironment.Limit.class, new RepresentLimit()); + } + + public static String toYaml(CelEnvironment environment) { + // Yaml is not thread-safe, so we create a new instance for each serialization. + Yaml yaml = new Yaml(INSTANCE, YAML_OPTIONS); + return yaml.dump(environment); + } + + private final class RepresentCelEnvironment implements Represent { + @Override + public Node representData(Object data) { + CelEnvironment environment = (CelEnvironment) data; + ImmutableMap.Builder configMap = new ImmutableMap.Builder<>(); + configMap.put("name", environment.name()); + if (!environment.description().isEmpty()) { + configMap.put("description", environment.description()); + } + if (environment.container().isPresent()) { + configMap.put("container", environment.container().get()); + } + if (!environment.extensions().isEmpty()) { + configMap.put("extensions", environment.extensions().asList()); + } + if (!environment.variables().isEmpty()) { + configMap.put("variables", environment.variables().asList()); + } + if (!environment.functions().isEmpty()) { + configMap.put("functions", environment.functions().asList()); + } + if (environment.standardLibrarySubset().isPresent()) { + configMap.put("stdlib", environment.standardLibrarySubset().get()); + } + if (!environment.features().isEmpty()) { + configMap.put("features", environment.features().asList()); + } + if (!environment.limits().isEmpty()) { + configMap.put("limits", environment.limits().asList()); + } + return represent(configMap.buildOrThrow()); + } + } + + private final class RepresentContainer implements Represent { + + @Override + public Node representData(Object data) { + CelContainer container = (CelContainer) data; + ImmutableMap.Builder configMap = ImmutableMap.builder(); + if (!container.name().isEmpty()) { + configMap.put("name", container.name()); + } + if (!container.abbreviations().isEmpty()) { + configMap.put("abbreviations", container.abbreviations()); + } + if (!container.aliases().isEmpty()) { + ImmutableList.Builder aliases = ImmutableList.builder(); + for (Map.Entry entry : container.aliases().entrySet()) { + aliases.add( + Alias.newBuilder() + .setAlias(entry.getKey()) + .setQualifiedName(entry.getValue()) + .build()); + } + configMap.put("aliases", aliases.build()); + } + return represent(configMap.buildOrThrow()); + } + } + + private final class RepresentAlias implements Represent { + + @Override + public Node representData(Object data) { + Alias alias = (Alias) data; + return represent( + ImmutableMap.of("alias", alias.alias(), "qualified_name", alias.qualifiedName())); + } + } + + private final class RepresentExtensionConfig implements Represent { + @Override + public Node representData(Object data) { + CelEnvironment.ExtensionConfig extension = (CelEnvironment.ExtensionConfig) data; + ImmutableMap.Builder configMap = new ImmutableMap.Builder<>(); + configMap.put("name", extension.name()); + if (extension.version() > 0 && extension.version() != Integer.MAX_VALUE) { + configMap.put("version", extension.version()); + } + return represent(configMap.buildOrThrow()); + } + } + + private final class RepresentVariableDecl implements Represent { + @Override + public Node representData(Object data) { + CelEnvironment.VariableDecl variable = (CelEnvironment.VariableDecl) data; + ImmutableMap.Builder configMap = new ImmutableMap.Builder<>(); + configMap.put("name", variable.name()).put("type_name", variable.type().name()); + if (!variable.type().params().isEmpty()) { + configMap.put("params", variable.type().params()); + } + return represent(configMap.buildOrThrow()); + } + } + + private final class RepresentFunctionDecl implements Represent { + @Override + public Node representData(Object data) { + CelEnvironment.FunctionDecl function = (CelEnvironment.FunctionDecl) data; + ImmutableMap.Builder configMap = new ImmutableMap.Builder<>(); + configMap.put("name", function.name()).put("overloads", function.overloads().asList()); + return represent(configMap.buildOrThrow()); + } + } + + private final class RepresentOverloadDecl implements Represent { + @Override + public Node representData(Object data) { + CelEnvironment.OverloadDecl overload = (CelEnvironment.OverloadDecl) data; + ImmutableMap.Builder configMap = new ImmutableMap.Builder<>(); + configMap.put("id", overload.id()); + if (overload.target().isPresent()) { + configMap.put("target", overload.target().get()); + } + configMap.put("args", overload.arguments()).put("return", overload.returnType()); + return represent(configMap.buildOrThrow()); + } + } + + private final class RepresentTypeDecl implements Represent { + @Override + public Node representData(Object data) { + CelEnvironment.TypeDecl type = (CelEnvironment.TypeDecl) data; + ImmutableMap.Builder configMap = new ImmutableMap.Builder<>(); + configMap.put("type_name", type.name()); + if (!type.params().isEmpty()) { + configMap.put("params", type.params()); + } + if (type.isTypeParam()) { + configMap.put("is_type_param", type.isTypeParam()); + } + return represent(configMap.buildOrThrow()); + } + } + + private final class RepresentLibrarySubset implements Represent { + @Override + public Node representData(Object data) { + LibrarySubset librarySubset = (LibrarySubset) data; + ImmutableMap.Builder configMap = new ImmutableMap.Builder<>(); + if (librarySubset.disabled()) { + configMap.put("disabled", true); + } + if (librarySubset.macrosDisabled()) { + configMap.put("disable_macros", true); + } + if (!librarySubset.includedMacros().isEmpty()) { + configMap.put("include_macros", ImmutableList.sortedCopyOf(librarySubset.includedMacros())); + } + if (!librarySubset.excludedMacros().isEmpty()) { + configMap.put("exclude_macros", ImmutableList.sortedCopyOf(librarySubset.excludedMacros())); + } + if (!librarySubset.includedFunctions().isEmpty()) { + configMap.put( + "include_functions", + ImmutableList.sortedCopyOf( + Comparator.comparing(FunctionSelector::name), librarySubset.includedFunctions())); + } + if (!librarySubset.excludedFunctions().isEmpty()) { + configMap.put( + "exclude_functions", + ImmutableList.sortedCopyOf( + Comparator.comparing(FunctionSelector::name), librarySubset.excludedFunctions())); + } + return represent(configMap.buildOrThrow()); + } + } + + private final class RepresentFunctionSelector implements Represent { + @Override + public Node representData(Object data) { + FunctionSelector functionSelector = (FunctionSelector) data; + ImmutableMap.Builder configMap = new ImmutableMap.Builder<>(); + configMap.put("name", functionSelector.name()); + if (!functionSelector.overloads().isEmpty()) { + configMap.put( + "overloads", + ImmutableList.sortedCopyOf( + Comparator.comparing(OverloadSelector::id), functionSelector.overloads())); + } + + return represent(configMap.buildOrThrow()); + } + } + + private final class RepresentOverloadSelector implements Represent { + @Override + public Node representData(Object data) { + OverloadSelector overloadSelector = (OverloadSelector) data; + return represent(ImmutableMap.of("id", overloadSelector.id())); + } + } + + private final class RepresentFeatureFlag implements Represent { + + @Override + public Node representData(Object data) { + CelEnvironment.FeatureFlag featureFlag = (CelEnvironment.FeatureFlag) data; + return represent( + ImmutableMap.builder() + .put("name", featureFlag.name()) + .put("enabled", featureFlag.enabled()) + .buildOrThrow()); + } + } + + private final class RepresentLimit implements Represent { + + @Override + public Node representData(Object data) { + CelEnvironment.Limit limit = (CelEnvironment.Limit) data; + return represent( + ImmutableMap.builder() + .put("name", limit.name()) + .put("value", limit.value() < 0 ? -1 : limit.value()) + .buildOrThrow()); + } + } +} diff --git a/bundle/src/main/java/dev/cel/bundle/CelFactory.java b/bundle/src/main/java/dev/cel/bundle/CelFactory.java new file mode 100644 index 000000000..ac589cfe6 --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/CelFactory.java @@ -0,0 +1,76 @@ +// Copyright 2023 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.bundle; + +import dev.cel.checker.CelCheckerLegacyImpl; +import dev.cel.common.CelOptions; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerImpl; +import dev.cel.parser.CelParserImpl; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeImpl; +import dev.cel.runtime.CelRuntimeLegacyImpl; + +/** Helper class to configure the entire CEL stack in a common interface. */ +public final class CelFactory { + + private CelFactory() {} + + /** + * Creates a builder for configuring CEL using current parser for the parse, type-check, and eval + * of expressions. + * + *

Note, the {@link CelOptions#current}, standard CEL function libraries, and linked message + * evaluation are enabled by default. + */ + public static CelBuilder standardCelBuilder() { + return CelImpl.newBuilder( + CelCompilerImpl.newBuilder( + CelParserImpl.newBuilder(), CelCheckerLegacyImpl.newBuilder()), + CelRuntimeLegacyImpl.newBuilder()) + .setOptions(CelOptions.current().build()) + // CEL-Internal-2 + .setStandardEnvironmentEnabled(true); + } + + /** + * Creates a builder for configuring CEL for the parsing, optional type-checking, and evaluation + * of expressions using the Program Planner. + * + *

The {@code ProgramPlanner} architecture provides key benefits over the {@link + * #standardCelBuilder()}: + * + *

    + *
  • Performance: Programs can be cached for improving evaluation speed. + *
  • Parsed-only expression evaluation: Unlike the traditional stack which required + * supplying type-checked expressions, this architecture handles both parsed-only and + * type-checked expressions. + *
+ */ + public static CelBuilder plannerCelBuilder() { + return CelImpl.newBuilder( + CelCompilerImpl.newBuilder( + CelParserImpl.newBuilder(), + CelCheckerLegacyImpl.newBuilder().setStandardEnvironmentEnabled(true)), + CelRuntimeImpl.newBuilder()) + // CEL-Internal-2 + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()); + } + + /** Combines a prebuilt {@link CelCompiler} and {@link CelRuntime} into {@link Cel}. */ + public static Cel combine(CelCompiler celCompiler, CelRuntime celRuntime) { + return CelImpl.combine(celCompiler, celRuntime); + } +} diff --git a/bundle/src/main/java/dev/cel/bundle/CelImpl.java b/bundle/src/main/java/dev/cel/bundle/CelImpl.java new file mode 100644 index 000000000..f0db128c1 --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/CelImpl.java @@ -0,0 +1,441 @@ +// Copyright 2022 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.bundle; + +import static com.google.common.base.Preconditions.checkNotNull; + +import dev.cel.expr.Decl; +import dev.cel.expr.Type; +import com.google.common.base.Supplier; +import com.google.common.base.Suppliers; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.Message; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.checker.CelStandardDeclarations; +import dev.cel.checker.ProtoTypeMask; +import dev.cel.checker.TypeProvider; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelSource; +import dev.cel.common.CelValidationResult; +import dev.cel.common.CelVarDecl; +import dev.cel.common.internal.EnvVisitable; +import dev.cel.common.internal.EnvVisitor; +import dev.cel.common.internal.FileDescriptorSetConverter; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.values.CelValueProvider; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerBuilder; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelParserBuilder; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeImpl; +import dev.cel.runtime.CelRuntimeLibrary; +import dev.cel.runtime.CelStandardFunctions; +import java.util.Arrays; +import java.util.function.Function; + +/** + * Implementation of the synchronous CEL stack. + * + *

Note, the underlying {@link CelCompiler} and {@link CelRuntime} values are constructed lazily. + */ +@Immutable +final class CelImpl implements Cel, EnvVisitable { + + // The lazily constructed compiler and runtime values are memoized and guaranteed to be + // constructed only once without side effects, thus making them effectively immutable. + @SuppressWarnings("Immutable") + private final Supplier compiler; + + @SuppressWarnings("Immutable") + private final Supplier runtime; + + @Override + public CelValidationResult parse(String expression, String description) { + return compiler.get().parse(expression, description); + } + + @Override + public CelValidationResult parse(CelSource source) { + return compiler.get().parse(source); + } + + @Override + public CelValidationResult check(CelAbstractSyntaxTree ast) { + return compiler.get().check(ast); + } + + @Override + public CelTypeProvider getTypeProvider() { + return compiler.get().getTypeProvider(); + } + + @Override + public CelRuntime.Program createProgram(CelAbstractSyntaxTree ast) throws CelEvaluationException { + return runtime.get().createProgram(ast); + } + + @Override + public void accept(EnvVisitor envVisitor) { + CelCompiler celCompiler = compiler.get(); + if (celCompiler instanceof EnvVisitable) { + ((EnvVisitable) celCompiler).accept(envVisitor); + } + } + + @Override + public CelBuilder toCelBuilder() { + return newBuilder(toCompilerBuilder(), toRuntimeBuilder()); + } + + @Override + public CelParserBuilder toParserBuilder() { + return compiler.get().toParserBuilder(); + } + + @Override + public CelCheckerBuilder toCheckerBuilder() { + return compiler.get().toCheckerBuilder(); + } + + @Override + public CelCompilerBuilder toCompilerBuilder() { + return compiler.get().toCompilerBuilder(); + } + + @Override + public CelRuntimeBuilder toRuntimeBuilder() { + return runtime.get().toRuntimeBuilder(); + } + + /** Combines a prebuilt {@link CelCompiler} and {@link CelRuntime} into {@link CelImpl}. */ + static CelImpl combine(CelCompiler compiler, CelRuntime runtime) { + return new CelImpl(Suppliers.memoize(() -> compiler), Suppliers.memoize(() -> runtime)); + } + + /** + * Create a new builder for constructing a {@code CelImpl} instance. + * + *

By default, {@link CelOptions#DEFAULT} are enabled, as is the CEL standard environment. + * + *

CEL Library Internals. Do Not Use. Consumers should use {@code CelFactory} instead. + */ + static CelBuilder newBuilder( + CelCompilerBuilder compilerBuilder, CelRuntimeBuilder celRuntimeBuilder) { + return new CelImpl.Builder(compilerBuilder, celRuntimeBuilder); + } + + /** Builder class for CelImpl instances. */ + public static final class Builder implements CelBuilder { + + private final CelCompilerBuilder compilerBuilder; + private final CelRuntimeBuilder runtimeBuilder; + + private Builder(CelCompilerBuilder celCompilerBuilder, CelRuntimeBuilder celRuntimeBuilder) { + this.compilerBuilder = celCompilerBuilder; + this.runtimeBuilder = celRuntimeBuilder; + } + + @Override + public CelBuilder setOptions(CelOptions options) { + compilerBuilder.setOptions(options); + runtimeBuilder.setOptions(options); + return this; + } + + @Override + public CelBuilder setStandardMacros(CelStandardMacro... macros) { + compilerBuilder.setStandardMacros(macros); + return this; + } + + @Override + public CelBuilder setStandardMacros(Iterable macros) { + compilerBuilder.setStandardMacros(macros); + return this; + } + + @Override + public CelBuilder addMacros(CelMacro... macros) { + checkNotNull(macros); + return addMacros(Arrays.asList(macros)); + } + + @Override + public CelBuilder addMacros(Iterable macros) { + checkNotNull(macros); + compilerBuilder.addMacros(macros); + return this; + } + + @Override + public CelContainer container() { + return compilerBuilder.container(); + } + + @Override + public CelBuilder setContainer(CelContainer container) { + compilerBuilder.setContainer(container); + if (runtimeBuilder instanceof CelRuntimeImpl.Builder) { + runtimeBuilder.setContainer(container); + } + + return this; + } + + @Override + public CelBuilder addVar(String name, Type type) { + compilerBuilder.addVar(name, type); + return this; + } + + @Override + public CelBuilder addVar(String name, CelType type) { + compilerBuilder.addVar(name, type); + return this; + } + + @Override + public CelBuilder addDeclarations(Decl... declarations) { + compilerBuilder.addDeclarations(declarations); + return this; + } + + @Override + public CelBuilder addDeclarations(Iterable declarations) { + compilerBuilder.addDeclarations(declarations); + return this; + } + + @Override + public CelBuilder addFunctionDeclarations(CelFunctionDecl... celFunctionDecls) { + compilerBuilder.addFunctionDeclarations(celFunctionDecls); + return this; + } + + @Override + public CelBuilder addFunctionDeclarations(Iterable celFunctionDecls) { + compilerBuilder.addFunctionDeclarations(celFunctionDecls); + return this; + } + + @Override + public CelBuilder addVarDeclarations(CelVarDecl... celVarDecls) { + compilerBuilder.addVarDeclarations(celVarDecls); + return this; + } + + @Override + public CelBuilder addVarDeclarations(Iterable celVarDecls) { + compilerBuilder.addVarDeclarations(celVarDecls); + return this; + } + + @Override + public CelBuilder addProtoTypeMasks(ProtoTypeMask... typeMasks) { + compilerBuilder.addProtoTypeMasks(typeMasks); + return this; + } + + @Override + public CelBuilder addProtoTypeMasks(Iterable typeMasks) { + compilerBuilder.addProtoTypeMasks(typeMasks); + return this; + } + + @Override + public CelBuilder addFunctionBindings(dev.cel.runtime.CelFunctionBinding... bindings) { + runtimeBuilder.addFunctionBindings(bindings); + return this; + } + + @Override + public CelBuilder addFunctionBindings(Iterable bindings) { + runtimeBuilder.addFunctionBindings(bindings); + return this; + } + + @Override + public CelBuilder addLateBoundFunctions(String... lateBoundFunctionNames) { + runtimeBuilder.addLateBoundFunctions(lateBoundFunctionNames); + return this; + } + + @Override + public CelBuilder addLateBoundFunctions(Iterable lateBoundFunctionNames) { + runtimeBuilder.addLateBoundFunctions(lateBoundFunctionNames); + return this; + } + + @Override + public CelBuilder setResultType(CelType resultType) { + checkNotNull(resultType); + return setProtoResultType(CelProtoTypes.celTypeToType(resultType)); + } + + @Override + public CelBuilder setProtoResultType(Type resultType) { + compilerBuilder.setProtoResultType(resultType); + return this; + } + + @Override + public CelBuilder setTypeFactory(Function typeFactory) { + runtimeBuilder.setTypeFactory(typeFactory); + return this; + } + + @Override + public CelBuilder setValueProvider(CelValueProvider celValueProvider) { + runtimeBuilder.setValueProvider(celValueProvider); + return this; + } + + @Override + @Deprecated + public Builder setTypeProvider(TypeProvider typeProvider) { + compilerBuilder.setTypeProvider(typeProvider); + return this; + } + + @Override + public CelBuilder setTypeProvider(CelTypeProvider celTypeProvider) { + compilerBuilder.setTypeProvider(celTypeProvider); + if (runtimeBuilder instanceof CelRuntimeImpl.Builder) { + runtimeBuilder.setTypeProvider(celTypeProvider); + } + return this; + } + + @Override + public CelBuilder addMessageTypes(Descriptor... descriptors) { + compilerBuilder.addMessageTypes(descriptors); + runtimeBuilder.addMessageTypes(descriptors); + return this; + } + + @Override + public CelBuilder addMessageTypes(Iterable descriptors) { + compilerBuilder.addMessageTypes(descriptors); + runtimeBuilder.addMessageTypes(descriptors); + return this; + } + + @Override + public CelBuilder addFileTypes(FileDescriptor... fileDescriptors) { + compilerBuilder.addFileTypes(fileDescriptors); + runtimeBuilder.addFileTypes(fileDescriptors); + return this; + } + + @Override + public CelBuilder addFileTypes(Iterable fileDescriptors) { + compilerBuilder.addFileTypes(fileDescriptors); + runtimeBuilder.addFileTypes(fileDescriptors); + return this; + } + + @Override + public CelBuilder addFileTypes(FileDescriptorSet fileDescriptorSet) { + // Note: The convert method here constructs unique instances of FileDescriptors, so we convert + // it here in advance and pass it down to compiler/runtime to avoid creating additional + // instances. + ImmutableSet fileDescriptors = + FileDescriptorSetConverter.convert(fileDescriptorSet); + compilerBuilder.addFileTypes(fileDescriptors); + runtimeBuilder.addFileTypes(fileDescriptors); + return this; + } + + @Override + public CelBuilder setStandardEnvironmentEnabled(boolean value) { + compilerBuilder.setStandardEnvironmentEnabled(value); + runtimeBuilder.setStandardEnvironmentEnabled(value); + return this; + } + + @Override + public CelBuilder addCompilerLibraries(CelCompilerLibrary... libraries) { + checkNotNull(libraries); + return this.addCompilerLibraries(Arrays.asList(libraries)); + } + + @Override + public CelBuilder addCompilerLibraries(Iterable libraries) { + checkNotNull(libraries); + compilerBuilder.addLibraries(libraries); + return this; + } + + @Override + public CelBuilder addRuntimeLibraries(CelRuntimeLibrary... libraries) { + checkNotNull(libraries); + return this.addRuntimeLibraries(Arrays.asList(libraries)); + } + + @Override + public CelBuilder addRuntimeLibraries(Iterable libraries) { + checkNotNull(libraries); + runtimeBuilder.addLibraries(libraries); + return this; + } + + @Override + public CelBuilder setStandardDeclarations(CelStandardDeclarations standardDeclarations) { + checkNotNull(standardDeclarations); + compilerBuilder.setStandardDeclarations(standardDeclarations); + return this; + } + + @Override + public CelBuilder setStandardFunctions(CelStandardFunctions standardFunctions) { + checkNotNull(standardFunctions); + runtimeBuilder.setStandardFunctions(standardFunctions); + return this; + } + + @Override + public CelBuilder setExtensionRegistry(ExtensionRegistry extensionRegistry) { + checkNotNull(extensionRegistry); + runtimeBuilder.setExtensionRegistry(extensionRegistry); + return this; + } + + @Override + public Cel build() { + return new CelImpl( + Suppliers.memoize(compilerBuilder::build), Suppliers.memoize(runtimeBuilder::build)); + } + } + + private CelImpl(Supplier compiler, Supplier runtime) { + this.compiler = compiler; + this.runtime = runtime; + } +} diff --git a/bundle/src/main/java/dev/cel/bundle/RequiredFieldsChecker.java b/bundle/src/main/java/dev/cel/bundle/RequiredFieldsChecker.java new file mode 100644 index 000000000..88bef2db5 --- /dev/null +++ b/bundle/src/main/java/dev/cel/bundle/RequiredFieldsChecker.java @@ -0,0 +1,49 @@ +// Copyright 2024 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.bundle; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import java.util.Optional; +import java.util.function.Supplier; + +/** + * Interface to be implemented on a builder that can be used to verify all required fields being + * set. + */ +interface RequiredFieldsChecker { + + ImmutableList requiredFields(); + + default ImmutableList getMissingRequiredFieldNames() { + return requiredFields().stream() + .filter(entry -> !entry.fieldValue().get().isPresent()) + .map(RequiredField::displayName) + .collect(toImmutableList()); + } + + @AutoValue + abstract class RequiredField { + abstract String displayName(); + + abstract Supplier> fieldValue(); + + static RequiredField of(String displayName, Supplier> fieldValue) { + return new AutoValue_RequiredFieldsChecker_RequiredField(displayName, fieldValue); + } + } +} diff --git a/bundle/src/test/java/dev/cel/bundle/BUILD.bazel b/bundle/src/test/java/dev/cel/bundle/BUILD.bazel new file mode 100644 index 000000000..548b4483d --- /dev/null +++ b/bundle/src/test/java/dev/cel/bundle/BUILD.bazel @@ -0,0 +1,86 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = [ + "//:license", + ], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*Test.java"]), + resources = [ + "//testing/environment:dump_env", + "//testing/environment:extended_env", + "//testing/environment:library_subset_env", + ], + deps = [ + "//:java_truth", + "//bundle:cel", + "//bundle:cel_impl", + "//bundle:environment", + "//bundle:environment_exception", + "//bundle:environment_exporter", + "//bundle:environment_yaml_parser", + "//checker", + "//checker:checker_legacy_environment", + "//checker:proto_type_mask", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:error_codes", + "//common:options", + "//common:proto_ast", + "//common:source_location", + "//common/ast", + "//common/resources/testdata/proto3:standalone_global_enum_java_proto", + "//common/testing", + "//common/types", + "//common/types:cel_proto_message_types", + "//common/types:cel_proto_types", + "//common/types:message_type_provider", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_byte_string", + "//compiler", + "//compiler:compiler_builder", + "//extensions", + "//parser", + "//parser:macro", + "//parser:unparser", + "//runtime", + "//runtime:evaluation_exception_builder", + "//runtime:evaluation_listener", + "//runtime:function_binding", + "//runtime:unknown_attributes", + "//testing:cel_runtime_flavor", + "//testing/protos:single_file_extension_java_proto", + "//testing/protos:single_file_java_proto", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@com_google_googleapis//google/type:type_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:com_google_truth_extensions_truth_proto_extension", + "@maven//:junit_junit", + "@maven//:org_jspecify_jspecify", + ], +) + +junit4_test_suites( + name = "test_suites", + shard_count = 4, + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java new file mode 100644 index 000000000..ae0de2c18 --- /dev/null +++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java @@ -0,0 +1,370 @@ +// Copyright 2025 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.bundle; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; +import static java.util.stream.Collectors.toCollection; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.io.Resources; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.bundle.CelEnvironment.ExtensionConfig; +import dev.cel.bundle.CelEnvironment.FunctionDecl; +import dev.cel.bundle.CelEnvironment.LibrarySubset; +import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector; +import dev.cel.bundle.CelEnvironment.LibrarySubset.OverloadSelector; +import dev.cel.bundle.CelEnvironment.OverloadDecl; +import dev.cel.bundle.CelEnvironment.TypeDecl; +import dev.cel.bundle.CelEnvironment.VariableDecl; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelVarDecl; +import dev.cel.common.types.ListType; +import dev.cel.common.types.OpaqueType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeParamType; +import dev.cel.extensions.CelExtensions; +import java.net.URL; +import java.util.HashSet; +import java.util.Set; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelEnvironmentExporterTest { + + public static final CelOptions CEL_OPTIONS = + CelOptions.newBuilder().enableHeterogeneousNumericComparisons(true).build(); + + @Test + public void extensions_latest() { + Cel cel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 2)) + .build(); + + CelEnvironment celEnvironment = + CelEnvironmentExporter.newBuilder().addStandardExtensions(CEL_OPTIONS).build().export(cel); + + assertThat(celEnvironment.extensions()) + .containsExactly(ExtensionConfig.newBuilder().setName("math").setVersion(2).build()); + } + + @Test + public void extensions_earlierVersion() { + Cel cel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 1)) + .build(); + + CelEnvironment celEnvironment = + CelEnvironmentExporter.newBuilder().addStandardExtensions(CEL_OPTIONS).build().export(cel); + + assertThat(celEnvironment.extensions()) + .containsExactly(ExtensionConfig.newBuilder().setName("math").setVersion(1).build()); + } + + @Test + public void standardLibrarySubset_favorExclusion() throws Exception { + URL url = Resources.getResource("environment/subset_env.yaml"); + String yamlFileContent = Resources.toString(url, UTF_8); + CelEnvironment environment = CelEnvironmentYamlParser.newInstance().parse(yamlFileContent); + + Cel standardCel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 2)) + .build(); + Cel extendedCel = environment.extend(standardCel, CEL_OPTIONS); + + CelEnvironment celEnvironment = + CelEnvironmentExporter.newBuilder() + .setMaxExcludedStandardFunctions(100) + .setMaxExcludedStandardFunctionOverloads(100) + .build() + .export(extendedCel); + + assertThat(celEnvironment.standardLibrarySubset()) + .hasValue( + LibrarySubset.newBuilder() + .setDisabled(false) + .setExcludedFunctions( + ImmutableSet.of( + FunctionSelector.create( + "_+_", ImmutableSet.of("add_bytes", "add_list", "add_string")), + FunctionSelector.create("duration", ImmutableSet.of("string_to_duration")), + FunctionSelector.create("matches", ImmutableSet.of()), + FunctionSelector.create( + "timestamp", ImmutableSet.of("string_to_timestamp")))) + .setExcludedMacros(ImmutableSet.of("map", "existsOne", "filter")) + .build()); + } + + @Test + public void standardLibrarySubset_favorInclusion() throws Exception { + URL url = Resources.getResource("environment/subset_env.yaml"); + String yamlFileContent = Resources.toString(url, UTF_8); + CelEnvironment environment = CelEnvironmentYamlParser.newInstance().parse(yamlFileContent); + + Cel standardCel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 2)) + .build(); + Cel extendedCel = environment.extend(standardCel, CEL_OPTIONS); + + CelEnvironment celEnvironment = + CelEnvironmentExporter.newBuilder() + .setMaxExcludedStandardFunctions(0) + .setMaxExcludedStandardFunctionOverloads(0) + .build() + .export(extendedCel); + + LibrarySubset actual = celEnvironment.standardLibrarySubset().get(); + + // "matches" is fully excluded + assertThat(actual.includedFunctions().stream().map(FunctionSelector::name)) + .doesNotContain("matches"); + + // A subset of overloads is included. Note the absence of string_to_timestamp + assertThat(actual.includedFunctions()) + .contains( + FunctionSelector.create( + "timestamp", ImmutableSet.of("int64_to_timestamp", "timestamp_to_timestamp"))); + + Set additionOverloads = + actual.includedFunctions().stream() + .filter(fs -> fs.name().equals("_+_")) + .flatMap(fs -> fs.overloads().stream()) + .map(OverloadSelector::id) + .collect(toCollection(HashSet::new)); + assertThat(additionOverloads).containsNoneOf("add_bytes", "add_list", "add_string"); + + assertThat(actual.includedMacros()).containsNoneOf("map", "filter"); + + // Random-check a few standard overloads + assertThat(additionOverloads).containsAtLeast("add_int64", "add_uint64", "add_double"); + + // Random-check a couple of standard functions + assertThat(actual.includedFunctions()) + .contains(FunctionSelector.create("-_", ImmutableSet.of())); + assertThat(actual.includedFunctions()) + .contains(FunctionSelector.create("getDayOfYear", ImmutableSet.of())); + assertThat(actual.includedMacros()).containsAtLeast("all", "exists", "exists_one", "has"); + } + + @Test + public void customFunctions() { + Cel cel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 1)) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "math.isFinite", + CelOverloadDecl.newGlobalOverload( + "math_isFinite_int64", SimpleType.BOOL, SimpleType.INT)), + CelFunctionDecl.newFunctionDeclaration( + "zipGeneric", + CelOverloadDecl.newGlobalOverload( + "zip_list_list", + ListType.create(ListType.create(TypeParamType.create("T"))), + ListType.create(TypeParamType.create("T")), + ListType.create(TypeParamType.create("T")))), + CelFunctionDecl.newFunctionDeclaration( + "zip", + CelOverloadDecl.newGlobalOverload( + "zip_list_int_list_int", + ListType.create(ListType.create(SimpleType.INT)), + ListType.create(SimpleType.INT), + ListType.create(SimpleType.INT))), + CelFunctionDecl.newFunctionDeclaration( + "addWeeks", + CelOverloadDecl.newMemberOverload( + "timestamp_addWeeks", + SimpleType.BOOL, + SimpleType.TIMESTAMP, + SimpleType.INT))) + .build(); + + CelEnvironmentExporter exporter = + CelEnvironmentExporter.newBuilder().addStandardExtensions(CEL_OPTIONS).build(); + CelEnvironment celEnvironment = exporter.export(cel); + + assertThat(celEnvironment.functions()) + .containsAtLeast( + FunctionDecl.create( + "math.isFinite", + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("math_isFinite_int64") + .setArguments(ImmutableList.of(TypeDecl.create("int"))) + .setReturnType(TypeDecl.create("bool")) + .build())), + FunctionDecl.create( + "addWeeks", + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("timestamp_addWeeks") + .setTarget(TypeDecl.create("google.protobuf.Timestamp")) + .setArguments(ImmutableList.of(TypeDecl.create("int"))) + .setReturnType(TypeDecl.create("bool")) + .build())), + FunctionDecl.create( + "zipGeneric", + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("zip_list_list") + .setArguments( + ImmutableList.of( + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .build(), + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .build())) + .setReturnType( + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .build()) + .build()) + .build())), + FunctionDecl.create( + "zip", + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("zip_list_int_list_int") + .setArguments( + ImmutableList.of( + TypeDecl.newBuilder() + .setName("list") + .addParams(TypeDecl.create("int")) + .build(), + TypeDecl.newBuilder() + .setName("list") + .addParams(TypeDecl.create("int")) + .build())) + .setReturnType( + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("list") + .addParams(TypeDecl.create("int")) + .build()) + .build()) + .build()))); + + // Random-check some standard functions: we don't want to see them explicitly defined. + assertThat( + celEnvironment.functions().stream().map(FunctionDecl::name).collect(toImmutableList())) + .containsNoneOf("_+_", "math.abs", "_in_", "__not_strictly_false__"); + } + + @Test + public void customVariables() { + Cel cel = + CelFactory.standardCelBuilder() + .addVarDeclarations( + CelVarDecl.newVarDeclaration("x", SimpleType.INT), + CelVarDecl.newVarDeclaration("y", OpaqueType.create("foo.Bar"))) + .build(); + + CelEnvironmentExporter exporter = + CelEnvironmentExporter.newBuilder().addStandardExtensions(CEL_OPTIONS).build(); + CelEnvironment celEnvironment = exporter.export(cel); + + assertThat(celEnvironment.variables()) + .containsAtLeast( + VariableDecl.create("x", TypeDecl.create("int")), + VariableDecl.create("y", TypeDecl.create("foo.Bar"))); + + // Random-check some standard variables: we don't want to see them explicitly included in + // the CelEnvironment. + assertThat( + celEnvironment.variables().stream().map(VariableDecl::name).collect(toImmutableList())) + .containsNoneOf("double", "null_type"); + } + + @Test + public void container() { + Cel cel = + CelFactory.standardCelBuilder() + .setContainer( + CelContainer.newBuilder() + .setName("cntnr") + .addAbbreviations("foo.Bar", "baz.Qux") + .addAlias("nm", "user.name") + .addAlias("id", "user.id") + .build()) + .build(); + + CelEnvironmentExporter exporter = CelEnvironmentExporter.newBuilder().build(); + CelEnvironment celEnvironment = exporter.export(cel); + CelContainer container = celEnvironment.container().get(); + assertThat(container.name()).isEqualTo("cntnr"); + assertThat(container.abbreviations()).containsExactly("foo.Bar", "baz.Qux").inOrder(); + assertThat(container.aliases()).containsAtLeast("nm", "user.name", "id", "user.id").inOrder(); + } + + @Test + public void options() { + Cel cel = + CelFactory.standardCelBuilder() + .setOptions( + CelOptions.current() + .maxExpressionCodePointSize(100) + .maxParseErrorRecoveryLimit(10) + .maxParseRecursionDepth(10) + .enableQuotedIdentifierSyntax(true) + .enableHeterogeneousNumericComparisons(true) + .populateMacroCalls(true) + .build()) + .build(); + + CelEnvironmentExporter exporter = CelEnvironmentExporter.newBuilder().build(); + CelEnvironment celEnvironment = exporter.export(cel); + assertThat(celEnvironment.features()) + .containsExactly( + CelEnvironment.FeatureFlag.create("cel.feature.backtick_escape_syntax", true), + CelEnvironment.FeatureFlag.create("cel.feature.cross_type_numeric_comparisons", true), + CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true)); + assertThat(celEnvironment.limits()) + .containsExactly( + CelEnvironment.Limit.create("cel.limit.expression_code_points", 100), + CelEnvironment.Limit.create("cel.limit.parse_error_recovery", 10), + CelEnvironment.Limit.create("cel.limit.parse_recursion_depth", 10)); + } +} diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java new file mode 100644 index 000000000..a5a2f3e6d --- /dev/null +++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java @@ -0,0 +1,467 @@ +// Copyright 2025 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.bundle; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableSet; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.bundle.CelEnvironment.CanonicalCelExtension; +import dev.cel.bundle.CelEnvironment.ExtensionConfig; +import dev.cel.bundle.CelEnvironment.LibrarySubset; +import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelStandardMacro; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelEnvironmentTest { + + @Test + public void newBuilder_defaults() { + CelEnvironment environment = CelEnvironment.newBuilder().build(); + + assertThat(environment.source()).isEmpty(); + assertThat(environment.name()).isEmpty(); + assertThat(environment.description()).isEmpty(); + assertThat(environment.container()).isEmpty(); + assertThat(environment.extensions()).isEmpty(); + assertThat(environment.variables()).isEmpty(); + assertThat(environment.functions()).isEmpty(); + } + + @Test + public void container() { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setContainer( + CelContainer.newBuilder() + .setName("cntr") + .addAbbreviations("foo.Bar", "baz.Qux") + .addAlias("nm", "user.name") + .addAlias("id", "user.id") + .build()) + .build(); + + CelContainer container = environment.container().get(); + assertThat(container.name()).isEqualTo("cntr"); + assertThat(container.abbreviations()).containsExactly("foo.Bar", "baz.Qux"); + assertThat(container.aliases()).containsExactly("nm", "user.name", "id", "user.id"); + } + + @Test + public void extend_allExtensions() throws Exception { + ImmutableSet extensionConfigs = + ImmutableSet.of( + ExtensionConfig.latest("bindings"), + ExtensionConfig.latest("encoders"), + ExtensionConfig.latest("lists"), + ExtensionConfig.latest("math"), + ExtensionConfig.latest("optional"), + ExtensionConfig.latest("protos"), + ExtensionConfig.latest("regex"), + ExtensionConfig.latest("sets"), + ExtensionConfig.latest("strings"), + ExtensionConfig.latest("two-var-comprehensions")); + CelEnvironment environment = + CelEnvironment.newBuilder().addExtensions(extensionConfigs).build(); + + Cel cel = environment.extend(CelFactory.standardCelBuilder().build(), CelOptions.DEFAULT); + CelAbstractSyntaxTree ast = + cel.compile( + "cel.bind(x, 10, math.greatest([1,x])) < int(' 11 '.trim()) &&" + + " optional.none().orValue(true) && [].flatten() == []") + .getAst(); + boolean result = (boolean) cel.createProgram(ast).eval(); + + assertThat(extensionConfigs.size()).isEqualTo(CelEnvironment.CEL_EXTENSION_CONFIG_MAP.size()); + assertThat(extensionConfigs.size()).isEqualTo(CanonicalCelExtension.values().length); + assertThat(result).isTrue(); + } + + @Test + public void extend_allFeatureFlags() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setFeatures( + CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true), + CelEnvironment.FeatureFlag.create("cel.feature.backtick_escape_syntax", true), + CelEnvironment.FeatureFlag.create( + "cel.feature.cross_type_numeric_comparisons", true)) + .build(); + + Cel cel = + environment.extend( + CelFactory.standardCelBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(), + CelOptions.DEFAULT); + CelAbstractSyntaxTree ast = + cel.compile("[{'foo.bar': 1}, {'foo.bar': 2}].all(e, e.`foo.bar` < 2.5)").getAst(); + assertThat(ast.getSource().getMacroCalls()).hasSize(1); + boolean result = (boolean) cel.createProgram(ast).eval(); + assertThat(result).isTrue(); + } + + @Test + public void extend_allLimits() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setLimits( + CelEnvironment.Limit.create("cel.limit.expression_code_points", 20), + CelEnvironment.Limit.create("cel.limit.parse_error_recovery", 10), + CelEnvironment.Limit.create("cel.limit.parse_recursion_depth", 10)) + .build(); + + Cel cel = + environment.extend( + CelFactory.standardCelBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(), + CelOptions.DEFAULT); + CelOptions checkerOptions = cel.toCheckerBuilder().options(); + assertThat(checkerOptions.maxExpressionCodePointSize()).isEqualTo(20); + assertThat(checkerOptions.maxParseErrorRecoveryLimit()).isEqualTo(10); + assertThat(checkerOptions.maxParseRecursionDepth()).isEqualTo(10); + + CelAbstractSyntaxTree ast = cel.compile("1 + 2 + 3 + 4 + 5").getAst(); + Long result = (Long) cel.createProgram(ast).eval(); + assertThat(result).isEqualTo(15L); + + CelValidationResult validationResult = cel.compile("1 + 2 + 3 + 4 + 5 + 6"); + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .contains("expression code point size exceeds limit: size: 21, limit 20"); + } + + @Test + public void extend_unsupportedFeatureFlag_throws() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setFeatures(CelEnvironment.FeatureFlag.create("unknown.feature", true)) + .build(); + + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> + environment.extend( + CelFactory.standardCelBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(), + CelOptions.DEFAULT)); + assertThat(e).hasMessageThat().contains("Unknown feature flag: unknown.feature"); + } + + @Test + public void extend_unsupportedLimit_throws() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setLimits(CelEnvironment.Limit.create("unknown.limit", 5)) + .build(); + + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> + environment.extend( + CelFactory.standardCelBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(), + CelOptions.DEFAULT)); + assertThat(e).hasMessageThat().contains("Unknown limit: unknown.limit"); + } + + @Test + public void extensionVersion_specific() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder().addExtensions(ExtensionConfig.of("math", 1)).build(); + + Cel cel = environment.extend(CelFactory.standardCelBuilder().build(), CelOptions.DEFAULT); + CelAbstractSyntaxTree ast1 = cel.compile("math.abs(-4)").getAst(); + assertThat(cel.createProgram(ast1).eval()).isEqualTo(4); + + // Version 1 of the 'math' extension does not include sqrt + assertThat( + assertThrows( + CelValidationException.class, + () -> { + cel.compile("math.sqrt(4)").getAst(); + })) + .hasMessageThat() + .contains("undeclared reference to 'sqrt'"); + } + + @Test + public void extensionVersion_latest() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder().addExtensions(ExtensionConfig.latest("math")).build(); + + Cel cel = environment.extend(CelFactory.standardCelBuilder().build(), CelOptions.DEFAULT); + CelAbstractSyntaxTree ast = cel.compile("math.sqrt(4)").getAst(); + double result = (double) cel.createProgram(ast).eval(); + assertThat(result).isEqualTo(2.0); + } + + @Test + public void extensionVersion_unsupportedVersion_throws() { + CelEnvironment environment = + CelEnvironment.newBuilder().addExtensions(ExtensionConfig.of("math", -5)).build(); + + assertThat( + assertThrows( + CelEnvironmentException.class, + () -> { + environment.extend(CelFactory.standardCelBuilder().build(), CelOptions.DEFAULT); + })) + .hasMessageThat() + .contains("Unsupported 'math' extension version -5"); + } + + @Test + public void stdlibSubset_bothIncludeExcludeSet_throws() { + assertThat( + assertThrows( + IllegalArgumentException.class, + () -> + CelEnvironment.newBuilder() + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setIncludedMacros(ImmutableSet.of("foo")) + .setExcludedMacros(ImmutableSet.of("bar")) + .build()) + .build())) + .hasMessageThat() + .contains("cannot both include and exclude macros"); + + assertThat( + assertThrows( + IllegalArgumentException.class, + () -> + CelEnvironment.newBuilder() + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setIncludedFunctions( + ImmutableSet.of( + FunctionSelector.create("foo", ImmutableSet.of()))) + .setExcludedFunctions( + ImmutableSet.of( + FunctionSelector.create("bar", ImmutableSet.of()))) + .build()) + .build())) + .hasMessageThat() + .contains("cannot both include and exclude functions"); + } + + @Test + public void stdlibSubset_disabled() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setStandardLibrarySubset(LibrarySubset.newBuilder().setDisabled(true).build()) + .build(); + + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT); + CelValidationResult result = extendedCompiler.compile("1 != 2"); + assertThat(result.getErrorString()).contains("undeclared reference to '_!=_'"); + } + + @Test + public void stdlibSubset_macrosDisabled() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setStandardLibrarySubset( + LibrarySubset.newBuilder().setDisabled(false).setMacrosDisabled(true).build()) + .build(); + + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT); + CelValidationResult result = + extendedCompiler.compile("['hello', 'world'].exists(v, v == 'hello')"); + assertThat(result.getErrorString()).contains("undeclared reference to 'exists'"); + } + + @Test + public void stdlibSubset_macrosIncluded() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setIncludedMacros(ImmutableSet.of(CelStandardMacro.EXISTS.getFunction())) + .build()) + .build(); + + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT); + CelValidationResult result = + extendedCompiler.compile("['hello', 'world'].exists(v, v == 'hello')"); + assertThat(result.hasError()).isFalse(); + + result = extendedCompiler.compile("['hello', 'world'].exists_one(v, v == 'hello')"); + assertThat(result.getErrorString()).contains("undeclared reference to 'exists_one'"); + } + + @Test + public void stdlibSubset_macrosExcluded() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setExcludedMacros(ImmutableSet.of(CelStandardMacro.EXISTS_ONE.getFunction())) + .build()) + .build(); + + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT); + CelValidationResult result = + extendedCompiler.compile("['hello', 'world'].exists(v, v == 'hello')"); + assertThat(result.hasError()).isFalse(); + + result = extendedCompiler.compile("['hello', 'world'].exists_one(v, v == 'hello')"); + assertThat(result.getErrorString()).contains("undeclared reference to 'exists_one'"); + } + + @Test + public void stdlibSubset_functionsIncluded() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setIncludedFunctions( + ImmutableSet.of( + FunctionSelector.create("_==_", ImmutableSet.of()), + FunctionSelector.create("_!=_", ImmutableSet.of()), + FunctionSelector.create("_&&_", ImmutableSet.of()))) + .build()) + .build(); + + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT); + CelValidationResult result = extendedCompiler.compile("1 == 1 && 1 != 2"); + assertThat(result.hasError()).isFalse(); + + result = extendedCompiler.compile("1 == 1 && 1 != 1 + 1"); + assertThat(result.getErrorString()).contains("undeclared reference to '_+_'"); + } + + @Test + public void stdlibSubset_functionOverloadIncluded() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setIncludedFunctions( + ImmutableSet.of( + FunctionSelector.create("_+_", ImmutableSet.of("add_int64")))) + .build()) + .build(); + + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT); + CelValidationResult result = extendedCompiler.compile("1 + 2"); + assertThat(result.hasError()).isFalse(); + + result = extendedCompiler.compile("1.0 + 2.0"); + assertThat(result.getErrorString()) + .contains("found no matching overload for '_+_' applied to '(double, double)'"); + } + + @Test + public void stdlibSubset_functionsExcluded() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setExcludedFunctions( + ImmutableSet.of(FunctionSelector.create("_+_", ImmutableSet.of()))) + .build()) + .build(); + + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT); + CelValidationResult result = extendedCompiler.compile("1 == 1 && 1 != 2"); + assertThat(result.hasError()).isFalse(); + + result = extendedCompiler.compile("1 == 1 && 1 != 1 + 1"); + assertThat(result.getErrorString()).contains("undeclared reference to '_+_'"); + } + + @Test + public void stdlibSubset_functionOverloadExcluded() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setExcludedFunctions( + ImmutableSet.of( + FunctionSelector.create("_+_", ImmutableSet.of("add_int64")))) + .build()) + .build(); + + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT); + CelValidationResult result = extendedCompiler.compile("1 == 1 && 1 != 2"); + assertThat(result.hasError()).isFalse(); + + result = extendedCompiler.compile("1 == 1 && 1 != 1 + 1"); + assertThat(result.getErrorString()).contains("found no matching overload for '_+_'"); + } + + @Test + public void typeDecl_toCelType_type() { + CelTypeProvider typeProvider = + CelCompilerFactory.standardCelCompilerBuilder().build().getTypeProvider(); + CelEnvironment.TypeDecl typeDecl = + CelEnvironment.TypeDecl.newBuilder() + .setName("type") + .addParams(CelEnvironment.TypeDecl.create("int")) + .build(); + + CelType celType = typeDecl.toCelType(typeProvider); + + assertThat(celType).isEqualTo(TypeType.create(SimpleType.INT)); + } + + @Test + public void typeDecl_toCelType_type_wrongParamCount_throws() { + CelTypeProvider typeProvider = + CelCompilerFactory.standardCelCompilerBuilder().build().getTypeProvider(); + CelEnvironment.TypeDecl typeDecl = CelEnvironment.TypeDecl.newBuilder().setName("type").build(); + + IllegalStateException e = + assertThrows(IllegalStateException.class, () -> typeDecl.toCelType(typeProvider)); + assertThat(e).hasMessageThat().contains("Expected 1 parameter for type, got 0"); + } +} diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java new file mode 100644 index 000000000..043664e8e --- /dev/null +++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java @@ -0,0 +1,1031 @@ +// Copyright 2025 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.bundle; + +import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.junit.Assert.assertThrows; + +import com.google.common.base.Ascii; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.io.Resources; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.bundle.CelEnvironment.ExtensionConfig; +import dev.cel.bundle.CelEnvironment.FunctionDecl; +import dev.cel.bundle.CelEnvironment.LibrarySubset; +import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector; +import dev.cel.bundle.CelEnvironment.OverloadDecl; +import dev.cel.bundle.CelEnvironment.TypeDecl; +import dev.cel.bundle.CelEnvironment.VariableDecl; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.CelSource; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.types.SimpleType; +import dev.cel.parser.CelUnparserFactory; +import dev.cel.runtime.CelEvaluationListener; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelLateFunctionBindings; +import java.io.IOException; +import java.net.URL; +import java.util.Optional; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelEnvironmentYamlParserTest { + + private static final Cel CEL_WITH_MESSAGE_TYPES = + CelFactory.standardCelBuilder() + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); + + private static final CelEnvironmentYamlParser ENVIRONMENT_PARSER = + CelEnvironmentYamlParser.newInstance(); + + @Test + public void environment_setEmpty() throws Exception { + assertThrows(CelEnvironmentException.class, () -> ENVIRONMENT_PARSER.parse("")); + } + + @Test + public void environment_setBasicProperties() throws Exception { + String yamlConfig = "name: hello\n" + "description: empty\n" + "container: pb.pkg\n"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .setName("hello") + .setDescription("empty") + .setContainer("pb.pkg") + .build()); + } + + @Test + public void environment_setFeatures() throws Exception { + String yamlConfig = + "name: hello\n" + + "description: empty\n" + + "features:\n" + + " - name: 'cel.feature.macro_call_tracking'\n" + + " enabled: true\n" + + " - name: 'cel.feature.backtick_escape_syntax'\n" + + " enabled: false"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .setName("hello") + .setDescription("empty") + .setFeatures( + ImmutableSet.of( + CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true), + CelEnvironment.FeatureFlag.create( + "cel.feature.backtick_escape_syntax", false))) + .build()); + } + + @Test + public void environment_setLimits() throws Exception { + String yamlConfig = + "name: hello\n" + + "description: empty\n" + + "limits:\n" + + " - name: 'cel.limit.expression_code_points'\n" + + " value: 1000\n" + + " - name: 'cel.limit.parse_error_recovery'\n" + + " value: 10\n" + + " - name: 'cel.limit.parse_recursion_depth'\n" + + " value: 7"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .setName("hello") + .setDescription("empty") + .setLimits( + ImmutableSet.of( + CelEnvironment.Limit.create("cel.limit.expression_code_points", 1000), + CelEnvironment.Limit.create("cel.limit.parse_error_recovery", 10), + CelEnvironment.Limit.create("cel.limit.parse_recursion_depth", 7))) + .build()); + } + + @Test + public void environment_setExtensions() throws Exception { + String yamlConfig = + "extensions:\n" + + " - name: 'bindings'\n" + + " - name: 'encoders'\n" + + " - name: 'lists'\n" + + " - name: 'math'\n" + + " - name: 'optional'\n" + + " - name: 'protos'\n" + + " - name: 'sets'\n" + + " - name: 'strings'\n" + + " version: 1"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .addExtensions( + ImmutableSet.of( + ExtensionConfig.of("bindings"), + ExtensionConfig.of("encoders"), + ExtensionConfig.of("lists"), + ExtensionConfig.of("math"), + ExtensionConfig.of("optional"), + ExtensionConfig.of("protos"), + ExtensionConfig.of("sets"), + ExtensionConfig.of("strings", 1))) + .build()); + assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull(); + } + + @Test + public void environment_setExtensionVersionToLatest() throws Exception { + String yamlConfig = + "extensions:\n" // + + " - name: 'bindings'\n" // + + " version: latest"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .addExtensions(ImmutableSet.of(ExtensionConfig.of("bindings", Integer.MAX_VALUE))) + .build()); + assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull(); + } + + @Test + public void environment_setExtensionVersionToInvalidValue() throws Exception { + String yamlConfig = + "extensions:\n" // + + " - name: 'bindings'\n" // + + " version: invalid"; + + CelEnvironmentException e = + assertThrows(CelEnvironmentException.class, () -> ENVIRONMENT_PARSER.parse(yamlConfig)); + assertThat(e) + .hasMessageThat() + .contains( + "ERROR: :3:5: Unsupported version tag: version\n" + + " | version: invalid\n" + + " | ....^"); + } + + @Test + public void environment_setFunctions() throws Exception { + String yamlConfig = + "functions:\n" + + " - name: 'coalesce'\n" + + " overloads:\n" + + " - id: 'null_coalesce_int'\n" + + " target:\n" + + " type_name: 'null_type'\n" + + " args:\n" + + " - type_name: 'int'\n" + + " return:\n" + + " type_name: 'int'\n" + + " - id: 'coalesce_null_int'\n" + + " args:\n" + + " - type_name: 'null_type'\n" + + " - type_name: 'int'\n" + + " return:\n" + + " type_name: 'int' \n" + + " - id: 'int_coalesce_int'\n" + + " target: \n" + + " type_name: 'int'\n" + + " args:\n" + + " - type_name: 'int'\n" + + " return: \n" + + " type_name: 'int'\n" + + " - id: 'optional_T_coalesce_T'\n" + + " target: \n" + + " type_name: 'optional_type'\n" + + " params:\n" + + " - type_name: 'T'\n" + + " is_type_param: true\n" + + " args:\n" + + " - type_name: 'T'\n" + + " is_type_param: true\n" + + " return: \n" + + " type_name: 'T'\n" + + " is_type_param: true"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .setFunctions( + ImmutableSet.of( + FunctionDecl.create( + "coalesce", + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("null_coalesce_int") + .setTarget(TypeDecl.create("null_type")) + .addArguments(TypeDecl.create("int")) + .setReturnType(TypeDecl.create("int")) + .build(), + OverloadDecl.newBuilder() + .setId("coalesce_null_int") + .addArguments( + TypeDecl.create("null_type"), TypeDecl.create("int")) + .setReturnType(TypeDecl.create("int")) + .build(), + OverloadDecl.newBuilder() + .setId("int_coalesce_int") + .setTarget(TypeDecl.create("int")) + .addArguments(TypeDecl.create("int")) + .setReturnType(TypeDecl.create("int")) + .build(), + OverloadDecl.newBuilder() + .setId("optional_T_coalesce_T") + .setTarget( + TypeDecl.newBuilder() + .setName("optional_type") + .addParams( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .build()) + .addArguments( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .setReturnType( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .build())))) + .build()); + assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull(); + } + + @Test + public void environment_setListVariable() throws Exception { + String yamlConfig = + "variables:\n" + + "- name: 'request'\n" + + " type_name: 'list'\n" + + " params:\n" + + " - type_name: 'string'"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .setVariables( + ImmutableSet.of( + VariableDecl.create( + "request", + TypeDecl.newBuilder() + .setName("list") + .addParams(TypeDecl.create("string")) + .build()))) + .build()); + } + + @Test + public void environment_setMapVariable() throws Exception { + String yamlConfig = + "variables:\n" + + "- name: 'request'\n" + + " type:\n" + + " type_name: 'map'\n" + + " params:\n" + + " - type_name: 'string'\n" + + " - type_name: 'dyn'"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .setVariables( + ImmutableSet.of( + VariableDecl.create( + "request", + TypeDecl.newBuilder() + .setName("map") + .addParams(TypeDecl.create("string"), TypeDecl.create("dyn")) + .build()))) + .build()); + assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull(); + } + + @Test + public void environment_setMessageVariable() throws Exception { + String yamlConfig = + "variables:\n" + + "- name: 'request'\n" + + " type:\n" + + " type_name: 'google.rpc.context.AttributeContext.Request'"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .setVariables( + ImmutableSet.of( + VariableDecl.create( + "request", + TypeDecl.create("google.rpc.context.AttributeContext.Request")))) + .build()); + assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull(); + } + + @Test + public void environment_setContainer() throws Exception { + String yamlConfig = + "container: google.rpc.context\n" + + "variables:\n" + + "- name: 'request'\n" + + " type:\n" + + " type_name: 'google.rpc.context.AttributeContext.Request'"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setContainer("google.rpc.context") + .setSource(environment.source().get()) + .setVariables( + ImmutableSet.of( + VariableDecl.create( + "request", + TypeDecl.create("google.rpc.context.AttributeContext.Request")))) + .build()); + assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull(); + } + + @Test + public void environment_setContainerWithAliasesAndAbbreviations() throws Exception { + String yamlConfig = + "container:\n" + + " name: 'google.rpc.context'\n" + + " abbreviations:\n" + + " - 'pkg3.lib3.Baz'\n" + + " - pkg4.lib4.Qux\n" + + " aliases:\n" + + " - alias: 'foo'\n" + + " qualified_name: 'pkg1.lib1.Foo'\n" + + " - alias: bar\n" + + " qualified_name: pkg2.lib2.Bar\n"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setContainer( + CelContainer.newBuilder() + .setName("google.rpc.context") + .addAbbreviations("pkg3.lib3.Baz", "pkg4.lib4.Qux") + .addAlias("foo", "pkg1.lib1.Foo") + .addAlias("bar", "pkg2.lib2.Bar") + .build()) + .setSource(environment.source().get()) + .build()); + } + + @Test + public void environment_withInlinedVariableDecl() throws Exception { + String yamlConfig = + "variables:\n" + + "- name: 'request'\n" + + " type_name: 'google.rpc.context.AttributeContext.Request'\n" + + "- name: 'map_var'\n" + + " type_name: 'map'\n" + + " params:\n" + + " - type_name: 'string'\n" + + " - type_name: 'string'"; + + CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig); + + assertThat(environment) + .isEqualTo( + CelEnvironment.newBuilder() + .setSource(environment.source().get()) + .setVariables( + ImmutableSet.of( + VariableDecl.create( + "request", + TypeDecl.create("google.rpc.context.AttributeContext.Request")), + VariableDecl.create( + "map_var", + TypeDecl.newBuilder() + .setName("map") + .addParams(TypeDecl.create("string"), TypeDecl.create("string")) + .build()))) + .build()); + assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull(); + } + + @Test + public void environment_parseErrors(@TestParameter EnvironmentParseErrorTestcase testCase) { + CelEnvironmentException e = + assertThrows( + CelEnvironmentException.class, () -> ENVIRONMENT_PARSER.parse(testCase.yamlConfig)); + assertThat(e).hasMessageThat().isEqualTo(testCase.expectedErrorMessage); + } + + @Test + public void environment_extendErrors(@TestParameter EnvironmentExtendErrorTestCase testCase) + throws Exception { + CelEnvironment environment = ENVIRONMENT_PARSER.parse(testCase.yamlConfig); + + CelEnvironmentException e = + assertThrows( + CelEnvironmentException.class, + () -> environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)); + assertThat(e).hasMessageThat().isEqualTo(testCase.expectedErrorMessage); + } + + // Note: dangling comments in expressions below is to retain the newlines by preventing auto + // formatter from compressing them in a single line. + private enum EnvironmentParseErrorTestcase { + MALFORMED_YAML_DOCUMENT( + "a:\na", + "YAML document is malformed: while scanning a simple key\n" + + " in 'reader', line 2, column 1:\n" + + " a\n" + + " ^\n" + + "could not find expected ':'\n" + + " in 'reader', line 2, column 2:\n" + + " a\n" + + " ^\n"), + ILLEGAL_YAML_TYPE_CONFIG_KEY( + "1: test", + "ERROR: :1:1: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | 1: test\n" + + " | ^"), + ILLEGAL_YAML_TYPE_CONFIG_VALUE( + "test: 1", "ERROR: :1:1: Unknown config tag: test\n" + " | test: 1\n" + " | ^"), + ILLEGAL_YAML_TYPE_VARIABLE_LIST( + "variables: 1", + "ERROR: :1:12: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | variables: 1\n" + + " | ...........^"), + ILLEGAL_YAML_TYPE_VARIABLE_VALUE( + "variables:\n - 1", + "ERROR: :2:4: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - 1\n" + + " | ...^"), + ILLEGAL_YAML_TYPE_FUNCTION_LIST( + "functions: 1", + "ERROR: :1:12: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | functions: 1\n" + + " | ...........^"), + ILLEGAL_YAML_TYPE_FUNCTION_VALUE( + "functions:\n - 1", + "ERROR: :2:4: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - 1\n" + + " | ...^"), + ILLEGAL_YAML_TYPE_OVERLOAD_LIST( + "functions:\n" // + + " - name: foo\n" // + + " overloads: 1", + "ERROR: :3:15: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | overloads: 1\n" + + " | ..............^"), + ILLEGAL_YAML_TYPE_OVERLOAD_VALUE( + "functions:\n" // + + " - name: foo\n" // + + " overloads:\n" // + + " - 2", + "ERROR: :4:7: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - 2\n" + + " | ......^"), + ILLEGAL_YAML_TYPE_OVERLOAD_VALUE_MAP_KEY( + "functions:\n" // + + " - name: foo\n" // + + " overloads:\n" // + + " - 2: test", + "ERROR: :4:9: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | - 2: test\n" + + " | ........^\n" + + "ERROR: :4:9: Missing required attribute(s): id, return\n" + + " | - 2: test\n" + + " | ........^"), + ILLEGAL_YAML_TYPE_EXTENSION_LIST( + "extensions: 1", + "ERROR: :1:13: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | extensions: 1\n" + + " | ............^"), + ILLEGAL_YAML_TYPE_EXTENSION_VALUE( + "extensions:\n - 1", + "ERROR: :2:4: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - 1\n" + + " | ...^"), + ILLEGAL_YAML_TYPE_TYPE_DECL( + "variables:\n" // + + " - name: foo\n" // + + " type: 1", + "ERROR: :3:10: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | type: 1\n" + + " | .........^"), + ILLEGAL_YAML_TYPE_TYPE_VALUE( + "variables:\n" + + " - name: foo\n" + + " type:\n" + + " type_name: bar\n" + + " 1: hello", + "ERROR: :5:6: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | 1: hello\n" + + " | .....^"), + ILLEGAL_YAML_TYPE_TYPE_PARAMS_LIST( + "variables:\n" + + " - name: foo\n" + + " type:\n" + + " type_name: bar\n" + + " params: 1", + "ERROR: :5:14: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | params: 1\n" + + " | .............^"), + ILLEGAL_YAML_TYPE_WITH_INLINED_TYPE_TAGS( + "variables:\n" + + " - name: foo\n" + + " type_name: bar\n" + + " type:\n" + + " type_name: qux\n", + "ERROR: :4:4: 'type' tag cannot be used together with inlined 'type_name'," + + " 'is_type_param' or 'params': type\n" + + " | type:\n" + + " | ...^"), + ILLEGAL_YAML_INLINED_TYPE_VALUE( + "variables:\n" // + + " - name: foo\n" // + + " type_name: 1\n", + "ERROR: :3:15: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | type_name: 1\n" + + " | ..............^"), + UNSUPPORTED_CONFIG_TAG( + "unsupported: test", + "ERROR: :1:1: Unknown config tag: unsupported\n" + + " | unsupported: test\n" + + " | ^"), + UNSUPPORTED_EXTENSION_TAG( + "extensions:\n" // + + " - name: foo\n" // + + " unsupported: test", + "ERROR: :3:5: Unsupported extension tag: unsupported\n" + + " | unsupported: test\n" + + " | ....^"), + UNSUPPORTED_TYPE_DECL_TAG( + "variables:\n" + + "- name: foo\n" + + " type:\n" + + " type_name: bar\n" + + " unsupported: hello", + "ERROR: :5:6: Unsupported type decl tag: unsupported\n" + + " | unsupported: hello\n" + + " | .....^"), + MISSING_VARIABLE_PROPERTIES( + "variables:\n - illegal: 2", + "ERROR: :2:4: Unsupported variable tag: illegal\n" + + " | - illegal: 2\n" + + " | ...^\n" + + "ERROR: :2:4: Missing required attribute(s): name, type\n" + + " | - illegal: 2\n" + + " | ...^"), + MISSING_OVERLOAD_RETURN( + "functions:\n" + + " - name: 'missing_return'\n" + + " overloads:\n" + + " - id: 'zero_arity'\n", + "ERROR: :4:9: Missing required attribute(s): return\n" + + " | - id: 'zero_arity'\n" + + " | ........^"), + MISSING_FUNCTION_NAME( + "functions:\n" + + " - overloads:\n" + + " - id: 'foo'\n" + + " return:\n" + + " type_name: 'string'\n", + "ERROR: :2:5: Missing required attribute(s): name\n" + + " | - overloads:\n" + + " | ....^"), + MISSING_OVERLOAD( + "functions:\n" + " - name: 'missing_overload'\n", + "ERROR: :2:5: Missing required attribute(s): overloads\n" + + " | - name: 'missing_overload'\n" + + " | ....^"), + MISSING_EXTENSION_NAME( + "extensions:\n" + "- version: 0", + "ERROR: :2:3: Missing required attribute(s): name\n" + + " | - version: 0\n" + + " | ..^"), + ILLEGAL_LIBRARY_SUBSET_TAG( + "name: 'test_suite_name'\n" + "stdlib:\n" + " unknown_tag: 'test_value'\n", + "ERROR: :3:3: Unsupported library subset tag: unknown_tag\n" + + " | unknown_tag: 'test_value'\n" + + " | ..^"), + ILLEGAL_LIBRARY_SUBSET_FUNCTION_SELECTOR_TAG( + "name: 'test_suite_name'\n" + + "stdlib:\n" + + " include_functions:\n" + + " - name: 'test_function'\n" + + " unknown_tag: 'test_value'\n", + "ERROR: :5:7: Unsupported function selector tag: unknown_tag\n" + + " | unknown_tag: 'test_value'\n" + + " | ......^"), + MISSING_LIBRARY_SUBSET_FUNCTION_SELECTOR_NAME( + "name: 'test_suite_name'\n" + + "stdlib:\n" + + " include_functions:\n" + + " - overloads:\n" + + " - id: add_bytes\n", + "ERROR: :4:7: Missing required attribute(s): name\n" + + " | - overloads:\n" + + " | ......^"), + ILLEGAL_LIBRARY_SUBSET_OVERLOAD_SELECTOR_TAG( + "name: 'test_suite_name'\n" + + "stdlib:\n" + + " include_functions:\n" + + " - name: _+_\n" + + " overloads:\n" + + " - id: test_overload\n" + + " unknown_tag: 'test_value'\n", + "ERROR: :7:11: Unsupported overload selector tag: unknown_tag\n" + + " | unknown_tag: 'test_value'\n" + + " | ..........^"), + MISSING_ALIAS_FIELDS( + "container:\n" + + " name: 'test_container'\n" + + " aliases:\n" + + " - qualified_name: 'test_qualified_name'\n", + "ERROR: :4:7: Missing required attribute(s): alias\n" + + " | - qualified_name: 'test_qualified_name'\n" + + " | ......^"), + ILLEGAL_ALIAS_TAG( + "container:\n" + + " name: 'test_container'\n" + + " aliases:\n" + + " - alias: 'test_alias'\n" + + " qualified_name: 'test_qualified_name'\n" + + " unknown_tag: 'test_value'\n", + "ERROR: :6:7: Unsupported alias tag: unknown_tag\n" + + " | unknown_tag: 'test_value'\n" + + " | ......^"), + UNSUPPORTED_LIMIT_TAG( + "limits:\n" + + " - name: 'test_limit'\n" + + " unknown_tag: 'test_value'\n" + + " value: 100\n", + "ERROR: :3:5: Unsupported limits tag: unknown_tag\n" + + " | unknown_tag: 'test_value'\n" + + " | ....^"), + MISSING_LIMIT_NAME( + "limits:\n" + " - value: 100\n", + "ERROR: :2:5: Missing required attribute(s): name\n" + + " | - value: 100\n" + + " | ....^"), + MISSING_LIMIT_VALUE( + "limits:\n" + " - name: 'test_limit'\n", + "ERROR: :2:5: Missing required attribute(s): value\n" + + " | - name: 'test_limit'\n" + + " | ....^"), + ILLEGAL_LIMIT_VALUE( + "limits:\n" + " - cel.limit.foo: 'not_a_number'\n", + "ERROR: :2:21: Got yaml node type tag:yaml.org,2002:str, wanted type(s)" + + " [tag:yaml.org,2002:int]\n" + + " | - cel.limit.foo: 'not_a_number'\n" + + " | ....................^"), + ILLEGAL_FEATURE_TAG( + "features:\n" + " - name: 'test_feature'\n" + " unknown_tag: 'test_value'\n", + "ERROR: :3:5: Unsupported feature tag: unknown_tag\n" + + " | unknown_tag: 'test_value'\n" + + " | ....^"), + MISSING_FEATURE_NAME( + "features:\n" + " - enabled: true\n", + "ERROR: :2:5: Missing required attribute(s): name\n" + + " | - enabled: true\n" + + " | ....^"), + ; + + private final String yamlConfig; + private final String expectedErrorMessage; + + EnvironmentParseErrorTestcase(String yamlConfig, String expectedErrorMessage) { + this.yamlConfig = yamlConfig; + this.expectedErrorMessage = expectedErrorMessage; + } + } + + private enum EnvironmentExtendErrorTestCase { + BAD_EXTENSION("extensions:\n" + " - name: 'bad_name'", "Unrecognized extension: bad_name"), + BAD_TYPE( + "variables:\n" + "- name: 'bad_type'\n" + " type:\n" + " type_name: 'strings'", + "Undefined type name: strings"), + BAD_LIST( + "variables:\n" + " - name: 'bad_list'\n" + " type:\n" + " type_name: 'list'", + "List type has unexpected param count: 0"), + BAD_MAP( + "variables:\n" + + " - name: 'bad_map'\n" + + " type:\n" + + " type_name: 'map'\n" + + " params:\n" + + " - type_name: 'string'", + "Map type has unexpected param count: 1"), + BAD_LIST_TYPE_PARAM( + "variables:\n" + + " - name: 'bad_list_type_param'\n" + + " type:\n" + + " type_name: 'list'\n" + + " params:\n" + + " - type_name: 'number'", + "Undefined type name: number"), + BAD_MAP_TYPE_PARAM( + "variables:\n" + + " - name: 'bad_map_type_param'\n" + + " type:\n" + + " type_name: 'map'\n" + + " params:\n" + + " - type_name: 'string'\n" + + " - type_name: 'optional'", + "Undefined type name: optional"), + BAD_RETURN( + "functions:\n" + + " - name: 'bad_return'\n" + + " overloads:\n" + + " - id: 'zero_arity'\n" + + " return:\n" + + " type_name: 'mystery'", + "Undefined type name: mystery"), + BAD_OVERLOAD_TARGET( + "functions:\n" + + " - name: 'bad_target'\n" + + " overloads:\n" + + " - id: 'unary_member'\n" + + " target:\n" + + " type_name: 'unknown'\n" + + " return:\n" + + " type_name: 'null_type'", + "Undefined type name: unknown"), + BAD_OVERLOAD_ARG( + "functions:\n" + + " - name: 'bad_arg'\n" + + " overloads:\n" + + " - id: 'unary_global'\n" + + " args:\n" + + " - type_name: 'unknown'\n" + + " return:\n" + + " type_name: 'null_type'", + "Undefined type name: unknown"), + ; + + private final String yamlConfig; + private final String expectedErrorMessage; + + EnvironmentExtendErrorTestCase(String yamlConfig, String expectedErrorMessage) { + this.yamlConfig = yamlConfig; + this.expectedErrorMessage = expectedErrorMessage; + } + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum EnvironmentYamlResourceTestCase { + EXTENDED_ENV( + "environment/extended_env.yaml", + CelEnvironment.newBuilder() + .setName("extended-env") + .setContainer("cel.expr") + .addExtensions( + ImmutableSet.of( + ExtensionConfig.of("optional", 2), + ExtensionConfig.of("math", Integer.MAX_VALUE))) + .setVariables( + VariableDecl.newBuilder() + .setName("msg") + .setDescription( + "msg represents all possible type permutation which CEL understands from a" + + " proto perspective") + .setType(TypeDecl.create("cel.expr.conformance.proto3.TestAllTypes")) + .build()) + .setFunctions( + FunctionDecl.newBuilder() + .setName("isEmpty") + .setDescription( + "determines whether a list is empty,\nor a string has no characters") + .setOverloads( + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("wrapper_string_isEmpty") + .setTarget(TypeDecl.create("google.protobuf.StringValue")) + .addExamples("''.isEmpty() // true") + .setReturnType(TypeDecl.create("bool")) + .build(), + OverloadDecl.newBuilder() + .setId("list_isEmpty") + .addExamples("[].isEmpty() // true") + .addExamples("[1].isEmpty() // false") + .setTarget( + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .build()) + .setReturnType(TypeDecl.create("bool")) + .build())) + .build()) + .setFeatures(CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true)) + .setLimits( + ImmutableSet.of( + CelEnvironment.Limit.create("cel.limit.expression_code_points", 1000), + CelEnvironment.Limit.create("cel.limit.parse_recursion_depth", 7))) + .build()), + + LIBRARY_SUBSET_ENV( + "environment/subset_env.yaml", + CelEnvironment.newBuilder() + .setName("subset-env") + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setExcludedMacros(ImmutableSet.of("map", "filter")) + .setExcludedFunctions( + ImmutableSet.of( + FunctionSelector.create( + "_+_", ImmutableSet.of("add_bytes", "add_list", "add_string")), + FunctionSelector.create("matches", ImmutableSet.of()), + FunctionSelector.create( + "timestamp", ImmutableSet.of("string_to_timestamp")), + FunctionSelector.create( + "duration", ImmutableSet.of("string_to_duration")))) + .build()) + .setVariables( + VariableDecl.create("x", TypeDecl.create("int")), + VariableDecl.create("y", TypeDecl.create("double")), + VariableDecl.create("z", TypeDecl.create("uint"))) + .build()), + ; + + private final String yamlFileContent; + private final CelEnvironment expectedEnvironment; + + EnvironmentYamlResourceTestCase(String yamlResourcePath, CelEnvironment expectedEnvironment) { + try { + this.yamlFileContent = readFile(yamlResourcePath); + } catch (IOException e) { + throw new RuntimeException(e); + } + this.expectedEnvironment = expectedEnvironment; + } + } + + @Test + public void environment_withYamlResource(@TestParameter EnvironmentYamlResourceTestCase testCase) + throws Exception { + CelEnvironment environment = ENVIRONMENT_PARSER.parse(testCase.yamlFileContent); + + // Empty out the parsed yaml source, as it's not relevant in the assertion here, and that it's + // only obtainable through the yaml parser. + environment = environment.toBuilder().setSource(Optional.empty()).build(); + assertThat(environment).isEqualTo(testCase.expectedEnvironment); + } + + @Test + public void lateBoundFunction_evaluate_callExpr() throws Exception { + String configSource = + "name: late_bound_function_config\n" + + "functions:\n" + + " - name: 'test'\n" + + " overloads:\n" + + " - id: 'test_bool'\n" + + " args:\n" + + " - type_name: 'bool'\n" + + " return:\n" + + " type_name: 'bool'"; + CelEnvironment celEnvironment = ENVIRONMENT_PARSER.parse(configSource); + Cel celDetails = + CelFactory.standardCelBuilder() + .addVar("a", SimpleType.INT) + .addVar("b", SimpleType.INT) + .addVar("c", SimpleType.INT) + .build(); + Cel cel = celEnvironment.extend(celDetails, CelOptions.DEFAULT); + CelAbstractSyntaxTree ast = cel.compile("a < 0 && b < 0 && c < 0 && test(a<0)").getAst(); + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from("test_bool", Boolean.class, result -> result)); + + boolean result = + (boolean) cel.createProgram(ast).eval(ImmutableMap.of("a", -1, "b", -1, "c", -4), bindings); + + assertThat(result).isTrue(); + } + + @Test + public void lateBoundFunction_trace_callExpr_identifyFalseBranch() throws Exception { + AtomicReference capturedExpr = new AtomicReference<>(); + CelEvaluationListener listener = + (expr, res) -> { + if (res instanceof Boolean && !(boolean) res && capturedExpr.get() == null) { + capturedExpr.set(expr); + } + }; + + String configSource = + "name: late_bound_function_config\n" + + "functions:\n" + + " - name: 'test'\n" + + " overloads:\n" + + " - id: 'test_bool'\n" + + " args:\n" + + " - type_name: 'bool'\n" + + " return:\n" + + " type_name: 'bool'"; + + CelEnvironment celEnvironment = ENVIRONMENT_PARSER.parse(configSource); + Cel celDetails = + CelFactory.standardCelBuilder() + .addVar("a", SimpleType.INT) + .addVar("b", SimpleType.INT) + .addVar("c", SimpleType.INT) + .build(); + Cel cel = celEnvironment.extend(celDetails, CelOptions.DEFAULT); + CelAbstractSyntaxTree ast = cel.compile("a < 0 && b < 0 && c < 0 && test(a<0)").getAst(); + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from("test_bool", Boolean.class, result -> result)); + + boolean result = + (boolean) + cel.createProgram(ast) + .trace(ImmutableMap.of("a", -1, "b", 1, "c", -4), bindings, listener); + + assertThat(result).isFalse(); + // Demonstrate that "b < 0" is what caused the expression to be false + CelAbstractSyntaxTree subtree = + CelAbstractSyntaxTree.newParsedAst(capturedExpr.get(), CelSource.newBuilder().build()); + assertThat(CelUnparserFactory.newUnparser().unparse(subtree)).isEqualTo("b < 0"); + } + + private static String readFile(String path) throws IOException { + URL url = Resources.getResource(Ascii.toLowerCase(path)); + return Resources.toString(url, UTF_8); + } +} diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlSerializerTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlSerializerTest.java new file mode 100644 index 000000000..aad72a578 --- /dev/null +++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlSerializerTest.java @@ -0,0 +1,250 @@ +// Copyright 2025 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.bundle; + +import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; + +import com.google.common.base.Ascii; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.io.Resources; +import dev.cel.bundle.CelEnvironment.ExtensionConfig; +import dev.cel.bundle.CelEnvironment.FunctionDecl; +import dev.cel.bundle.CelEnvironment.LibrarySubset; +import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector; +import dev.cel.bundle.CelEnvironment.OverloadDecl; +import dev.cel.bundle.CelEnvironment.TypeDecl; +import dev.cel.bundle.CelEnvironment.VariableDecl; +import dev.cel.common.CelContainer; +import java.io.IOException; +import java.net.URL; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelEnvironmentYamlSerializerTest { + + @Test + public void toYaml_success() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setName("dump_env") + .setDescription("dump_env description") + .setContainer( + CelContainer.newBuilder() + .setName("test.container") + .addAbbreviations("abbr1.Abbr1", "abbr2.Abbr2") + .addAlias("alias1", "qual.name1") + .addAlias("alias2", "qual.name2") + .build()) + .addExtensions( + ImmutableSet.of( + ExtensionConfig.of("bindings"), + ExtensionConfig.of("encoders"), + ExtensionConfig.of("lists"), + ExtensionConfig.of("math"), + ExtensionConfig.of("optional"), + ExtensionConfig.of("protos"), + ExtensionConfig.of("sets"), + ExtensionConfig.of("strings", 1))) + .setVariables( + ImmutableSet.of( + VariableDecl.create( + "request", TypeDecl.create("google.rpc.context.AttributeContext.Request")), + VariableDecl.create( + "map_var", + TypeDecl.newBuilder() + .setName("map") + .addParams(TypeDecl.create("string")) + .addParams(TypeDecl.create("string")) + .build()))) + .setFunctions( + ImmutableSet.of( + FunctionDecl.create( + "getOrDefault", + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("getOrDefault_key_value") + .setTarget( + TypeDecl.newBuilder() + .setName("map") + .addParams( + TypeDecl.newBuilder() + .setName("K") + .setIsTypeParam(true) + .build()) + .addParams( + TypeDecl.newBuilder() + .setName("V") + .setIsTypeParam(true) + .build()) + .build()) + .setArguments( + ImmutableList.of( + TypeDecl.newBuilder() + .setName("K") + .setIsTypeParam(true) + .build(), + TypeDecl.newBuilder() + .setName("V") + .setIsTypeParam(true) + .build())) + .setReturnType( + TypeDecl.newBuilder().setName("V").setIsTypeParam(true).build()) + .build())), + FunctionDecl.create( + "zip", + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("zip_list_int_list_int") + .setArguments( + ImmutableList.of( + TypeDecl.newBuilder() + .setName("list") + .addParams(TypeDecl.create("int")) + .build(), + TypeDecl.newBuilder() + .setName("list") + .addParams(TypeDecl.create("int")) + .build())) + .setReturnType( + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("list") + .addParams(TypeDecl.create("int")) + .build()) + .build()) + .build())), + FunctionDecl.create( + "zipGeneric", + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("zip_list_list") + .setArguments( + ImmutableList.of( + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .build(), + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .build())) + .setReturnType( + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("list") + .addParams( + TypeDecl.newBuilder() + .setName("T") + .setIsTypeParam(true) + .build()) + .build()) + .build()) + .build())), + FunctionDecl.create( + "coalesce", + ImmutableSet.of( + OverloadDecl.newBuilder() + .setId("coalesce_null_int") + .setTarget(TypeDecl.create("google.protobuf.Int64Value")) + .setArguments(ImmutableList.of(TypeDecl.create("int"))) + .setReturnType(TypeDecl.create("int")) + .build())))) + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(true) + .setMacrosDisabled(true) + .setIncludedMacros(ImmutableSet.of("has", "exists")) + .setIncludedFunctions( + ImmutableSet.of( + FunctionSelector.create("_!=_", ImmutableSet.of()), + FunctionSelector.create( + "_+_", ImmutableSet.of("add_bytes", "add_list")))) + .build()) + .setFeatures( + CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true), + CelEnvironment.FeatureFlag.create("cel.feature.backtick_escape_syntax", false)) + .setLimits( + CelEnvironment.Limit.create("cel.limit.expression_code_points", 1000), + CelEnvironment.Limit.create("cel.limit.parse_error_recovery", 10), + CelEnvironment.Limit.create("cel.limit.parse_recursion_depth", 7)) + .build(); + + String yamlOutput = CelEnvironmentYamlSerializer.toYaml(environment); + try { + String yamlFileContent = readFile("environment/dump_env.yaml"); + // Strip the license at the beginning of the file + String expectedOutput = yamlFileContent.replaceAll("#.*\\n", "").replaceAll("^\\n", ""); + assertThat(yamlOutput).isEqualTo(expectedOutput); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + private static String readFile(String path) throws IOException { + URL url = Resources.getResource(Ascii.toLowerCase(path)); + return Resources.toString(url, UTF_8); + } + + @Test + public void standardLibrary_excludeMacrosAndFunctions() throws Exception { + CelEnvironment environment = + CelEnvironment.newBuilder() + .setName("dump_env") + .setStandardLibrarySubset( + LibrarySubset.newBuilder() + .setDisabled(false) + .setExcludedMacros(ImmutableSet.of("has", "exists")) + .setExcludedFunctions( + ImmutableSet.of( + FunctionSelector.create("_!=_", ImmutableSet.of()), + FunctionSelector.create( + "_+_", ImmutableSet.of("add_bytes", "add_list")))) + .build()) + .build(); + + String yamlOutput = CelEnvironmentYamlSerializer.toYaml(environment); + + String expectedYaml = + "name: dump_env\n" + + "stdlib:\n" + + " exclude_macros:\n" + + " - exists\n" + + " - has\n" + + " exclude_functions:\n" + + " - name: _!=_\n" + + " - name: _+_\n" + + " overloads:\n" + + " - id: add_bytes\n" + + " - id: add_list\n"; + + assertThat(yamlOutput).isEqualTo(expectedYaml); + } +} diff --git a/bundle/src/test/java/dev/cel/bundle/CelFactoryTest.java b/bundle/src/test/java/dev/cel/bundle/CelFactoryTest.java new file mode 100644 index 000000000..456ea628c --- /dev/null +++ b/bundle/src/test/java/dev/cel/bundle/CelFactoryTest.java @@ -0,0 +1,49 @@ +// Copyright 2022 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.bundle; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.ast.CelExpr; +import dev.cel.parser.CelMacro; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelFactoryTest { + + @Test + public void legacyCelBuilder() { + assertThat(CelFactory.standardCelBuilder().build()).isNotNull(); + } + + @Test + public void standardCelBuilder() { + assertThat(CelFactory.standardCelBuilder().build()).isNotNull(); + } + + @Test + public void addCustomMacros_currentParser_success() { + assertThat( + CelFactory.standardCelBuilder() + .addMacros( + CelMacro.newReceiverMacro( + "dummy", 0, (a, b, c) -> Optional.of(CelExpr.newBuilder().build()))) + .build()) + .isNotNull(); + } +} diff --git a/bundle/src/test/java/dev/cel/bundle/CelImplTest.java b/bundle/src/test/java/dev/cel/bundle/CelImplTest.java new file mode 100644 index 000000000..a3ad60d40 --- /dev/null +++ b/bundle/src/test/java/dev/cel/bundle/CelImplTest.java @@ -0,0 +1,2341 @@ +// Copyright 2022 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.bundle; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; +import static dev.cel.common.CelOverloadDecl.newMemberOverload; +import static org.junit.Assert.assertThrows; + +import dev.cel.expr.CheckedExpr; +import dev.cel.expr.Constant; +import dev.cel.expr.Decl; +import dev.cel.expr.Decl.FunctionDecl; +import dev.cel.expr.Decl.FunctionDecl.Overload; +import dev.cel.expr.Decl.IdentDecl; +import dev.cel.expr.Expr; +import dev.cel.expr.Expr.Call; +import dev.cel.expr.Expr.Ident; +import dev.cel.expr.Expr.Select; +import dev.cel.expr.ParsedExpr; +import dev.cel.expr.Reference; +import dev.cel.expr.Type; +import dev.cel.expr.Type.PrimitiveType; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.util.concurrent.MoreExecutors; +import com.google.protobuf.Any; +import com.google.protobuf.ByteString; +import com.google.protobuf.DescriptorProtos.FileDescriptorProto; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.Duration; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.Empty; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.FieldMask; +import com.google.protobuf.Message; +import com.google.protobuf.Struct; +import com.google.protobuf.TextFormat; +import com.google.protobuf.Timestamp; +import com.google.protobuf.TypeRegistry; +import com.google.protobuf.WrappersProto; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.checker.CelCheckerLegacyImpl; +import dev.cel.checker.DescriptorTypeProvider; +import dev.cel.checker.ProtoTypeMask; +import dev.cel.checker.TypeProvider; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelErrorCode; +import dev.cel.common.CelIssue; +import dev.cel.common.CelOptions; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.common.CelSource.Extension; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.CelVarDecl; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.testing.RepeatedTestProvider; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelProtoMessageTypes; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.EnumType; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.compiler.CelCompilerImpl; +import dev.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage; +import dev.cel.expr.conformance.proto2.TestAllTypesExtensions; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelExtensions; +import dev.cel.parser.CelParserImpl; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelAttribute; +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.CelFunctionBinding; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntime.Program; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.runtime.CelRuntimeLegacyImpl; +import dev.cel.runtime.CelUnknownSet; +import dev.cel.runtime.CelVariableResolver; +import dev.cel.runtime.UnknownContext; +import dev.cel.testing.CelRuntimeFlavor; +import dev.cel.testing.testdata.SingleFile; +import dev.cel.testing.testdata.SingleFileExtensionsProto; +import dev.cel.testing.testdata.proto3.StandaloneGlobalEnum; +import java.time.Instant; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.ThreadPoolExecutor; +import org.jspecify.annotations.Nullable; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelImplTest { + + private static final Expr NOT_EXPR = + Expr.newBuilder() + .setCallExpr( + Call.newBuilder() + .setFunction("!_") + .addArgs( + Expr.newBuilder().setConstExpr(Constant.newBuilder().setBoolValue(true)))) + .build(); + + private static final Expr NOT_NOT_NOT_EXPR = + Expr.newBuilder() + .setCallExpr( + Call.newBuilder() + .setFunction("!_") + .addArgs( + Expr.newBuilder() + .setCallExpr(Call.newBuilder().setFunction("!_").addArgs(NOT_EXPR)))) + .build(); + + private static final Expr EXPR = + Expr.newBuilder() + .setCallExpr( + Call.newBuilder() + .setFunction("_&&_") + .addArgs(Expr.newBuilder().setConstExpr(Constant.newBuilder().setBoolValue(true))) + .addArgs( + Expr.newBuilder() + .setCallExpr( + Call.newBuilder() + .setFunction("!_") + .addArgs( + Expr.newBuilder() + .setConstExpr( + Constant.newBuilder().setBoolValue(false)))))) + .build(); + + private static final ParsedExpr PARSED_EXPR = ParsedExpr.newBuilder().setExpr(EXPR).build(); + private static final CheckedExpr CHECKED_EXPR = + CheckedExpr.newBuilder() + .setExpr(EXPR) + .putTypeMap(1L, CelProtoTypes.BOOL) + .putTypeMap(2L, CelProtoTypes.BOOL) + .putTypeMap(3L, CelProtoTypes.BOOL) + .putTypeMap(4L, CelProtoTypes.BOOL) + .putReferenceMap(2L, Reference.newBuilder().addOverloadId("logical_and").build()) + .putReferenceMap(3L, Reference.newBuilder().addOverloadId("logical_not").build()) + .build(); + + private static final ParsedExpr PARSED_HAS_EXPR = + ParsedExpr.newBuilder() + .setExpr( + Expr.newBuilder() + .setSelectExpr( + Select.newBuilder() + .setOperand( + Expr.newBuilder().setIdentExpr(Ident.newBuilder().setName("a"))) + .setField("b") + .setTestOnly(true))) + .build(); + + private CelBuilder standardCelBuilderWithMacros() { + return CelFactory.standardCelBuilder().setStandardMacros(CelStandardMacro.STANDARD_MACROS); + } + + @Test + public void build_badFileDescriptorSet() { + IllegalArgumentException e = + Assert.assertThrows( + IllegalArgumentException.class, + () -> + standardCelBuilderWithMacros() + .setContainer(CelContainer.ofName("cel.expr.conformance.proto2")) + .addFileTypes( + FileDescriptorSet.newBuilder() + .addFile(TestAllTypesExtensions.getDescriptor().getFile().toProto()) + .build()) + .build()); + assertThat(e).hasMessageThat().contains("file descriptor set with unresolved proto file"); + } + + @Test + public void parse() throws Exception { + Cel cel = standardCelBuilderWithMacros().build(); + assertValidationResult(cel.parse("true && !false"), PARSED_EXPR); + } + + @Test + public void check() throws Exception { + Cel cel = standardCelBuilderWithMacros().setResultType(SimpleType.BOOL).build(); + CelValidationResult parseResult = cel.parse("true && !false"); + assertValidationResult(parseResult, PARSED_EXPR); + CelValidationResult checkResult = cel.check(parseResult.getAst()); + assertValidationResult(checkResult, CHECKED_EXPR); + } + + @Test + @TestParameters("{useProtoResultType: false}") + @TestParameters("{useProtoResultType: true}") + public void compile(boolean useProtoResultType) throws Exception { + CelBuilder celBuilder = standardCelBuilderWithMacros(); + if (useProtoResultType) { + celBuilder.setProtoResultType(CelProtoTypes.BOOL); + } else { + celBuilder.setResultType(SimpleType.BOOL); + } + Cel cel = celBuilder.build(); + assertValidationResult(cel.compile("true && !false"), CHECKED_EXPR); + } + + @Test + @TestParameters("{useProtoResultType: false}") + @TestParameters("{useProtoResultType: true}") + public void compile_resultTypeCheckFailure(boolean useProtoResultType) { + CelBuilder celBuilder = standardCelBuilderWithMacros(); + if (useProtoResultType) { + celBuilder.setProtoResultType(CelProtoTypes.STRING); + } else { + celBuilder.setResultType(SimpleType.STRING); + } + Cel cel = celBuilder.build(); + CelValidationResult validationResult = cel.compile("true && !false"); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .contains("expected type 'string' but found 'bool'"); + } + + @Test + public void compile_combinedTypeProvider() { + ProtoMessageTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(ImmutableList.of(AttributeContext.getDescriptor())); + Cel cel = + standardCelBuilderWithMacros() + .setContainer(CelContainer.ofName("google")) + .setTypeProvider(celTypeProvider) + .addMessageTypes(com.google.type.Expr.getDescriptor()) + .addProtoTypeMasks( + ImmutableList.of(ProtoTypeMask.ofAllFields("google.rpc.context.AttributeContext"))) + .addVar("condition", StructTypeReference.create("google.type.Expr")) + .setProtoResultType(CelProtoTypes.BOOL) + .build(); + CelValidationResult result = + cel.compile("type.Expr{expression: \"'hello'\"}.expression == condition.expression"); + assertThat(result.getErrorString()).isEmpty(); + } + + @Test + public void compile_customTypeProvider() { + ProtoMessageTypeProvider celTypeProvider = + new ProtoMessageTypeProvider( + ImmutableList.of( + AttributeContext.getDescriptor(), com.google.type.Expr.getDescriptor())); + Cel cel = + standardCelBuilderWithMacros() + .setContainer(CelContainer.ofName("google")) + .setTypeProvider(celTypeProvider) + .addVar("condition", StructTypeReference.create("google.type.Expr")) + .setResultType(SimpleType.BOOL) + .build(); + CelValidationResult result = + cel.compile("type.Expr{expression: \"'hello'\"}.expression == condition.expression"); + assertThat(result.getErrorString()).isEmpty(); + } + + @Test + public void compile_customTypesWithAliasingCombinedProviders() throws Exception { + + // The custom type provider sets up an alias from "Condition" to "google.type.Expr". + // However, the first type resolution from the alias to the qualified type name won't be + // sufficient as future checks will expect the resolved alias to also be a type. + TypeProvider customTypeProvider = + aliasingProvider( + ImmutableMap.of("Condition", CelProtoTypes.createMessage("google.type.Expr"))); + + // The registration of the aliasing TypeProvider and the google.type.Expr descriptor + // ensures that once the alias is resolved, the additional details about the Expr type + // are discoverable. + // + // The custom type factory is then necessary to ensure that the Condition type listed + // in the AST can be resolved to the appropriate message builder instance. + Cel cel = + standardCelBuilderWithMacros() + .setTypeProvider(customTypeProvider) + .addMessageTypes(com.google.type.Expr.getDescriptor()) + .setTypeFactory( + (typeName) -> + typeName.equals("Condition") ? com.google.type.Expr.newBuilder() : null) + .setResultType(StructTypeReference.create("google.type.Expr")) + .build(); + CelValidationResult result = cel.compile("Condition{expression: \"'hello'\"}"); + assertThat(result.getErrorString()).isEmpty(); + CelRuntime.Program program = cel.createProgram(result.getAst()); + assertThat(program.eval()) + .isEqualTo(com.google.type.Expr.newBuilder().setExpression("'hello'").build()); + } + + @Test + public void compile_customTypesWithAliasingSelfContainedProvider() throws Exception { + + // The custom type provider sets up an alias from "Condition" to "google.type.Expr". + TypeProvider customTypeProvider = + aliasingProvider( + ImmutableMap.of( + "Condition", + CelProtoTypes.createMessage("google.type.Expr"), + "google.type.Expr", + CelProtoTypes.createMessage("google.type.Expr"))); + + // The registration of the aliasing TypeProvider and the google.type.Expr descriptor + // ensures that once the alias is resolved, the additional details about the Expr type + // are discoverable. + // + // The custom type factory is then necessary to ensure that the Condition type listed + // in the AST can be resolved to the appropriate message builder instance. + Cel cel = + standardCelBuilderWithMacros() + .setTypeProvider(customTypeProvider) + .setTypeFactory( + (typeName) -> + typeName.equals("Condition") ? com.google.type.Expr.newBuilder() : null) + .setResultType(StructTypeReference.create("google.type.Expr")) + .build(); + CelValidationResult result = cel.compile("Condition{expression: \"'hello'\"}"); + assertThat(result.getErrorString()).isEmpty(); + CelRuntime.Program program = cel.createProgram(result.getAst()); + assertThat(program.eval()) + .isEqualTo(com.google.type.Expr.newBuilder().setExpression("'hello'").build()); + } + + @Test + public void program_setTypeFactoryOnAnyPackedMessage_fieldSelectionSuccess() throws Exception { + // Arrange + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("input", StructTypeReference.create("google.type.Expr")) + .addMessageTypes(com.google.type.Expr.getDescriptor()) + .setResultType(SimpleType.STRING) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("input.expression").getAst(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + // CEL-Internal-2 + .setTypeFactory( + (typeName) -> + typeName.equals("google.type.Expr") ? com.google.type.Expr.newBuilder() : null) + .build(); + CelRuntime.Program program = celRuntime.createProgram(ast); + Message exprMessage = com.google.type.Expr.newBuilder().setExpression("test").build(); + + // Act + Object evaluatedResult1 = program.eval(ImmutableMap.of("input", exprMessage)); + Object evaluatedResult2 = program.eval(ImmutableMap.of("input", Any.pack(exprMessage))); + + // Assert + assertThat(evaluatedResult1).isEqualTo("test"); + assertThat(evaluatedResult2).isEqualTo("test"); + } + + @Test + public void program_setTypeFactoryOnAnyPackedMessage_messageConstructionSucceeds() + throws Exception { + // Arrange + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("input", StructTypeReference.create("google.type.Expr")) + .addMessageTypes(com.google.type.Expr.getDescriptor()) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("input").getAst(); + + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + // CEL-Internal-2 + .setTypeFactory( + (typeName) -> + typeName.equals("google.type.Expr") ? com.google.type.Expr.newBuilder() : null) + .build(); + CelRuntime.Program program = celRuntime.createProgram(ast); + Message exprMessage = com.google.type.Expr.newBuilder().setExpression("test").build(); + + // Act + Object evaluatedResult1 = program.eval(ImmutableMap.of("input", exprMessage)); + Object evaluatedResult2 = program.eval(ImmutableMap.of("input", Any.pack(exprMessage))); + + // Assert + assertThat(evaluatedResult1).isEqualTo(exprMessage); + assertThat(evaluatedResult2).isEqualTo(exprMessage); + } + + @Test + @SuppressWarnings("unused") // testRunIndex name retained for test result readability + public void program_concurrentMessageConstruction_succeeds( + @TestParameter(valuesProvider = RepeatedTestProvider.class) int testRunIndex) + throws Exception { + // Arrange + int threadCount = 10; + Cel cel = + standardCelBuilderWithMacros() + .setContainer(CelContainer.ofName("google.rpc.context.AttributeContext")) + .addFileTypes( + Any.getDescriptor().getFile(), + Duration.getDescriptor().getFile(), + Struct.getDescriptor().getFile(), + Timestamp.getDescriptor().getFile(), + AttributeContext.getDescriptor().getFile()) + .setResultType( + StructTypeReference.create("google.rpc.context.AttributeContext.Resource")) + .build(); + CelRuntime.Program program = + cel.createProgram(cel.compile("Resource{name: \"'hello'\"}").getAst()); + ExecutorService executor = + MoreExecutors.getExitingExecutorService( + (ThreadPoolExecutor) Executors.newFixedThreadPool(threadCount)); + + // Act + List> futures = new ArrayList<>(); + for (int i = 0; i < threadCount; i++) { + futures.add(executor.submit(() -> (AttributeContext.Resource) program.eval())); + } + + // Assert + AttributeContext.Resource expectedResult = + AttributeContext.Resource.newBuilder().setName("'hello'").build(); + for (Future future : futures) { + assertThat(future.get()).isEqualTo(expectedResult); + } + } + + @Test + public void compile_syntaxFailure() throws Exception { + Cel cel = standardCelBuilderWithMacros().build(); + CelValidationResult result = cel.compile("|| false"); + assertThat(result.hasError()).isTrue(); + assertThat(result.getErrors()) + .containsExactly( + CelIssue.formatError( + 1, + 0, + "extraneous input '||' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false'," + + " 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER}")); + assertThat(result.getErrorString()) + .isEqualTo( + "ERROR: :1:1: extraneous input '||' expecting {'[', '{', '(', '.', '-', '!'," + + " 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES," + + " IDENTIFIER}\n" + + " | || false\n" + + " | ^"); + } + + @Test + public void compile_typeCheckFailure() { + Cel cel = standardCelBuilderWithMacros().build(); + CelValidationResult syntaxErrorResult = cel.compile("variable"); + assertThat(syntaxErrorResult.hasError()).isTrue(); + assertThat(syntaxErrorResult.getErrors()) + .containsExactly( + CelIssue.formatError( + /* exprId= */ 1L, + CelSourceLocation.of(1, 0), + "undeclared reference to 'variable' (in container '')")); + assertThat(syntaxErrorResult.getErrorString()) + .isEqualTo( + "ERROR: :1:1: undeclared reference to 'variable' (in container '')\n" + + " | variable\n" + + " | ^"); + } + + @Test + public void compile_withOptionalTypes() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableOptionalSyntax(true).build()) + .addVar("a", OptionalType.create(SimpleType.STRING)) + .build(); + + CelAbstractSyntaxTree ast = cel.compile("[?a]").getAst(); + + CelList list = ast.getExpr().list(); + assertThat(list.optionalIndices()).containsExactly(0); + assertThat(list.elements()).containsExactly(CelExpr.ofIdent(2, "a")); + } + + @Test + public void compile_overlappingVarsFailure() { + Cel cel = + standardCelBuilderWithMacros() + .addDeclarations( + Decl.newBuilder() + .setName("variable") + .setIdent(IdentDecl.newBuilder().setType(CelProtoTypes.STRING)) + .build()) + .addDeclarations( + Decl.newBuilder() + .setName("variable") + .setIdent( + IdentDecl.newBuilder() + .setType(CelProtoTypes.createList(CelProtoTypes.STRING))) + .build()) + .setResultType(SimpleType.BOOL) + .build(); + CelValidationException e = + Assert.assertThrows( + CelValidationException.class, () -> cel.compile("variable == 'hello'").getAst()); + assertThat(e).hasMessageThat().contains("variable"); + } + + @Test + public void program() throws Exception { + Cel cel = standardCelBuilderWithMacros().setResultType(SimpleType.BOOL).build(); + CelRuntime.Program program = cel.createProgram(cel.compile("true && !false").getAst()); + assertThat(program.eval()).isEqualTo(true); + } + + @Test + public void program_withVars() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addDeclarations( + Decl.newBuilder() + .setName("variable") + .setIdent(IdentDecl.newBuilder().setType(CelProtoTypes.STRING)) + .build()) + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("variable == 'hello'").getAst()); + assertThat(program.eval(ImmutableMap.of("variable", "hello"))).isEqualTo(true); + } + + @Test + public void program_withCelValue() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableCelValue(true).build()) + .addDeclarations( + Decl.newBuilder() + .setName("variable") + .setIdent(IdentDecl.newBuilder().setType(CelProtoTypes.STRING)) + .build()) + .setResultType(SimpleType.BOOL) + .build(); + + CelRuntime.Program program = cel.createProgram(cel.compile("variable == 'hello'").getAst()); + + assertThat(program.eval(ImmutableMap.of("variable", "hello"))).isEqualTo(true); + } + + @Test + public void program_withProtoVars() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addMessageTypes(AttributeContext.getDescriptor()) + .addProtoTypeMasks( + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder().addPaths("resource.*").build()) + .withFieldsAsVariableDeclarations()) + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = + cel.createProgram( + cel.compile("resource.name == 'secure' && resource.type == 'compute.vm'").getAst()); + assertThat( + program.eval( + AttributeContext.newBuilder() + .setResource( + AttributeContext.Resource.newBuilder() + .setName("secure") + .setType("compute.vm")) + .build())) + .isEqualTo(true); + } + + @Test + public void program_withAllFieldsHidden_emptyMessageConstructionSuccess() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addMessageTypes(AttributeContext.getDescriptor()) + .setContainer(CelContainer.ofName("google.rpc.context.AttributeContext")) + .addProtoTypeMasks( + ProtoTypeMask.ofAllFieldsHidden("google.rpc.context.AttributeContext")) + .build(); + + assertThat(cel.createProgram(cel.compile("AttributeContext{}").getAst()).eval()) + .isEqualTo(AttributeContext.getDefaultInstance()); + } + + @Test + public void compile_withAllFieldsHidden_selectHiddenField_throws() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addMessageTypes(AttributeContext.getDescriptor()) + .setContainer(CelContainer.ofName("google.rpc.context.AttributeContext")) + .addProtoTypeMasks( + ProtoTypeMask.ofAllFieldsHidden("google.rpc.context.AttributeContext")) + .build(); + + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> cel.compile("AttributeContext{ request: AttributeContext.Request{} }").getAst()); + assertThat(e).hasMessageThat().contains("undefined field 'request'"); + } + + @Test + public void compile_withAllFieldsHidden_selectHiddenFieldOnVar_throws() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addMessageTypes(AttributeContext.getDescriptor()) + .setContainer(CelContainer.ofName("google.rpc.context.AttributeContext")) + .addProtoTypeMasks( + ProtoTypeMask.ofAllFieldsHidden("google.rpc.context.AttributeContext")) + .addVar("attr_ctx", StructTypeReference.create("google.rpc.context.AttributeContext")) + .build(); + + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile("attr_ctx.source").getAst()); + assertThat(e).hasMessageThat().contains("undefined field 'source'"); + } + + @Test + public void program_withNestedRestrictedProtoVars() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addMessageTypes(AttributeContext.getDescriptor()) + .addProtoTypeMasks( + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder().addPaths("resource.type").build()) + .withFieldsAsVariableDeclarations()) + .setResultType(SimpleType.BOOL) + .build(); + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> cel.compile("{1:resource}[1].name == 'secure'").getAst()); + assertThat(e).hasMessageThat().contains("undefined field 'name'"); + } + + @Test + public void program_withFunctions() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addDeclarations( + ImmutableList.of( + Decl.newBuilder() + .setName("one") + .setIdent(IdentDecl.newBuilder().setType(CelProtoTypes.BOOL)) + .build(), + Decl.newBuilder() + .setName("two") + .setIdent(IdentDecl.newBuilder().setType(CelProtoTypes.BOOL)) + .build(), + Decl.newBuilder() + .setName("any") + .setFunction( + FunctionDecl.newBuilder() + .addOverloads( + Overload.newBuilder() + .setOverloadId("any_bool") + .addParams(CelProtoTypes.BOOL) + .setResultType(CelProtoTypes.BOOL)) + .addOverloads( + Overload.newBuilder() + .setOverloadId("any_bool_bool") + .addParams(CelProtoTypes.BOOL) + .addParams(CelProtoTypes.BOOL) + .setResultType(CelProtoTypes.BOOL)) + .addOverloads( + Overload.newBuilder() + .setOverloadId("any_bool_bool_bool") + .addParams(CelProtoTypes.BOOL) + .addParams(CelProtoTypes.BOOL) + .addParams(CelProtoTypes.BOOL) + .setResultType(CelProtoTypes.BOOL))) + .build())) + .addFunctionBindings(CelFunctionBinding.from("any_bool", Boolean.class, (arg) -> arg)) + .addFunctionBindings( + ImmutableList.of( + CelFunctionBinding.from( + "any_bool_bool", + Boolean.class, + Boolean.class, + (arg1, arg2) -> (boolean) arg1 || (boolean) arg2), + CelFunctionBinding.from( + "any_bool_bool_bool", + ImmutableList.of(Boolean.class, Boolean.class, Boolean.class), + (args) -> (boolean) args[0] || (boolean) args[1] || (boolean) args[2]))) + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = + cel.createProgram( + cel.compile("any(true) && any(false, one) && any(false, two, false)").getAst()); + assertThat(program.eval(ImmutableMap.of("one", true, "two", true))).isEqualTo(true); + } + + @Test + public void program_withThrowingFunction() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addDeclarations( + Decl.newBuilder() + .setName("throws") + .setFunction( + FunctionDecl.newBuilder() + .addOverloads( + Overload.newBuilder() + .setOverloadId("throws") + .setResultType(CelProtoTypes.BOOL))) + .build()) + .addFunctionBindings( + CelFunctionBinding.from( + "throws", + ImmutableList.of(), + (unused) -> { + throw new CelEvaluationException("this method always throws"); + })) + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("throws()").getAst()); + CelEvaluationException e = Assert.assertThrows(CelEvaluationException.class, program::eval); + assertThat(e).hasMessageThat().contains("this method always throws"); + } + + @Test + public void program_withThrowingFunctionShortcircuited() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addDeclarations( + Decl.newBuilder() + .setName("throws") + .setFunction( + FunctionDecl.newBuilder() + .addOverloads( + Overload.newBuilder() + .setOverloadId("throws") + .setResultType(CelProtoTypes.BOOL))) + .build()) + .addFunctionBindings( + CelFunctionBinding.from( + "throws", + ImmutableList.of(), + (unused) -> { + throw CelEvaluationExceptionBuilder.newBuilder("this method always throws") + .setCause(new RuntimeException("reason")) + .build(); + })) + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("throws() || true").getAst()); + assertThat(program.eval()).isEqualTo(true); + } + + @Test + public void program_simpleStructTypeReference() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("test", StructTypeReference.create(Expr.getDescriptor().getFullName())) + .addMessageTypes(Expr.getDescriptor()) + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + CelRuntime.Program program = + celRuntime.createProgram(celCompiler.compile("test.id == 2").getAst()); + + Object evaluatedResult = + program.eval(ImmutableMap.of("test", Expr.newBuilder().setId(2).build())); + + assertThat(evaluatedResult).isEqualTo(true); + } + + @Test + public void program_messageConstruction() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setContainer(CelContainer.ofName("google.type")) + .addMessageTypes(com.google.type.Expr.getDescriptor()) + .setResultType(StructTypeReference.create("google.type.Expr")) + .setStandardEnvironmentEnabled(false) + .build(); + CelRuntime.Program program = + cel.createProgram(cel.compile("type.Expr{expression: \"'hello'\"}").getAst()); + assertThat(program.eval()) + .isEqualTo(com.google.type.Expr.newBuilder().setExpression("'hello'").build()); + } + + @Test + public void program_duplicateTypeDescriptor() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addMessageTypes(Timestamp.getDescriptor()) + .addMessageTypes(ImmutableList.of(Timestamp.getDescriptor())) + .setContainer(CelContainer.ofName("google")) + .setResultType(SimpleType.TIMESTAMP) + .build(); + CelRuntime.Program program = + cel.createProgram(cel.compile("protobuf.Timestamp{seconds: 12}").getAst()); + + assertThat(program.eval()).isEqualTo(Instant.ofEpochSecond(12)); + } + + @Test + public void program_hermeticDescriptors_wellKnownProtobuf() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + // CEL-Internal-2 + .addMessageTypes(Timestamp.getDescriptor()) + .setContainer(CelContainer.ofName("google")) + .setResultType(SimpleType.TIMESTAMP) + .build(); + CelRuntime.Program program = + cel.createProgram(cel.compile("protobuf.Timestamp{seconds: 12}").getAst()); + assertThat(program.eval()).isEqualTo(Instant.ofEpochSecond(12)); + } + + @Test + public void program_partialMessageTypes() throws Exception { + String packageName = CheckedExpr.getDescriptor().getFile().getPackage(); + Cel cel = + standardCelBuilderWithMacros() + .addFileTypes(CheckedExpr.getDescriptor().getFile()) + // Disabling the resolution of type dependencies can be risky as message types which + // are expected to be available in an imported file may not be present if the type + // is not referenced in a field within the provided file descriptors. + // + // In this test 'Expr' is defined in syntax.proto, but the descriptor provided is + // defined in checked.proto. Because the `Expr` type is referenced within a message + // field of the CheckedExpr, it is available for use. + .setOptions(CelOptions.current().resolveTypeDependencies(false).build()) + .setContainer(CelContainer.ofName(packageName)) + .setResultType(StructTypeReference.create(packageName + ".Expr")) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("Expr{}").getAst()); + assertThat(program.eval()).isEqualTo(Expr.getDefaultInstance()); + } + + @Test + public void program_partialMessageTypeFailure() { + String packageName = CheckedExpr.getDescriptor().getFile().getPackage(); + Cel cel = + standardCelBuilderWithMacros() + .addFileTypes(CheckedExpr.getDescriptor().getFile()) + // In this test 'ParsedExpr' is defined in syntax.proto, but the descriptor provided is + // defined in checked.proto. Because the `ParsedExpr` type is not referenced, it is not + // available for use within CEL when deep type resolution is disabled. + .setOptions(CelOptions.current().resolveTypeDependencies(false).build()) + .setContainer(CelContainer.ofName(packageName)) + .setResultType(StructTypeReference.create(packageName + ".ParsedExpr")) + .build(); + CelValidationException e = + Assert.assertThrows( + CelValidationException.class, () -> cel.compile("ParsedExpr{}").getAst()); + assertThat(e).hasMessageThat().contains("undeclared reference to 'ParsedExpr'"); + } + + @Test + public void program_deepTypeResolution() throws Exception { + String packageName = CheckedExpr.getDescriptor().getFile().getPackage(); + Cel cel = + standardCelBuilderWithMacros() + .addFileTypes(CheckedExpr.getDescriptor().getFile()) + // In this test 'ParsedExpr' is defined in syntax.proto, but the descriptor provided is + // defined in checked.proto. Because deep type dependency resolution is enabled, the + // `ParsedExpr` may be used within CEL. + .setOptions(CelOptions.current().resolveTypeDependencies(true).build()) + .setContainer(CelContainer.ofName(packageName)) + .setResultType(StructTypeReference.create(packageName + ".ParsedExpr")) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("ParsedExpr{}").getAst()); + assertThat(program.eval()).isEqualTo(ParsedExpr.getDefaultInstance()); + } + + @Test + public void program_deepTypeResolutionEnabledForRuntime_success() throws Exception { + String packageName = CheckedExpr.getDescriptor().getFile().getPackage(); + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFileTypes(ParsedExpr.getDescriptor().getFile()) + .setResultType(StructTypeReference.create(packageName + ".ParsedExpr")) + .setContainer(CelContainer.ofName(packageName)) + .build(); + + CelAbstractSyntaxTree ast = celCompiler.compile("ParsedExpr{}").getAst(); + + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addFileTypes(CheckedExpr.getDescriptor().getFile()) + .setOptions(CelOptions.current().resolveTypeDependencies(true).build()) + // CEL-Internal-2 + .build(); + CelRuntime.Program program = celRuntime.createProgram(ast); + + // 'ParsedExpr' is defined in syntax.proto but the descriptor provided to the runtime is from + // 'checked.proto'. + // 'ParsedExpr' is transitively available for use because deep type resolution is enabled. + assertThat(program.eval()).isEqualTo(ParsedExpr.getDefaultInstance()); + } + + @Test + public void program_deepTypeResolutionDisabledForRuntime_fails() throws Exception { + String packageName = CheckedExpr.getDescriptor().getFile().getPackage(); + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFileTypes(CheckedExpr.getDescriptor().getFile()) + .setOptions(CelOptions.current().resolveTypeDependencies(true).build()) + .setResultType(StructTypeReference.create(packageName + ".ParsedExpr")) + .setContainer(CelContainer.ofName(packageName)) + .build(); + + // 'ParsedExpr' is defined in syntax.proto but the descriptor provided is from 'checked.proto'. + // 'ParsedExpr' is transitively available for use because deep type resolution is enabled. + CelAbstractSyntaxTree ast = celCompiler.compile("ParsedExpr{}").getAst(); + + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addFileTypes(CheckedExpr.getDescriptor().getFile()) + .setOptions(CelOptions.current().resolveTypeDependencies(false).build()) + // CEL-Internal-2 + .build(); + CelRuntime.Program program = celRuntime.createProgram(ast); + + // In this case, linked types are disabled so the same descriptors + // provided to the CelCompiler must also be provided into the runtime. + // As deep type resolution is disabled, 'ParsedExpr' is not available for use in runtime so an + // error is thrown. + CelEvaluationException e = Assert.assertThrows(CelEvaluationException.class, program::eval); + assertThat(e) + .hasMessageThat() + .contains(String.format("cannot resolve '%s.ParsedExpr' as a message", packageName)); + } + + @Test + @SuppressWarnings("deprecation") // Test for existing deprecated method setTypeProvider + public void program_typeProvider() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setTypeProvider( + new DescriptorTypeProvider(ImmutableList.of(Timestamp.getDescriptor()))) + .setContainer(CelContainer.ofName("google")) + .setResultType(SimpleType.TIMESTAMP) + .build(); + CelRuntime.Program program = + cel.createProgram(cel.compile("protobuf.Timestamp{seconds: 12}").getAst()); + assertThat(program.eval()).isEqualTo(Instant.ofEpochSecond(12)); + } + + @Test + public void program_protoActivation() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addMessageTypes(AttributeContext.getDescriptor()) + .addDeclarations( + Decl.newBuilder() + .setName("resource") + .setIdent( + IdentDecl.newBuilder() + .setType( + CelProtoTypes.createMessage( + "google.rpc.context.AttributeContext.Resource"))) + .build()) + .setResultType(SimpleType.STRING) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("resource.name").getAst()); + assertThat( + program.eval( + AttributeContext.newBuilder() + .setResource(AttributeContext.Resource.newBuilder().setName("test/name")) + .build())) + .isEqualTo("test/name"); + } + + @Test + @TestParameters("{resolveTypeDependencies: false}") + @TestParameters("{resolveTypeDependencies: true}") + public void program_enumTypeDirectResolution(boolean resolveTypeDependencies) throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addFileTypes(StandaloneGlobalEnum.getDescriptor().getFile()) + .setOptions( + CelOptions.current().resolveTypeDependencies(resolveTypeDependencies).build()) + .setContainer( + CelContainer.ofName("dev.cel.testing.testdata.proto3.StandaloneGlobalEnum")) + .setResultType(SimpleType.BOOL) + .build(); + + // Providing an enum proto file directly should not cause an error + // regardless of the resolveTypeDependencies settings + StandaloneGlobalEnum testEnum = StandaloneGlobalEnum.SGAR; + CelRuntime.Program program = + cel.createProgram( + cel.compile(String.format("%s == %d", testEnum, testEnum.getNumber())).getAst()); + assertThat(program.eval()).isEqualTo(true); + } + + @Test + @TestParameters("{resolveTypeDependencies: false}") + @TestParameters("{resolveTypeDependencies: true}") + public void program_enumTypeReferenceResolution(boolean resolveTypeDependencies) + throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions( + CelOptions.current().resolveTypeDependencies(resolveTypeDependencies).build()) + .addMessageTypes(Struct.getDescriptor()) + .setResultType(StructTypeReference.create("google.protobuf.NullValue")) + .setContainer(CelContainer.ofName("google.protobuf")) + .build(); + + // `Value` is defined in `Struct` proto and NullValue is an enum within this `Value` struct. + // The following evaluation should work regardless of resolveTypeDependencies settings + // as the enum definition is found in the same `Struct` proto definition. + CelRuntime.Program program = + cel.createProgram(cel.compile("Value{null_value: NullValue.NULL_VALUE}").getAst()); + assertThat(program.eval()).isEqualTo(NullValue.NULL_VALUE); + } + + @Test + public void program_enumTypeTransitiveResolution() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().resolveTypeDependencies(true).build()) + .addMessageTypes(Proto2ExtensionScopedMessage.getDescriptor()) + .setResultType(StructTypeReference.create("google.protobuf.NullValue")) + .setContainer(CelContainer.ofName("google.protobuf")) + .build(); + + // 'Value' is a struct defined as a dependency of messages_proto2.proto and 'NullValue' is an + // enum within this 'Value' struct. + // As deep type dependency is enabled, the following evaluation should work by as the + // 'NullValue' enum type is transitively discovered + CelRuntime.Program program = + cel.createProgram(cel.compile("Value{null_value: NullValue.NULL_VALUE}").getAst()); + assertThat(program.eval()).isEqualTo(NullValue.NULL_VALUE); + } + + @Test + public void compile_enumTypeIsEquivalentToInt() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addFileTypes(StandaloneGlobalEnum.getDescriptor().getFile()) + .addVar("enumVar", EnumType.create("enum", ImmutableMap.of("FOO", 0, "BAR", 1))) + .setResultType(SimpleType.BOOL) + .build(); + + CelAbstractSyntaxTree ast = cel.compile("enumVar == 1").getAst(); + + assertThat(ast).isNotNull(); + } + + @Test + public void compile_enumTypeTransitiveResolutionFailure() { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().resolveTypeDependencies(false).build()) + .addMessageTypes(Proto2ExtensionScopedMessage.getDescriptor()) + .setResultType(StructTypeReference.create("google.protobuf.NullValue")) + .setContainer(CelContainer.ofName("google.protobuf")) + .build(); + + // 'Value' is a struct defined as a dependency of messages_proto2.proto and 'NullValue' is an + // enum within this 'Value' struct. + // As deep type dependency is disabled, the following evaluation will fail as CEL will not be + // aware of the dependent enum type + CelValidationException e = + Assert.assertThrows( + CelValidationException.class, + () -> cel.compile("Value{null_value: NullValue.NULL_VALUE}").getAst()); + assertThat(e).hasMessageThat().contains("undeclared reference to 'NullValue'"); + } + + @Test + public void compile_multipleInstancesOfEnumDescriptor_dedupedByFullName() throws Exception { + String enumTextProto = + "name: \"standalone_global_enum.proto\"\n" + + "package: \"dev.cel.testing.testdata.proto3\"\n" + + "enum_type {\n" + + " name: \"StandaloneGlobalEnum\"\n" + + " value {\n" + + " name: \"SGOO\"\n" + + " number: 0\n" + + " }\n" + + "}\n" + + "syntax: \"proto3\"\n"; + FileDescriptorProto enumFileDescriptorProto = + TextFormat.parse(enumTextProto, FileDescriptorProto.class); + FileDescriptor enumFileDescriptor = + FileDescriptor.buildFrom(enumFileDescriptorProto, new FileDescriptor[] {}); + Cel cel = + standardCelBuilderWithMacros() + .setContainer(CelContainer.ofName("dev.cel.testing.testdata")) + .addFileTypes(enumFileDescriptor) + .addFileTypes(StandaloneGlobalEnum.getDescriptor().getFile()) + .build(); + + assertThat(cel.compile("dev.cel.testing.testdata.proto3.StandaloneGlobalEnum.SGOO").getAst()) + .isNotNull(); + } + + @Test + public void program_customVarResolver() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addDeclarations( + Decl.newBuilder() + .setName("variable") + .setIdent(IdentDecl.newBuilder().setType(CelProtoTypes.STRING)) + .build()) + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("variable == 'hello'").getAst()); + assertThat( + program.eval( + (name) -> name.equals("variable") ? Optional.of("hello") : Optional.empty())) + .isEqualTo(true); + assertThat(program.eval((unused) -> Optional.of(""))).isEqualTo(false); + } + + @Test + public void program_wrongTypeComprehensionThrows() throws Exception { + Cel cel = standardCelBuilderWithMacros().setResultType(SimpleType.BOOL).build(); + CelRuntime.Program program = + cel.createProgram(cel.compile("dyn(42).exists(x, x != 'foo')").getAst()); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + + assertThat(e).hasMessageThat().contains("expected a list or a map"); + } + + @Test + public void program_stringFormatInjection_throwsEvaluationException() throws Exception { + Cel cel = standardCelBuilderWithMacros().build(); + CelRuntime.Program program = cel.createProgram(cel.compile("{}['%2000222222s']").getAst()); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e).hasMessageThat().contains("evaluation error"); + } + + @Test + public void program_emptyTypeProviderConfig() throws Exception { + Cel cel = standardCelBuilderWithMacros().build(); + assertThat(cel.createProgram(cel.compile("true && !false").getAst()).eval()).isEqualTo(true); + } + + @Test + public void program_messageTypeAddedAsVarWithoutDescriptor_throwsHumanReadableError() { + String packageName = CheckedExpr.getDescriptor().getFile().getPackage(); + Cel cel = + standardCelBuilderWithMacros() + .addVar("parsedExprVar", CelProtoMessageTypes.createMessage(ParsedExpr.getDescriptor())) + .build(); + CelValidationException exception = + assertThrows( + CelValidationException.class, + () -> cel.createProgram(cel.compile("parsedExprVar.source_info").getAst())); + assertThat(exception) + .hasMessageThat() + .contains( + String.format( + "Message type resolution failure while referencing field 'source_info'. Ensure that" + + " the descriptor for type '%s.ParsedExpr' was added to the environment", + packageName)); + } + + @Test + public void setOptions() throws Exception { + Cel cel = standardCelBuilderWithMacros().build(); + CelValidationResult result = cel.parse("!!!true"); + assertThat(result.hasError()).isFalse(); + assertThat(CelProtoAbstractSyntaxTree.fromCelAst(result.getAst()).toParsedExpr().getExpr()) + .ignoringFieldDescriptors(Expr.getDescriptor().findFieldByName("id")) + .isEqualTo(NOT_EXPR); + + cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.newBuilder().retainRepeatedUnaryOperators(true).build()) + .build(); + result = cel.parse("!!!true"); + assertThat(result.hasError()).isFalse(); + assertThat(CelProtoAbstractSyntaxTree.fromCelAst(result.getAst()).toParsedExpr().getExpr()) + .ignoringFieldDescriptors(Expr.getDescriptor().findFieldByName("id")) + .isEqualTo(NOT_NOT_NOT_EXPR); + } + + @Test + public void setStandardMacros() throws Exception { + Cel cel = standardCelBuilderWithMacros().setStandardMacros(CelStandardMacro.HAS).build(); + assertValidationResult(cel.parse("has(a.b)"), PARSED_HAS_EXPR); + } + + private void assertValidationResult(CelValidationResult result, ParsedExpr parsedExpr) + throws Exception { + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(CelProtoAbstractSyntaxTree.fromCelAst(result.getAst()).toParsedExpr()) + .ignoringFieldDescriptors( + Expr.getDescriptor().findFieldByName("id"), + ParsedExpr.getDescriptor().findFieldByName("source_info")) + .reportingMismatchesOnly() + .isEqualTo(parsedExpr); + } + + private void assertValidationResult(CelValidationResult result, CheckedExpr checkedExpr) + throws Exception { + assertThat(result.hasError()).isFalse(); + assertThat(CelProtoAbstractSyntaxTree.fromCelAst(result.getAst()).toCheckedExpr()) + .ignoringFieldDescriptors( + Expr.getDescriptor().findFieldByName("id"), + CheckedExpr.getDescriptor().findFieldByName("source_info")) + .reportingMismatchesOnly() + .isEqualTo(checkedExpr); + } + + private CelVariableResolver fromMap(ImmutableMap m) { + return (String s) -> Optional.ofNullable(m.get(s)); + } + + @Test + public void programAdvanceEvaluation_unknownsBasic() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("a", SimpleType.BOOL) + .addVar("b", SimpleType.BOOL) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("a || b").getAst()); + assertThat( + program.eval( + ImmutableMap.of( + "a", true, + "b", false))) + .isEqualTo(true); + + ImmutableMap partial = ImmutableMap.of("b", false); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(partial), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("a"))))) + .isEqualTo(CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("a"))); + } + + @Test + public void programAdvanceEvaluation_attributesIgnoredIfDisabled() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(false).build()) + .addVar("a", SimpleType.BOOL) + .addVar("b", SimpleType.BOOL) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("a || b").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap( + ImmutableMap.of( + "a", true, + "b", false)), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("a"))))) + .isEqualTo(true); + } + + @Test + public void programAdvanceEvaluation_logicOperatorTypeMismatchThrows() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("a", SimpleType.BOOL) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("a || dyn(42)").getAst()); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("a"))))); + assertThat(e).hasMessageThat().contains("expected boolean"); + } + + @Test + public void programAdvanceEvaluation_unknownsCollection() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("a", SimpleType.BOOL) + .addVar("b", SimpleType.BOOL) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("a || b").getAst()); + assertThat( + program.eval( + ImmutableMap.of( + "a", true, + "b", false))) + .isEqualTo(true); + + ImmutableMap partial = ImmutableMap.of("b", false); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(partial), + ImmutableList.of( + CelAttributePattern.create("a"), CelAttributePattern.create("b"))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of(CelAttribute.create("a"), CelAttribute.create("b")))); + } + + @Test + public void programAdvanceEvaluation_unknownsNamespaceSupport() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("com.google.a", SimpleType.BOOL) + .addVar("com.google.b", SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("a || b").getAst()); + assertThat( + program.eval( + ImmutableMap.of( + "com.google.a", true, + "com.google.b", false))) + .isEqualTo(true); + + ImmutableMap partial = ImmutableMap.of("com.google.b", false); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(partial), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("com.google.a"))))) + .isEqualTo(CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("com.google.a"))); + } + + @Test + public void programAdvanceEvaluation_unknownsIterativeEvalExample() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("com.google.a", SimpleType.BOOL) + .addVar("com.google.b", SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("a || b").getAst()); + UnknownContext context = + UnknownContext.create( + fromMap(ImmutableMap.of("com.google.b", false)), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("com.google.a"))); + + assertThat(program.advanceEvaluation(context)) + .isEqualTo(CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("com.google.a"))); + + assertThat( + program.advanceEvaluation( + context.withResolvedAttributes( + ImmutableMap.of(CelAttribute.fromQualifiedIdentifier("com.google.a"), true)))) + .isEqualTo(true); + } + + @Test + public void programAdvanceEvaluation_nestedSelect() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("com", MapType.create(SimpleType.STRING, SimpleType.DYN)) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("com.google.a || false").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("com.google.a"))))) + .isEqualTo(CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("com.google.a"))); + } + + @Test + public void programAdvanceEvaluation_nestedSelect_withCelValue() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions( + CelOptions.current().enableUnknownTracking(true).enableCelValue(true).build()) + .addVar("com", MapType.create(SimpleType.STRING, SimpleType.DYN)) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("com.google.a || false").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("com.google.a"))))) + .isEqualTo(CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("com.google.a"))); + } + + @Test + public void programAdvanceEvaluation_argumentMergeErrorPriority() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("unk", SimpleType.BOOL) + .addDeclarations( + Decl.newBuilder() + .setName("acceptThreeBoolArgs") + .setFunction( + FunctionDecl.newBuilder() + .addOverloads( + Overload.newBuilder() + .setOverloadId("acceptThreeBoolArgs") + .addParams(Type.newBuilder().setPrimitive(PrimitiveType.BOOL)) + .addParams(Type.newBuilder().setPrimitive(PrimitiveType.BOOL)) + .addParams(Type.newBuilder().setPrimitive(PrimitiveType.BOOL)) + .setResultType( + Type.newBuilder().setPrimitive(PrimitiveType.BOOL)))) + .build()) + .setContainer(CelContainer.ofName("")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + + // The type signature at check time is acceptThreeBoolArgs(bool, bool, bool) + // at runtime, it's acceptThreeBoolArgs(bool, unknown, error). + // For a strict function, an error argument should propagate instead of dispatching to the + // implementation. + CelRuntime.Program program = + cel.createProgram(cel.compile("acceptThreeBoolArgs(false, unk, [false][1])").getAst()); + + Assert.assertThrows( + CelEvaluationException.class, + () -> + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("unk"))))); + } + + @Test + public void programAdvanceEvaluation_argumentMergeUnknowns() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("unk.a", SimpleType.BOOL) + .addVar("unk.b", SimpleType.BOOL) + .addVar("unk.c", SimpleType.BOOL) + .addDeclarations( + Decl.newBuilder() + .setName("acceptThreeBoolArgs") + .setFunction( + FunctionDecl.newBuilder() + .addOverloads( + Overload.newBuilder() + .setOverloadId("acceptThreeBoolArgs") + .addParams(Type.newBuilder().setPrimitive(PrimitiveType.BOOL)) + .addParams(Type.newBuilder().setPrimitive(PrimitiveType.BOOL)) + .addParams(Type.newBuilder().setPrimitive(PrimitiveType.BOOL)) + .setResultType( + Type.newBuilder().setPrimitive(PrimitiveType.BOOL)))) + .build()) + .setContainer(CelContainer.ofName("")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = + cel.createProgram(cel.compile("acceptThreeBoolArgs(unk.a, unk.b, unk.c)").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of( + CelAttributePattern.create("unk").qualify(Qualifier.ofWildCard()))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.fromQualifiedIdentifier("unk.a"), + CelAttribute.fromQualifiedIdentifier("unk.c"), + CelAttribute.fromQualifiedIdentifier("unk.b")))); + } + + @Test + public void programAdvanceEvaluation_mapSelectUnknowns() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("unk", MapType.create(SimpleType.STRING, SimpleType.BOOL)) + .setContainer(CelContainer.ofName("")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("unk.a || unk.b || unk.c").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of( + CelAttributePattern.create("unk").qualify(Qualifier.ofWildCard()))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.fromQualifiedIdentifier("unk.a"), + CelAttribute.fromQualifiedIdentifier("unk.c"), + CelAttribute.fromQualifiedIdentifier("unk.b")))); + } + + @Test + public void programAdvanceEvaluation_mapIndexUnknowns() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("unk", MapType.create(SimpleType.STRING, SimpleType.BOOL)) + .setContainer(CelContainer.ofName("")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + + CelRuntime.Program program = + cel.createProgram(cel.compile("unk['a'] || unk['b'] || unk['c']").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of( + CelAttributePattern.fromQualifiedIdentifier("unk") + .qualify(Qualifier.ofWildCard()))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.fromQualifiedIdentifier("unk.a"), + CelAttribute.fromQualifiedIdentifier("unk.c"), + CelAttribute.fromQualifiedIdentifier("unk.b")))); + } + + @Test + public void programAdvanceEvaluation_listIndexUnknowns() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("unk", ListType.create(SimpleType.BOOL)) + .setContainer(CelContainer.ofName("")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + + CelRuntime.Program program = + cel.createProgram(cel.compile("unk[0] || unk[1] || unk[2]").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of( + CelAttributePattern.fromQualifiedIdentifier("unk") + .qualify(Qualifier.ofWildCard()))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("unk").qualify(Qualifier.ofInt(0)), + CelAttribute.create("unk").qualify(Qualifier.ofInt(1)), + CelAttribute.create("unk").qualify(Qualifier.ofInt(2))))); + } + + @Test + public void programAdvanceEvaluation_indexOnUnknownContainer() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("unk", ListType.create(SimpleType.BOOL)) + .setContainer(CelContainer.ofName("")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + + CelRuntime.Program program = + cel.createProgram(cel.compile("unk[0] || unk[1] || unk[2]").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("unk"))))) + .isEqualTo(CelUnknownSet.create(ImmutableSet.of(CelAttribute.create("unk")))); + } + + @Test + public void programAdvanceEvaluation_unsupportedIndexIgnored() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("unk", MapType.create(SimpleType.STRING, SimpleType.BOOL)) + .setContainer(CelContainer.ofName("")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + + CelRuntime.Program program = cel.createProgram(cel.compile("unk[dyn(b'a')]").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of( + CelAttributePattern.fromQualifiedIdentifier("unk") + .qualify(Qualifier.ofWildCard()))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + // Map is partially unknown, but we can't provide a more specific attribute if + // the index is of an unsupported type. + CelAttribute.fromQualifiedIdentifier("unk")))); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap( + ImmutableMap.of( + "unk", ImmutableMap.of(CelByteString.copyFromUtf8("a"), false))), + ImmutableList.of()))) + .isEqualTo(false); + } + + @Test + public void programAdvanceEvaluation_listIndexMacroTracking() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("testList", ListType.create(SimpleType.BOOL)) + .setContainer(CelContainer.ofName("")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + + CelRuntime.Program program = + cel.createProgram(cel.compile("testList.all(x, x == true)").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of("testList", ImmutableList.of(true, true, false))), + ImmutableList.of( + CelAttributePattern.create("testList").qualify(Qualifier.ofInt(2)))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of(CelAttribute.create("testList").qualify(Qualifier.ofInt(2))))); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of("testList", ImmutableList.of(true, false, false))), + ImmutableList.of( + CelAttributePattern.create("testList").qualify(Qualifier.ofInt(2)))))) + .isEqualTo(false); + } + + @Test + public void programAdvanceEvaluation_mapIndexMacroTracking() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("testMap", MapType.create(SimpleType.STRING, SimpleType.BOOL)) + .setContainer(CelContainer.ofName("")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + + CelRuntime.Program program = + cel.createProgram(cel.compile("testMap.all(x, testMap[x] == true)").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap( + ImmutableMap.of( + "testMap", + ImmutableMap.of( + "key1", true, + "key2", true, + "key3", false))), + ImmutableList.of( + CelAttributePattern.create("testMap") + .qualify(Qualifier.ofString("key3")))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("testMap").qualify(Qualifier.ofString("key3"))))); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap( + ImmutableMap.of( + "testMap", + ImmutableMap.of( + "key1", true, + "key2", false, + "key3", false))), + ImmutableList.of( + CelAttributePattern.create("testMap") + .qualify(Qualifier.ofString("key3")))))) + .isEqualTo(false); + } + + @Test + public void programAdvanceEvaluation_boolOperatorMergeUnknownPriority() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVarDeclarations( + CelVarDecl.newVarDeclaration("unk", SimpleType.BOOL), + CelVarDecl.newVarDeclaration("err", SimpleType.BOOL)) + .setContainer(CelContainer.ofName("com.google")) + .addFunctionBindings() + .setResultType(SimpleType.BOOL) + .build(); + CelRuntime.Program program = cel.createProgram(cel.compile("unk || err").getAst()); + assertThat(program.eval(ImmutableMap.of("unk", true))).isEqualTo(true); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap(ImmutableMap.of()), + ImmutableList.of(CelAttributePattern.fromQualifiedIdentifier("unk"))))) + .isEqualTo( + CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("unk"), ImmutableSet.of(3L))); + } + + @Test + public void programAdvanceEvaluation_partialUnknownMapEntryPropagates() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVarDeclarations( + ImmutableList.of( + CelVarDecl.newVarDeclaration("partialList1", ListType.create(SimpleType.INT)), + CelVarDecl.newVarDeclaration("partialList2", ListType.create(SimpleType.INT)))) + .setContainer(CelContainer.ofName("com.google")) + .addFunctionBindings() + .build(); + CelRuntime.Program program = + cel.createProgram( + cel.compile("{'key1': partialList1, 'key2': partialList2, 'key3': [1, 2, 3]}") + .getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap( + ImmutableMap.of( + "partialList1", ImmutableList.of(1, 2), + "partialList2", ImmutableList.of(1, 2))), + ImmutableList.of( + CelAttributePattern.create("partialList1").qualify(Qualifier.ofInt(1)), + CelAttributePattern.create("partialList2").qualify(Qualifier.ofInt(0)))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("partialList1"), CelAttribute.create("partialList2")))); + } + + @Test + public void programAdvanceEvaluation_partialUnknownListElementPropagates() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addVar("partialList1", ListType.create(SimpleType.INT)) + .addVar("partialList2", ListType.create(SimpleType.INT)) + .setContainer(CelContainer.ofName("com.google")) + .addFunctionBindings() + .build(); + CelRuntime.Program program = + cel.createProgram(cel.compile("[partialList1, partialList2, [1, 2, 3]]").getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap( + ImmutableMap.of( + "partialList1", ImmutableList.of(1, 2), + "partialList2", ImmutableList.of(1, 2))), + ImmutableList.of( + CelAttributePattern.create("partialList1").qualify(Qualifier.ofInt(1)), + CelAttributePattern.create("partialList2").qualify(Qualifier.ofInt(0)))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("partialList1"), CelAttribute.create("partialList2")))); + } + + @Test + public void programAdvanceEvaluation_partialUnknownMessageFieldPropagates() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar( + "partialMessage1", + StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")) + .addVar( + "partialMessage2", + StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")) + .setResultType( + StructTypeReference.create("cel.expr.conformance.proto3.NestedTestAllTypes")) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .addFunctionBindings() + .build(); + Program program = + cel.createProgram( + cel.compile( + "NestedTestAllTypes{" + + " child: NestedTestAllTypes{" + + " payload: partialMessage1" + + " }, " + + " payload: partialMessage2" + + "}") + .getAst()); + + assertThat( + program.advanceEvaluation( + UnknownContext.create( + fromMap( + ImmutableMap.of( + "partialMessage1", TestAllTypes.getDefaultInstance(), + "partialMessage2", TestAllTypes.getDefaultInstance())), + ImmutableList.of( + CelAttributePattern.fromQualifiedIdentifier( + "partialMessage1.single_double"), + CelAttributePattern.fromQualifiedIdentifier( + "partialMessage2.single_int64"))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("partialMessage1"), + CelAttribute.create("partialMessage2")))); + } + + @Test + public void program_functionBindingWithCustomType_assignableToRelatedType() throws Exception { + // A custom type that is assignable to an integer + CelType customType = + new CelType() { + @Override + public CelKind kind() { + return CelKind.INT; + } + + @Override + public String name() { + return "customInt"; + } + + @Override + public boolean isAssignableFrom(CelType other) { + return super.isAssignableFrom(other) || other.equals(SimpleType.INT); + } + }; + Cel cel = + CelFactory.standardCelBuilder() + .addVar("x", SimpleType.INT) + .addFunctionDeclarations( + newFunctionDeclaration( + "print", + newGlobalOverload( + "print_overload", + SimpleType.STRING, + customType))) // The overload would accept either Int or CustomType + .addFunctionBindings( + CelFunctionBinding.from("print_overload", Long.class, String::valueOf)) + .build(); + CelAbstractSyntaxTree ast = cel.compile("print(x)").getAst(); + + String result = (String) cel.createProgram(ast).eval(ImmutableMap.of("x", 5)); + + assertThat(result).isEqualTo("5"); + } + + @Test + @SuppressWarnings("unchecked") // test only + public void program_functionParamWithWellKnownType() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "hasStringValue", + newMemberOverload( + "struct_hasStringValue_string_string", + SimpleType.BOOL, + StructTypeReference.create("google.protobuf.Struct"), + SimpleType.STRING, + SimpleType.STRING))) + .addFunctionBindings( + CelFunctionBinding.from( + "struct_hasStringValue_string_string", + ImmutableList.of(Map.class, String.class, String.class), + args -> { + Map map = (Map) args[0]; + return map.containsKey(args[1]) && map.containsValue(args[2]); + })) + .build(); + CelAbstractSyntaxTree ast = cel.compile("{'a': 'b'}.hasStringValue('a', 'b')").getAst(); + + boolean result = (boolean) cel.createProgram(ast).eval(); + + assertThat(result).isTrue(); + } + + @Test + public void program_nativeTypeUnknownsEnabled_asIdentifiers() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addVar("x", SimpleType.BOOL) + .addVar("y", SimpleType.BOOL) + .setOptions(CelOptions.current().build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("x || y").getAst(); + + CelUnknownSet result = (CelUnknownSet) cel.createProgram(ast).eval(); + + assertThat(result.unknownExprIds()).containsExactly(1L, 3L); + assertThat(result.attributes()).isEmpty(); + } + + @Test + public void program_nativeTypeUnknownsEnabled_asCallArguments() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addVar("x", SimpleType.BOOL) + .addFunctionDeclarations( + newFunctionDeclaration( + "foo", newGlobalOverload("foo_bool", SimpleType.BOOL, SimpleType.BOOL))) + .setOptions(CelOptions.current().build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("foo(x)").getAst(); + + CelUnknownSet result = (CelUnknownSet) cel.createProgram(ast).eval(); + + assertThat(result.unknownExprIds()).containsExactly(2L); + assertThat(result.attributes()).isEmpty(); + } + + @Test + public void program_comprehensionDisabled_throws() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().enableComprehension(false).build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("['foo', 'bar'].map(x, x)").getAst(); + + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + assertThat(e).hasMessageThat().contains("Iteration budget exceeded: 0"); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.ITERATION_BUDGET_EXCEEDED); + } + + @Test + public void program_regexProgramSizeUnderLimit_success() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().maxRegexProgramSize(7).build()) + .build(); + // See + // https://github.com/google/re2j/blob/84237cbbd0fbd637c6eb6856717c1e248daae729/javatests/com/google/re2j/PatternTest.java#L175 for program size + CelAbstractSyntaxTree ast = cel.compile("'foo'.matches('(a+b)')").getAst(); + + assertThat(cel.createProgram(ast).eval()).isEqualTo(false); + } + + @Test + public void program_regexProgramSizeExceedsLimit_throws() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().maxRegexProgramSize(6).build()) + .build(); + // See + // https://github.com/google/re2j/blob/84237cbbd0fbd637c6eb6856717c1e248daae729/javatests/com/google/re2j/PatternTest.java#L175 for program size + CelAbstractSyntaxTree ast = cel.compile("'foo'.matches('(a+b)')").getAst(); + + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + assertThat(e) + .hasMessageThat() + .contains( + "evaluation error at :13: Regex pattern exceeds allowed program size. Allowed:" + + " 6, Provided: 7"); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.INVALID_ARGUMENT); + } + + @Test + @SuppressWarnings("unchecked") // test only + public void program_evaluateCanonicalTypesToNativeTypesDisabled_producesProtoValues() + throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .setOptions(CelOptions.current().evaluateCanonicalTypesToNativeValues(false).build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("[null, {b'abc': null}]").getAst(); + Map expectedNestedMap = new LinkedHashMap<>(); + expectedNestedMap.put(ByteString.copyFromUtf8("abc"), com.google.protobuf.NullValue.NULL_VALUE); + + List result = (List) cel.createProgram(ast).eval(); + + assertThat(result).containsExactly(com.google.protobuf.NullValue.NULL_VALUE, expectedNestedMap); + } + + @Test + public void program_evaluateCanonicalTypesToNativeTypesDisabled_producesBytesProto() + throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .setOptions(CelOptions.current().evaluateCanonicalTypesToNativeValues(false).build()) + .build(); + CelAbstractSyntaxTree ast = + cel.compile("TestAllTypes{single_bytes: bytes('abc')}.single_bytes").getAst(); + + ByteString result = (ByteString) cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(ByteString.copyFromUtf8("abc")); + } + + @Test + public void program_fdsContainsWktDependency_descriptorInstancesMatch() throws Exception { + // Force serialization of the descriptor to get a unique instance + FileDescriptorProto proto = TestAllTypes.getDescriptor().getFile().toProto(); + FileDescriptorSet fds = FileDescriptorSet.newBuilder().addFile(proto).build(); + ImmutableSet fileDescriptors = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds); + ImmutableSet descriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(fileDescriptors) + .messageTypeDescriptors(); + Descriptor testAllTypesDescriptor = + descriptors.stream() + .filter(x -> x.getFullName().equals(TestAllTypes.getDescriptor().getFullName())) + .findAny() + .get(); + + // Parse text proto using this fds + TypeRegistry typeRegistry = TypeRegistry.newBuilder().add(descriptors).build(); + TestAllTypes.Builder testAllTypesBuilder = TestAllTypes.newBuilder(); + TextFormat.Parser textFormatParser = + TextFormat.Parser.newBuilder().setTypeRegistry(typeRegistry).build(); + String textProto = + "single_timestamp {\n" // + + " seconds: 100\n" // + + "}"; + textFormatParser.merge(textProto, testAllTypesBuilder); + TestAllTypes testAllTypesFromTextProto = testAllTypesBuilder.build(); + DynamicMessage dynamicMessage = + DynamicMessage.parseFrom( + testAllTypesDescriptor, + testAllTypesFromTextProto.toByteArray(), + ExtensionRegistry.getEmptyRegistry()); + // Setup CEL environment with the same descriptors obtained from FDS + Cel cel = + standardCelBuilderWithMacros() + .addMessageTypes(descriptors) + // CEL-Internal-2 + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .build(); + CelAbstractSyntaxTree ast = + cel.compile("TestAllTypes{single_timestamp: timestamp(100)}").getAst(); + + DynamicMessage evalResult = (DynamicMessage) cel.createProgram(ast).eval(); + + // This should strictly equal regardless of where the descriptors came from for WKTs + assertThat(evalResult).isEqualTo(dynamicMessage); + } + + @Test + public void toBuilder_isImmutable() { + CelBuilder celBuilder = CelFactory.standardCelBuilder(); + CelImpl celImpl = (CelImpl) celBuilder.build(); + + CelImpl.Builder newCelBuilder = (CelImpl.Builder) celImpl.toCelBuilder(); + CelParserImpl.Builder newParserBuilder = (CelParserImpl.Builder) celImpl.toParserBuilder(); + CelCheckerLegacyImpl.Builder newCheckerBuilder = + (CelCheckerLegacyImpl.Builder) celImpl.toCheckerBuilder(); + CelCompilerImpl.Builder newCompilerBuilder = + (CelCompilerImpl.Builder) celImpl.toCompilerBuilder(); + CelRuntimeLegacyImpl.Builder newRuntimeBuilder = + (CelRuntimeLegacyImpl.Builder) celImpl.toRuntimeBuilder(); + + assertThat(newCelBuilder).isNotEqualTo(celBuilder); + assertThat(newParserBuilder).isNotEqualTo(celImpl.toParserBuilder()); + assertThat(newCheckerBuilder).isNotEqualTo(celImpl.toCheckerBuilder()); + assertThat(newCompilerBuilder).isNotEqualTo(celImpl.toCompilerBuilder()); + assertThat(newRuntimeBuilder).isNotEqualTo(celImpl.toRuntimeBuilder()); + } + + @Test + public void eval_withJsonFieldName(@TestParameter CelRuntimeFlavor runtimeFlavor) + throws Exception { + Cel cel = setupEnv(runtimeFlavor.builder()); + CelAbstractSyntaxTree ast = + cel.compile( + "file.int32_snake_case_json_name == 1 && " + + "file.int64CamelCaseJsonName == 2 && " + + "file.uint32DefaultJsonName == 3u && " + + "file.`uint64-custom-json-name` == 4u && " + + "file.single_string == 'shadows' && " + + "file.singleString == 'shadowed'") + .getAst(); + + boolean result = + (boolean) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "file", + SingleFile.newBuilder() + .setInt32SnakeCaseJsonName(1) + .setInt64CamelCaseJsonName(2L) + .setUint32DefaultJsonName(3) + .setUint64CustomJsonName(4) + .setStringJsonNameShadows("shadows") + .setSingleString("shadowed") + .setExtension(SingleFileExtensionsProto.int64CamelCaseJsonName, 5L) + .build())); + + assertThat(result).isTrue(); + } + + @Test + public void eval_withJsonFieldName_fieldsFallBack(@TestParameter CelRuntimeFlavor runtimeFlavor) + throws Exception { + Cel cel = setupEnv(runtimeFlavor.builder()); + CelAbstractSyntaxTree ast = + cel.compile( + "dyn(file).int32_snake_case_json_name == 1 && " + + "dyn(file).`uint64-custom-json-name` == 4u && " + + "dyn(file).single_string == 'shadows' && " + + "dyn(file).string_json_name_shadows == 'shadows' && " + + "dyn(file).singleString == 'shadowed'") + .getAst(); + + boolean result = + (boolean) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "file", + SingleFile.newBuilder() + .setInt32SnakeCaseJsonName(1) + .setInt64CamelCaseJsonName(2L) + .setUint32DefaultJsonName(3) + .setUint64CustomJsonName(4) + .setStringJsonNameShadows("shadows") + .setSingleString("shadowed") + .build())); + + assertThat(result).isTrue(); + } + + @Test + public void eval_withJsonFieldName_extensionFields(@TestParameter CelRuntimeFlavor runtimeFlavor) + throws Exception { + Cel cel = setupEnv(runtimeFlavor.builder()); + CelAbstractSyntaxTree ast = + cel.compile( + "proto.getExt(file, dev.cel.testing.testdata.int64CamelCaseJsonName) == 5 &&" + + " proto.getExt(file, dev.cel.testing.testdata.single_string) == 'foo'") + .getAst(); + + boolean result = + (boolean) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "file", + SingleFile.newBuilder() + .setInt64CamelCaseJsonName(2L) + .setExtension(SingleFileExtensionsProto.int64CamelCaseJsonName, 5L) + .setSingleString("This should not be used") + .setExtension(SingleFileExtensionsProto.singleString, "foo") + .build())); + + assertThat(result).isTrue(); + } + + @Test + public void eval_withJsonFieldName_runtimeOptionDisabled_throws() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("file", StructTypeReference.create(SingleFile.getDescriptor().getFullName())) + .addMessageTypes(SingleFile.getDescriptor()) + .setOptions(CelOptions.current().enableJsonFieldNames(true).build()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(SingleFile.getDescriptor()) + .setOptions(CelOptions.current().enableJsonFieldNames(false).build()) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("file.int64CamelCaseJsonName").getAst(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> + celRuntime + .createProgram(ast) + .eval(ImmutableMap.of("file", SingleFile.getDefaultInstance()))); + assertThat(e) + .hasMessageThat() + .contains( + "field 'int64CamelCaseJsonName' is not declared in message" + + " 'dev.cel.testing.testdata.SingleFile"); + } + + @Test + public void compile_withJsonFieldName_astTagged() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addVar("file", StructTypeReference.create(SingleFile.getDescriptor().getFullName())) + .addMessageTypes(SingleFile.getDescriptor()) + .setOptions(CelOptions.current().enableJsonFieldNames(true).build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("file.int64CamelCaseJsonName").getAst(); + + assertThat(ast.getSource().getExtensions()) + .contains( + Extension.create( + "json_name", Extension.Version.of(1L, 1L), Extension.Component.COMPONENT_RUNTIME)); + } + + @Test + public void compile_withJsonFieldName_protoFieldNameComparison_throws() throws Exception { + Cel cel = + standardCelBuilderWithMacros() + .addVar("file", StructTypeReference.create(SingleFile.getDescriptor().getFullName())) + .addMessageTypes(SingleFile.getDescriptor()) + .setOptions(CelOptions.current().enableJsonFieldNames(true).build()) + .build(); + + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> cel.compile("file.camelCased == file.snake_cased").getAst()); + assertThat(e).hasMessageThat().contains("undefined field 'snake_cased'"); + } + + private static TypeProvider aliasingProvider(ImmutableMap typeAliases) { + return new TypeProvider() { + @Override + public @Nullable Type lookupType(String typeName) { + Type alias = typeAliases.get(typeName); + if (alias != null) { + return CelProtoTypes.create(alias); + } + return null; + } + + @Override + public @Nullable Integer lookupEnumValue(String enumName) { + return null; + } + + @Override + public TypeProvider.@Nullable FieldType lookupFieldType(Type type, String fieldName) { + if (typeAliases.containsKey(type.getMessageType())) { + return TypeProvider.FieldType.of(CelProtoTypes.STRING); + } + return null; + } + }; + } + + private static Cel setupEnv(CelBuilder celBuilder) { + ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance(); + SingleFileExtensionsProto.registerAllExtensions(extensionRegistry); + return celBuilder + .addVar("file", StructTypeReference.create(SingleFile.getDescriptor().getFullName())) + .addMessageTypes(SingleFile.getDescriptor()) + .addFileTypes(SingleFileExtensionsProto.getDescriptor()) + .addCompilerLibraries(CelExtensions.protos()) + .setExtensionRegistry(extensionRegistry) + .setOptions( + CelOptions.current() + .enableJsonFieldNames(true) + .enableHeterogeneousNumericComparisons(true) + .enableQuotedIdentifierSyntax(true) + .build()) + .build(); + } +} diff --git a/cel_android_rules.bzl b/cel_android_rules.bzl new file mode 100644 index 000000000..9bd2fd8bc --- /dev/null +++ b/cel_android_rules.bzl @@ -0,0 +1,63 @@ +# Copyright 2025 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. +"""Macro to create android_library rules with CEL specific options applied.""" + +load("@rules_android//rules:rules.bzl", "android_library", "android_local_test") + +DEFAULT_JAVACOPTS = [ + "-XDstringConcat=inline", # SDK forces usage of StringConcatFactory (java 9+) +] + +def cel_android_library(name, **kwargs): + """ + Generates android_library target with CEL specific javacopts applied + + Args: + name: name of the android_library target + **kwargs: rest of the args accepted by android_library + """ + + javacopts = kwargs.get("javacopts", []) + all_javacopts = DEFAULT_JAVACOPTS + javacopts + + # By default, set visibility to android_allow_list, unless if overridden at the call site. + provided_visibility_or_default = kwargs.get("visibility", ["//:android_allow_list"]) + provided_compatible_with_or_default = kwargs.get("compatible_with", []) + filtered_kwargs = {k: v for k, v in kwargs.items() if k not in ["visibility", "compatible_with"]} + + android_library( + name = name, + visibility = provided_visibility_or_default, + compatible_with = provided_compatible_with_or_default, + javacopts = all_javacopts, + **filtered_kwargs + ) + +def cel_android_local_test(name, **kwargs): + """ + Generates android_local_test target with CEL specific javacopts applied + + Args: + name: name of the android_local_test target + **kwargs: rest of the args accepted by android_local_test + """ + + javacopts = kwargs.get("javacopts", []) + all_javacopts = DEFAULT_JAVACOPTS + javacopts + + android_local_test( + name = name, + javacopts = all_javacopts, + **kwargs + ) diff --git a/checker/BUILD.bazel b/checker/BUILD.bazel new file mode 100644 index 000000000..5fa3c6c05 --- /dev/null +++ b/checker/BUILD.bazel @@ -0,0 +1,60 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "checker", + exports = ["//checker/src/main/java/dev/cel/checker"], +) + +java_library( + name = "checker_builder", + exports = ["//checker/src/main/java/dev/cel/checker:checker_builder"], +) + +java_library( + name = "proto_type_mask", + exports = ["//checker/src/main/java/dev/cel/checker:proto_type_mask"], +) + +java_library( + name = "type_provider_legacy", + deprecation = "Please use CelTypeProvider instead in //common/types:type_providers", + exports = ["//checker/src/main/java/dev/cel/checker:type_provider_legacy"], +) + +java_library( + name = "type_provider_legacy_impl", + visibility = ["//:internal"], + exports = ["//checker/src/main/java/dev/cel/checker:type_provider_legacy_impl"], +) + +java_library( + name = "cel_ident_decl", + exports = ["//checker/src/main/java/dev/cel/checker:cel_ident_decl"], +) + +java_library( + name = "checker_legacy_environment", + deprecation = "See go/cel-java-migration-guide. Please use CEL-Java Fluent APIs //compiler instead", + exports = ["//checker/src/main/java/dev/cel/checker:checker_legacy_environment"], +) + +java_library( + name = "type_inferencer", + visibility = ["//:internal"], # Planned for use in a new type-checker. + exports = ["//checker/src/main/java/dev/cel/checker:type_inferencer"], +) + +java_library( + name = "proto_expr_visitor", + exports = ["//checker/src/main/java/dev/cel/checker:proto_expr_visitor"], +) + +java_library( + name = "standard_decl", + exports = ["//checker/src/main/java/dev/cel/checker:standard_decl"], +) diff --git a/checker/src/main/java/dev/cel/checker/BUILD.bazel b/checker/src/main/java/dev/cel/checker/BUILD.bazel new file mode 100644 index 000000000..99d4da586 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/BUILD.bazel @@ -0,0 +1,252 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//checker:__pkg__", + "//publish:__pkg__", + ], +) + +# keep sorted +CHECKER_SOURCES = [ + "CelCheckerLegacyImpl.java", + "ProtoTypeMaskTypeProvider.java", +] + +# keep sorted +CHECKER_BUILDER_SOURCES = [ + "CelChecker.java", + "CelCheckerBuilder.java", + "CelCheckerLibrary.java", +] + +# keep sorted +CHECKER_LEGACY_ENV_SOURCES = [ + "DescriptorTypeProvider.java", + "Env.java", + "ExprChecker.java", + "ExprVisitor.java", + "InferenceContext.java", + "TypeFormatter.java", + "TypeProvider.java", + "Types.java", +] + +java_library( + name = "type_provider_legacy", + srcs = [ + "DescriptorTypeProvider.java", + "TypeProvider.java", + "Types.java", + ], + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "//common/internal:file_descriptor_converter", + "//common/types", + "//common/types:cel_proto_types", + "//common/types:type_providers", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "checker", + srcs = CHECKER_SOURCES, + tags = [ + ], + deps = [ + ":cel_ident_decl", + ":checker_builder", + ":checker_legacy_environment", + ":proto_type_mask", + ":standard_decl", + ":type_provider_legacy_impl", + "//:auto_value", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common:source_location", + "//common/annotations", + "//common/ast:expr_converter", + "//common/internal:env_visitor", + "//common/internal:errors", + "//common/types", + "//common/types:cel_proto_types", + "//common/types:message_type_provider", + "//common/types:type_providers", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "checker_builder", + srcs = CHECKER_BUILDER_SOURCES, + tags = [ + ], + deps = [ + ":checker_legacy_environment", + ":proto_type_mask", + ":standard_decl", + "//common:cel_ast", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common/types:type_providers", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "proto_type_mask", + srcs = ["ProtoTypeMask.java"], + tags = [ + ], + deps = [ + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "cel_ident_decl", + srcs = [ + "CelIdentDecl.java", + ], + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "//common/ast", + "//common/ast:expr_converter", + "//common/types:cel_proto_types", + "//common/types:type_providers", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "type_provider_legacy_impl", + srcs = ["TypeProviderLegacyImpl.java"], + tags = [ + ], + deps = [ + ":checker_legacy_environment", + "//:auto_value", + "//common/annotations", + "//common/types", + "//common/types:cel_proto_types", + "//common/types:type_providers", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "checker_legacy_environment", + srcs = CHECKER_LEGACY_ENV_SOURCES, + tags = [ + ], + deps = [ + ":cel_ident_decl", + ":standard_decl", + "//:auto_value", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:mutable_ast", + "//common:operator", + "//common:options", + "//common:proto_ast", + "//common/annotations", + "//common/ast", + "//common/ast:expr_converter", + "//common/ast:mutable_expr", + "//common/internal:errors", + "//common/internal:file_descriptor_converter", + "//common/types", + "//common/types:cel_proto_types", + "//common/types:cel_types", + "//common/types:type_providers", + "//parser:macro", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "type_inferencer", + srcs = ["TypeInferencer.java"], + tags = [ + ], + deps = [ + "//:auto_value", + "//common/types", + "//common/types:type_providers", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "proto_expr_visitor", + srcs = [ + "CelProtoExprVisitor.java", + ], + tags = [ + ], + deps = [ + ":checker_legacy_environment", + "//common:cel_ast", + "//common:proto_ast", + ], +) + +java_library( + name = "standard_decl", + srcs = [ + "CelStandardDeclarations.java", + ], + tags = [ + ], + deps = [ + ":cel_ident_decl", + "//common:compiler_common", + "//common:operator", + "//common/types", + "//common/types:cel_types", + "//common/types:type_providers", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) diff --git a/checker/src/main/java/dev/cel/checker/CelChecker.java b/checker/src/main/java/dev/cel/checker/CelChecker.java new file mode 100644 index 000000000..077850be1 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/CelChecker.java @@ -0,0 +1,37 @@ +// Copyright 2022 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.checker; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.CelTypeProvider; + +/** Public interface for type-checking parsed CEL expressions. */ +@Immutable +public interface CelChecker { + + /** + * Check the input {@code ast} for type-agreement and return a {@code CelValidationResult}. + * + *

Check validates the type-agreement of the parsed {@code CelAbstractSyntaxTree}. + */ + CelValidationResult check(CelAbstractSyntaxTree ast); + + /** Returns the underlying type provider. */ + CelTypeProvider getTypeProvider(); + + CelCheckerBuilder toCheckerBuilder(); +} diff --git a/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java b/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java new file mode 100644 index 000000000..a7d531f88 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java @@ -0,0 +1,181 @@ +// Copyright 2022 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.checker; + +import dev.cel.expr.Decl; +import dev.cel.expr.Type; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelVarDecl; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; + +/** Interface for building an instance of CelChecker */ +public interface CelCheckerBuilder { + + /** Set the {@code CelOptions} used to enable fixes and features for this CEL instances. */ + @CanIgnoreReturnValue + CelCheckerBuilder setOptions(CelOptions options); + + /** Retrieves the currently configured {@link CelOptions} in the builder. */ + CelOptions options(); + + /** + * Set the {@link CelContainer} to use as the namespace for resolving CEL expression variables and + * functions. + */ + @CanIgnoreReturnValue + CelCheckerBuilder setContainer(CelContainer container); + + /** Retrieves the currently configured {@link CelContainer} in the builder. */ + CelContainer container(); + + /** Add variable and function {@code declarations} to the CEL environment. */ + @CanIgnoreReturnValue + CelCheckerBuilder addDeclarations(Decl... declarations); + + /** Add variable and function {@code declarations} to the CEL environment. */ + @CanIgnoreReturnValue + CelCheckerBuilder addDeclarations(Iterable declarations); + + /** Add function declaration {@code CelFunctionDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelCheckerBuilder addFunctionDeclarations(CelFunctionDecl... celFunctionDecls); + + /** Add function declaration {@code CelFunctionDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelCheckerBuilder addFunctionDeclarations(Iterable celFunctionDecls); + + /** Add variable declaration {@code CelVarDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelCheckerBuilder addVarDeclarations(CelVarDecl... celVarDecls); + + /** Add variable declaration {@code CelVarDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelCheckerBuilder addVarDeclarations(Iterable celVarDecls); + + /** + * Add one or more {@link ProtoTypeMask} values. The {@code ProtoTypeMask} values will be used to + * compute a set of {@code Decl} values using a protobuf message's fields as the names and types + * of the variables if {@link ProtoTypeMask#fieldsAreVariableDeclarations} is {@code true}. + * + *

Note, this feature may not work with custom {@link TypeProvider} implementations out of the + * box, as it requires the implementation of {@link TypeProvider#lookupFieldNames} to return the + * set of all fields declared on the protobuf type. + */ + @CanIgnoreReturnValue + CelCheckerBuilder addProtoTypeMasks(ProtoTypeMask... typeMasks); + + /** + * Add one or more {@link ProtoTypeMask} values. The {@code ProtoTypeMask} values will be used to + * compute a set of {@code Decl} values using a protobuf message's fields as the names and types + * of the variables if {@link ProtoTypeMask#fieldsAreVariableDeclarations} is {@code true}. + * + *

Note, this feature may not work with custom {@link TypeProvider} implementations out of the + * box, as it requires the implementation of {@link TypeProvider#lookupFieldNames} to return the + * set of all fields declared on the protobuf type. + */ + @CanIgnoreReturnValue + CelCheckerBuilder addProtoTypeMasks(Iterable typeMasks); + + /** Set the expected {@code resultType} for the type-checked expression. */ + @CanIgnoreReturnValue + CelCheckerBuilder setResultType(CelType resultType); + + /** + * Set the expected {@code resultType} in proto format described in checked.proto for the + * type-checked expression. + */ + @CanIgnoreReturnValue + CelCheckerBuilder setProtoResultType(Type resultType); + + /** + * Set the {@code typeProvider} for use with type-checking expressions. + * + * @deprecated Use {@link #setTypeProvider(CelTypeProvider)} instead. + */ + @CanIgnoreReturnValue + @Deprecated + CelCheckerBuilder setTypeProvider(TypeProvider celTypeProvider); + + /** Set the {@code celTypeProvider} for use with type-checking expressions. */ + @CanIgnoreReturnValue + CelCheckerBuilder setTypeProvider(CelTypeProvider celTypeProvider); + + /** + * Add message {@link Descriptor}s to the use for type-checking and object creation at + * interpretation time. + */ + @CanIgnoreReturnValue + CelCheckerBuilder addMessageTypes(Descriptor... descriptors); + + /** + * Add message {@link Descriptor}s to the use for type-checking and object creation at + * interpretation time. + */ + @CanIgnoreReturnValue + CelCheckerBuilder addMessageTypes(Iterable descriptors); + + /** + * Add {@link FileDescriptor}s to the use for type-checking, and for object creation at + * interpretation time. + */ + @CanIgnoreReturnValue + CelCheckerBuilder addFileTypes(FileDescriptor... fileDescriptors); + + /** + * Add {@link FileDescriptor}s to the use for type-checking, and for object creation at + * interpretation time. + */ + @CanIgnoreReturnValue + CelCheckerBuilder addFileTypes(Iterable fileDescriptors); + + /** + * Add all of the {@link FileDescriptor}s in a {@code FileDescriptorSet} to the use for + * type-checking, and for object creation at interpretation time. + */ + @CanIgnoreReturnValue + CelCheckerBuilder addFileTypes(FileDescriptorSet fileDescriptorSet); + + /** Enable or disable the standard CEL library functions and variables */ + @CanIgnoreReturnValue + CelCheckerBuilder setStandardEnvironmentEnabled(boolean value); + + /** + * Override the standard declarations for the type-checker. This can be used to subset the + * standard environment to only expose the desired declarations to the type-checker. {@link + * #setStandardEnvironmentEnabled(boolean)} must be set to false for this to take effect. + */ + @CanIgnoreReturnValue + CelCheckerBuilder setStandardDeclarations(CelStandardDeclarations standardDeclarations); + + /** Adds one or more libraries for parsing and type-checking. */ + @CanIgnoreReturnValue + CelCheckerBuilder addLibraries(CelCheckerLibrary... libraries); + + /** Adds a collection of libraries for parsing and type-checking. */ + @CanIgnoreReturnValue + CelCheckerBuilder addLibraries(Iterable libraries); + + /** Build a new instance of the {@code CelChecker}. */ + @CheckReturnValue + CelChecker build(); +} diff --git a/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java b/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java new file mode 100644 index 000000000..ceab0fa93 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java @@ -0,0 +1,566 @@ +// Copyright 2022 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.checker; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import dev.cel.expr.Decl; +import dev.cel.expr.Type; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelIssue; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelSource; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.CelValidationResult; +import dev.cel.common.CelVarDecl; +import dev.cel.common.annotations.Internal; +import dev.cel.common.ast.CelExprConverter; +import dev.cel.common.internal.EnvVisitable; +import dev.cel.common.internal.EnvVisitor; +import dev.cel.common.internal.Errors; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.ProtoMessageTypeProvider; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.SortedSet; +import java.util.TreeSet; +import org.jspecify.annotations.Nullable; + +/** + * {@code CelChecker} implementation which uses the original CEL-Java APIs to provide a simple, + * consistent interface for type-checking. + * + *

CEL Library Internals. Do Not Use. Consumers should use {@code CelCompilerFactory} to + * instantiate a type-checker. + */ +@Immutable +@Internal +public final class CelCheckerLegacyImpl implements CelChecker, EnvVisitable { + + private final CelOptions celOptions; + private final CelContainer container; + private final ImmutableSet identDeclarations; + private final ImmutableSet functionDeclarations; + private final Optional expectedResultType; + + @SuppressWarnings("Immutable") + private final TypeProvider typeProvider; + + private final CelTypeProvider celTypeProvider; + private final boolean standardEnvironmentEnabled; + + private final CelStandardDeclarations overriddenStandardDeclarations; + + // This does not affect the type-checking behavior in any manner. + @SuppressWarnings("Immutable") + private final ImmutableSet checkerLibraries; + + private final ImmutableSet fileDescriptors; + private final ImmutableSet protoTypeMasks; + + @Override + public CelValidationResult check(CelAbstractSyntaxTree ast) { + CelSource source = ast.getSource(); + Errors errors = new Errors(source.getDescription(), source.getContent().toString()); + Env env = getEnv(errors); + if (errors.getErrorCount() > 0) { + return new CelValidationResult(source, errorsToIssues(errors)); + } + + CelAbstractSyntaxTree checkedAst = + ExprChecker.typecheck(env, container, ast, expectedResultType); + if (errors.getErrorCount() > 0) { + return new CelValidationResult(source, errorsToIssues(errors)); + } + return new CelValidationResult(checkedAst, ImmutableList.of()); + } + + @Override + public CelTypeProvider getTypeProvider() { + return this.celTypeProvider; + } + + @Override + public CelCheckerBuilder toCheckerBuilder() { + CelCheckerBuilder builder = + new Builder() + .addIdentDeclarations(identDeclarations) + .setOptions(celOptions) + .setTypeProvider(celTypeProvider) + .setContainer(container) + .setStandardEnvironmentEnabled(standardEnvironmentEnabled) + .addFunctionDeclarations(functionDeclarations) + .addLibraries(checkerLibraries) + .addFileTypes(fileDescriptors) + .addProtoTypeMasks(protoTypeMasks); + + if (expectedResultType.isPresent()) { + builder.setResultType(expectedResultType.get()); + } + + if (overriddenStandardDeclarations != null) { + builder.setStandardDeclarations(overriddenStandardDeclarations); + } + + return builder; + } + + @Override + public void accept(EnvVisitor envVisitor) { + Errors errors = new Errors("", ""); + Env env = getEnv(errors); + for (int i = env.scopeDepth(); i >= 0; i--) { + Env.DeclGroup declGroup = env.getDeclGroup(i); + SortedSet names = new TreeSet<>(); + names.addAll(declGroup.getIdents().keySet()); + names.addAll(declGroup.getFunctions().keySet()); + for (String name : names) { + CelIdentDecl ident = declGroup.getIdent(name); + CelFunctionDecl func = declGroup.getFunction(name); + List decls = new ArrayList<>(); + if (ident != null) { + decls.add(CelIdentDecl.celIdentToDecl(ident)); + } + if (func != null) { + decls.add(CelFunctionDecl.celFunctionDeclToDecl(func)); + } + envVisitor.visitDecl(name, decls); + } + } + } + + private Env getEnv(Errors errors) { + Env env; + if (standardEnvironmentEnabled) { + env = Env.standard(errors, typeProvider, celOptions); + } else if (overriddenStandardDeclarations != null) { + env = Env.standard(overriddenStandardDeclarations, errors, typeProvider, celOptions); + } else { + env = Env.unconfigured(errors, typeProvider, celOptions); + } + identDeclarations.forEach(env::add); + functionDeclarations.forEach(env::add); + return env; + } + + /** Create a new builder to construct a {@code CelChecker} instance. */ + public static CelCheckerBuilder newBuilder() { + return new Builder(); + } + + /** Builder class for the legacy {@code CelChecker} implementation. */ + public static final class Builder implements CelCheckerBuilder { + + private final ImmutableSet.Builder identDeclarations; + private final ImmutableSet.Builder functionDeclarations; + private final ImmutableSet.Builder protoTypeMasks; + private final ImmutableSet.Builder messageTypes; + private final ImmutableSet.Builder fileTypes; + private final ImmutableSet.Builder celCheckerLibraries; + private CelContainer container; + private CelOptions celOptions; + private CelType expectedResultType; + private TypeProvider customTypeProvider; + private CelTypeProvider celTypeProvider; + private boolean standardEnvironmentEnabled; + private CelStandardDeclarations standardDeclarations; + + @Override + public CelCheckerBuilder setOptions(CelOptions celOptions) { + this.celOptions = checkNotNull(celOptions); + return this; + } + + @Override + public CelOptions options() { + return this.celOptions; + } + + @Override + public CelCheckerBuilder setContainer(CelContainer container) { + checkNotNull(container); + this.container = container; + return this; + } + + @Override + public CelContainer container() { + return this.container; + } + + @Override + public CelCheckerBuilder addDeclarations(Decl... declarations) { + checkNotNull(declarations); + return addDeclarations(Arrays.asList(declarations)); + } + + @Override + public CelCheckerBuilder addDeclarations(Iterable declarations) { + checkNotNull(declarations); + for (Decl decl : declarations) { + switch (decl.getDeclKindCase()) { + case IDENT: + CelIdentDecl.Builder identBuilder = + CelIdentDecl.newBuilder() + .setName(decl.getName()) + .setType(CelProtoTypes.typeToCelType(decl.getIdent().getType())) + // Note: Setting doc and constant value exists for compatibility reason. This + // should not be set by the users. + .setDoc(decl.getIdent().getDoc()); + if (decl.getIdent().hasValue()) { + identBuilder.setConstant( + CelExprConverter.exprConstantToCelConstant(decl.getIdent().getValue())); + } + + this.identDeclarations.add(identBuilder.build()); + break; + case FUNCTION: + addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + decl.getName(), + decl.getFunction().getOverloadsList().stream() + .map(CelOverloadDecl::overloadToCelOverload) + .collect(toImmutableList()))); + break; + default: + throw new IllegalArgumentException("unexpected decl kind: " + decl.getDeclKindCase()); + } + } + return this; + } + + @Override + @CanIgnoreReturnValue + public CelCheckerBuilder addFunctionDeclarations(CelFunctionDecl... celFunctionDecls) { + checkNotNull(celFunctionDecls); + return addFunctionDeclarations(Arrays.asList(celFunctionDecls)); + } + + @Override + public CelCheckerBuilder addFunctionDeclarations(Iterable celFunctionDecls) { + checkNotNull(celFunctionDecls); + this.functionDeclarations.addAll(celFunctionDecls); + return this; + } + + @Override + public CelCheckerBuilder addVarDeclarations(CelVarDecl... celVarDecls) { + checkNotNull(celVarDecls); + return addVarDeclarations(Arrays.asList(celVarDecls)); + } + + @Override + public CelCheckerBuilder addVarDeclarations(Iterable celVarDecls) { + checkNotNull(celVarDecls); + for (CelVarDecl celVarDecl : celVarDecls) { + this.identDeclarations.add( + CelIdentDecl.newIdentDeclaration(celVarDecl.name(), celVarDecl.type())); + } + return this; + } + + @Override + public CelCheckerBuilder addProtoTypeMasks(ProtoTypeMask... typeMasks) { + checkNotNull(typeMasks); + return addProtoTypeMasks(Arrays.asList(typeMasks)); + } + + @Override + public CelCheckerBuilder addProtoTypeMasks(Iterable typeMasks) { + checkNotNull(typeMasks); + protoTypeMasks.addAll(typeMasks); + return this; + } + + @Override + public CelCheckerBuilder setResultType(CelType resultType) { + checkNotNull(resultType); + this.expectedResultType = resultType; + return this; + } + + @Override + public CelCheckerBuilder setProtoResultType(Type resultType) { + checkNotNull(resultType); + return setResultType(CelProtoTypes.typeToCelType(resultType)); + } + + @Override + @Deprecated + public CelCheckerBuilder setTypeProvider(TypeProvider typeProvider) { + this.customTypeProvider = typeProvider; + return this; + } + + @Override + public CelCheckerBuilder setTypeProvider(CelTypeProvider celTypeProvider) { + this.celTypeProvider = celTypeProvider; + return this; + } + + @Override + public CelCheckerBuilder addMessageTypes(Descriptor... descriptors) { + return addMessageTypes(Arrays.asList(checkNotNull(descriptors))); + } + + @Override + public CelCheckerBuilder addMessageTypes(Iterable descriptors) { + this.messageTypes.addAll(checkNotNull(descriptors)); + return this; + } + + @Override + public CelCheckerBuilder addFileTypes(FileDescriptor... fileDescriptors) { + return addFileTypes(Arrays.asList(checkNotNull(fileDescriptors))); + } + + @Override + public CelCheckerBuilder addFileTypes(Iterable fileDescriptors) { + this.fileTypes.addAll(checkNotNull(fileDescriptors)); + return this; + } + + @Override + public CelCheckerBuilder addFileTypes(FileDescriptorSet fileDescriptorSet) { + checkNotNull(fileDescriptorSet); + return addFileTypes( + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fileDescriptorSet)); + } + + @Override + public CelCheckerBuilder setStandardEnvironmentEnabled(boolean value) { + this.standardEnvironmentEnabled = value; + return this; + } + + @Override + public CelCheckerBuilder setStandardDeclarations(CelStandardDeclarations standardDeclarations) { + this.standardDeclarations = checkNotNull(standardDeclarations); + return this; + } + + @Override + public CelCheckerBuilder addLibraries(CelCheckerLibrary... libraries) { + checkNotNull(libraries); + return this.addLibraries(Arrays.asList(libraries)); + } + + @Override + public CelCheckerBuilder addLibraries(Iterable libraries) { + checkNotNull(libraries); + this.celCheckerLibraries.addAll(libraries); + return this; + } + + @CanIgnoreReturnValue + Builder addIdentDeclarations(ImmutableSet identDeclarations) { + this.identDeclarations.addAll(identDeclarations); + return this; + } + + // The following getters marked @VisibleForTesting exist for testing toCheckerBuilder copies + // over all properties. Do not expose these to public + @VisibleForTesting + ImmutableSet.Builder functionDecls() { + return this.functionDeclarations; + } + + @VisibleForTesting + ImmutableSet.Builder identDecls() { + return this.identDeclarations; + } + + @VisibleForTesting + ImmutableSet.Builder protoTypeMasks() { + return this.protoTypeMasks; + } + + @VisibleForTesting + ImmutableSet.Builder messageTypes() { + return this.messageTypes; + } + + @VisibleForTesting + ImmutableSet.Builder fileTypes() { + return this.fileTypes; + } + + @VisibleForTesting + ImmutableSet.Builder checkerLibraries() { + return this.celCheckerLibraries; + } + + @VisibleForTesting + CelStandardDeclarations standardDeclarations() { + return this.standardDeclarations; + } + + @VisibleForTesting + CelTypeProvider celTypeProvider() { + return this.celTypeProvider; + } + + @Override + @CheckReturnValue + public CelCheckerLegacyImpl build() { + if (standardEnvironmentEnabled && standardDeclarations != null) { + throw new IllegalArgumentException( + "setStandardEnvironmentEnabled must be set to false to override standard" + + " declarations."); + } + + // Add libraries, such as extensions + ImmutableSet checkerLibraries = celCheckerLibraries.build(); + checkerLibraries.forEach(celLibrary -> celLibrary.setCheckerOptions(this)); + + // Configure the type provider. + ImmutableSet fileTypeSet = fileTypes.build(); + ImmutableSet messageTypeSet = messageTypes.build(); + if (!messageTypeSet.isEmpty()) { + fileTypeSet = + new ImmutableSet.Builder() + .addAll(fileTypeSet) + .addAll(messageTypeSet.stream().map(Descriptor::getFile).collect(toImmutableSet())) + .build(); + } + + CelTypeProvider messageTypeProvider = + ProtoMessageTypeProvider.newBuilder() + .setAllowJsonFieldNames(celOptions.enableJsonFieldNames()) + .setResolveTypeDependencies(celOptions.resolveTypeDependencies()) + .addFileDescriptors(fileTypeSet) + .build(); + + if (celTypeProvider != null && fileTypeSet.isEmpty()) { + messageTypeProvider = celTypeProvider; + } else if (celTypeProvider != null) { + messageTypeProvider = + new CelTypeProvider.CombinedCelTypeProvider( + ImmutableList.of(celTypeProvider, messageTypeProvider)); + } + + // Configure the declaration set, and possibly alter the type provider if ProtoDecl values + // are provided as they may prevent the use of certain field selection patterns against the + // proto. + ImmutableSet identDeclarationSet = identDeclarations.build(); + ImmutableSet protoTypeMaskSet = protoTypeMasks.build(); + if (!protoTypeMaskSet.isEmpty()) { + ProtoTypeMaskTypeProvider protoTypeMaskTypeProvider = + new ProtoTypeMaskTypeProvider(messageTypeProvider, protoTypeMaskSet); + identDeclarationSet = + ImmutableSet.builder() + .addAll(identDeclarationSet) + .addAll(protoTypeMaskTypeProvider.computeDeclsFromProtoTypeMasks()) + .build(); + messageTypeProvider = protoTypeMaskTypeProvider; + } + + TypeProvider legacyProvider = new TypeProviderLegacyImpl(messageTypeProvider); + if (customTypeProvider != null) { + legacyProvider = + new TypeProvider.CombinedTypeProvider( + ImmutableList.of(customTypeProvider, legacyProvider)); + } + + return new CelCheckerLegacyImpl( + celOptions, + container, + identDeclarationSet, + functionDeclarations.build(), + Optional.fromNullable(expectedResultType), + legacyProvider, + messageTypeProvider, + standardEnvironmentEnabled, + standardDeclarations, + checkerLibraries, + fileTypeSet, + protoTypeMaskSet); + } + + private Builder() { + this.celOptions = CelOptions.newBuilder().build(); + this.identDeclarations = ImmutableSet.builder(); + this.functionDeclarations = ImmutableSet.builder(); + this.fileTypes = ImmutableSet.builder(); + this.messageTypes = ImmutableSet.builder(); + this.protoTypeMasks = ImmutableSet.builder(); + this.celCheckerLibraries = ImmutableSet.builder(); + this.container = CelContainer.ofName(""); + } + } + + private CelCheckerLegacyImpl( + CelOptions celOptions, + CelContainer container, + ImmutableSet identDeclarations, + ImmutableSet functionDeclarations, + Optional expectedResultType, + TypeProvider typeProvider, + CelTypeProvider celTypeProvider, + boolean standardEnvironmentEnabled, + @Nullable CelStandardDeclarations overriddenStandardDeclarations, + ImmutableSet checkerLibraries, + ImmutableSet fileDescriptors, + ImmutableSet protoTypeMasks) { + this.celOptions = celOptions; + this.container = container; + this.identDeclarations = identDeclarations; + this.functionDeclarations = functionDeclarations; + this.expectedResultType = expectedResultType; + this.typeProvider = typeProvider; + this.celTypeProvider = celTypeProvider; + this.standardEnvironmentEnabled = standardEnvironmentEnabled; + this.overriddenStandardDeclarations = overriddenStandardDeclarations; + this.checkerLibraries = checkerLibraries; + this.fileDescriptors = fileDescriptors; + this.protoTypeMasks = protoTypeMasks; + } + + private static ImmutableList errorsToIssues(Errors errors) { + ImmutableList errorList = errors.getErrors(); + CelIssue.Builder issueBuilder = CelIssue.newBuilder().setSeverity(CelIssue.Severity.ERROR); + return errorList.stream() + .map( + e -> { + Errors.SourceLocation loc = errors.getPositionLocation(e.position()); + CelSourceLocation newLoc = CelSourceLocation.of(loc.line(), loc.column() - 1); + return issueBuilder + .setExprId(e.exprId()) + .setMessage(e.rawMessage()) + .setSourceLocation(newLoc) + .build(); + }) + .collect(toImmutableList()); + } +} diff --git a/checker/src/main/java/dev/cel/checker/CelCheckerLibrary.java b/checker/src/main/java/dev/cel/checker/CelCheckerLibrary.java new file mode 100644 index 000000000..8d7efcab7 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/CelCheckerLibrary.java @@ -0,0 +1,26 @@ +// Copyright 2023 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.checker; + +/** + * CelCheckerLibrary defines the interface to extend functionalities beyond the CEL standard + * functions for {@link CelChecker}. + */ +public interface CelCheckerLibrary { + /** + * Configures the checker to support the library implementation, such as adding function bindings + */ + default void setCheckerOptions(CelCheckerBuilder checkerBuilder) {} +} diff --git a/checker/src/main/java/dev/cel/checker/CelIdentDecl.java b/checker/src/main/java/dev/cel/checker/CelIdentDecl.java new file mode 100644 index 000000000..60f747b77 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/CelIdentDecl.java @@ -0,0 +1,103 @@ +// Copyright 2023 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.checker; + +import dev.cel.expr.Decl; +import dev.cel.expr.Decl.IdentDecl; +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExprConverter; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import java.util.Optional; + +/** + * Abstract representation of a CEL identifier declaration. + * + *

CEL Library Internals. Do Not Use. + */ +@AutoValue +@Immutable +@Internal +public abstract class CelIdentDecl { + + /** Fully qualified variable name. */ + public abstract String name(); + + /** The type of the variable. */ + public abstract CelType type(); + + /** + * The constant value of the identifier. If not specified, the identifier must be supplied at + * evaluation time. + */ + public abstract Optional constant(); + + /** Documentation string for the identifier. */ + public abstract String doc(); + + /** Converts a {@link CelIdentDecl} to a protobuf equivalent form {@code Decl} */ + public static Decl celIdentToDecl(CelIdentDecl identDecl) { + IdentDecl.Builder identBuilder = + IdentDecl.newBuilder() + .setDoc(identDecl.doc()) + .setType(CelProtoTypes.celTypeToType(identDecl.type())); + if (identDecl.constant().isPresent()) { + identBuilder.setValue(CelExprConverter.celConstantToExprConstant(identDecl.constant().get())); + } + return Decl.newBuilder().setName(identDecl.name()).setIdent(identBuilder).build(); + } + + /** Create a new {@code CelIdentDecl} with a given {@code name} and {@code type}. */ + @CheckReturnValue + public static CelIdentDecl newIdentDeclaration(String name, CelType type) { + return newBuilder().setName(name).setType(type).build(); + } + + public static Builder newBuilder() { + return new AutoValue_CelIdentDecl.Builder().setDoc(""); + } + + /** Builder for configuring the {@link CelIdentDecl}. */ + @AutoValue.Builder + public abstract static class Builder { + @CanIgnoreReturnValue + public abstract Builder setName(String name); + + @CanIgnoreReturnValue + public abstract Builder setType(CelType name); + + @CanIgnoreReturnValue + public abstract Builder setConstant(CelConstant constant); + + @CanIgnoreReturnValue + public abstract Builder setConstant(Optional constant); + + @CanIgnoreReturnValue + public abstract Builder setDoc(String value); + + @CanIgnoreReturnValue + public Builder clearConstant() { + return setConstant(Optional.empty()); + } + + @CheckReturnValue + public abstract CelIdentDecl build(); + } +} diff --git a/checker/src/main/java/dev/cel/checker/CelProtoExprVisitor.java b/checker/src/main/java/dev/cel/checker/CelProtoExprVisitor.java new file mode 100644 index 000000000..08552d56f --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/CelProtoExprVisitor.java @@ -0,0 +1,31 @@ +// Copyright 2022 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.checker; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelProtoAbstractSyntaxTree; + +/** + * CEL expression visitor implementation based on the {@link dev.cel.expr.Expr} proto. + * + *

Note: Prefer using {@link dev.cel.common.ast.CelExprVisitor} if protobuf support is not + * needed. + */ +public abstract class CelProtoExprVisitor extends ExprVisitor { + /** Visit the {@code ast} value, routing to overloads based on the kind of expression. */ + public void visit(CelAbstractSyntaxTree ast) { + visit(CelProtoAbstractSyntaxTree.fromCelAst(ast).getExpr()); + } +} diff --git a/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java b/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java new file mode 100644 index 000000000..53615604f --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java @@ -0,0 +1,1796 @@ +// Copyright 2024 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.checker; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static java.util.Arrays.stream; + +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.Operator; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypes; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeParamType; +import dev.cel.common.types.TypeType; +import java.util.Optional; + +/** + * Standard declarations for CEL. + * + *

Refer to CEL + * Specification for comprehensive listing of functions and identifiers included in the standard + * environment. + */ +@Immutable +public final class CelStandardDeclarations { + // Some shortcuts we use when building declarations. + private static final TypeParamType TYPE_PARAM_A = TypeParamType.create("A"); + private static final ListType LIST_OF_A = ListType.create(TYPE_PARAM_A); + private static final TypeParamType TYPE_PARAM_B = TypeParamType.create("B"); + private static final MapType MAP_OF_AB = MapType.create(TYPE_PARAM_A, TYPE_PARAM_B); + + private final ImmutableSet celFunctionDecls; + private final ImmutableSet celIdentDecls; + + /** Enumeration of Standard Functions. */ + public enum StandardFunction { + // Deprecated - use {@link #IN} + OLD_IN( + true, + Operator.OLD_IN.getFunction(), + () -> + CelOverloadDecl.newGlobalOverload( + "in_list", "list membership", SimpleType.BOOL, TYPE_PARAM_A, LIST_OF_A), + () -> + CelOverloadDecl.newGlobalOverload( + "in_map", "map key membership", SimpleType.BOOL, TYPE_PARAM_A, MAP_OF_AB)), + + // Deprecated - use {@link #NOT_STRICTLY_FALSE} + OLD_NOT_STRICTLY_FALSE( + true, + Operator.OLD_NOT_STRICTLY_FALSE.getFunction(), + () -> + CelOverloadDecl.newGlobalOverload( + "not_strictly_false", + "false if argument is false, true otherwise (including errors and unknowns)", + SimpleType.BOOL, + SimpleType.BOOL)), + + // Internal (rewritten by macro) + IN(Operator.IN, Overload.InternalOperator.IN_LIST, Overload.InternalOperator.IN_MAP), + NOT_STRICTLY_FALSE(Operator.NOT_STRICTLY_FALSE, Overload.InternalOperator.NOT_STRICTLY_FALSE), + TYPE("type", Overload.InternalOperator.TYPE), + + // Booleans + CONDITIONAL(Operator.CONDITIONAL, Overload.BooleanOperator.CONDITIONAL), + LOGICAL_NOT(Operator.LOGICAL_NOT, Overload.BooleanOperator.LOGICAL_NOT), + LOGICAL_OR(Operator.LOGICAL_OR, Overload.BooleanOperator.LOGICAL_OR), + LOGICAL_AND(Operator.LOGICAL_AND, Overload.BooleanOperator.LOGICAL_AND), + + // Relations + EQUALS(Operator.EQUALS, Overload.Relation.EQUALS), + NOT_EQUALS(Operator.NOT_EQUALS, Overload.Relation.NOT_EQUALS), + + // Arithmetic + ADD( + Operator.ADD, + Overload.Arithmetic.ADD_INT64, + Overload.Arithmetic.ADD_UINT64, + Overload.Arithmetic.ADD_DOUBLE, + Overload.Arithmetic.ADD_STRING, + Overload.Arithmetic.ADD_BYTES, + Overload.Arithmetic.ADD_LIST, + Overload.Arithmetic.ADD_TIMESTAMP_DURATION, + Overload.Arithmetic.ADD_DURATION_TIMESTAMP, + Overload.Arithmetic.ADD_DURATION_DURATION), + SUBTRACT( + Operator.SUBTRACT, + Overload.Arithmetic.SUBTRACT_INT64, + Overload.Arithmetic.SUBTRACT_UINT64, + Overload.Arithmetic.SUBTRACT_DOUBLE, + Overload.Arithmetic.SUBTRACT_TIMESTAMP_TIMESTAMP, + Overload.Arithmetic.SUBTRACT_TIMESTAMP_DURATION, + Overload.Arithmetic.SUBTRACT_DURATION_DURATION), + MULTIPLY( + Operator.MULTIPLY, + Overload.Arithmetic.MULTIPLY_INT64, + Overload.Arithmetic.MULTIPLY_UINT64, + Overload.Arithmetic.MULTIPLY_DOUBLE), + DIVIDE( + Operator.DIVIDE, + Overload.Arithmetic.DIVIDE_INT64, + Overload.Arithmetic.DIVIDE_UINT64, + Overload.Arithmetic.DIVIDE_DOUBLE), + MODULO(Operator.MODULO, Overload.Arithmetic.MODULO_INT64, Overload.Arithmetic.MODULO_UINT64), + + NEGATE(Operator.NEGATE, Overload.Arithmetic.NEGATE_INT64, Overload.Arithmetic.NEGATE_DOUBLE), + + // Index + INDEX(Operator.INDEX, Overload.Index.INDEX_LIST, Overload.Index.INDEX_MAP), + + // Size + SIZE( + "size", + Overload.Size.SIZE_STRING, + Overload.Size.SIZE_BYTES, + Overload.Size.SIZE_LIST, + Overload.Size.SIZE_MAP, + Overload.Size.STRING_SIZE, + Overload.Size.BYTES_SIZE, + Overload.Size.LIST_SIZE, + Overload.Size.MAP_SIZE), + + // Conversions + INT( + "int", + Overload.Conversions.INT64_TO_INT64, + Overload.Conversions.UINT64_TO_INT64, + Overload.Conversions.DOUBLE_TO_INT64, + Overload.Conversions.STRING_TO_INT64, + Overload.Conversions.TIMESTAMP_TO_INT64), + UINT( + "uint", + Overload.Conversions.UINT64_TO_UINT64, + Overload.Conversions.INT64_TO_UINT64, + Overload.Conversions.DOUBLE_TO_UINT64, + Overload.Conversions.STRING_TO_UINT64), + DOUBLE( + "double", + Overload.Conversions.DOUBLE_TO_DOUBLE, + Overload.Conversions.INT64_TO_DOUBLE, + Overload.Conversions.UINT64_TO_DOUBLE, + Overload.Conversions.STRING_TO_DOUBLE), + STRING( + "string", + Overload.Conversions.STRING_TO_STRING, + Overload.Conversions.INT64_TO_STRING, + Overload.Conversions.UINT64_TO_STRING, + Overload.Conversions.DOUBLE_TO_STRING, + Overload.Conversions.BOOL_TO_STRING, + Overload.Conversions.BYTES_TO_STRING, + Overload.Conversions.TIMESTAMP_TO_STRING, + Overload.Conversions.DURATION_TO_STRING), + BYTES("bytes", Overload.Conversions.BYTES_TO_BYTES, Overload.Conversions.STRING_TO_BYTES), + DYN("dyn", Overload.Conversions.TO_DYN), + DURATION( + "duration", + Overload.Conversions.DURATION_TO_DURATION, + Overload.Conversions.STRING_TO_DURATION), + TIMESTAMP( + "timestamp", + Overload.Conversions.STRING_TO_TIMESTAMP, + Overload.Conversions.TIMESTAMP_TO_TIMESTAMP, + Overload.Conversions.INT64_TO_TIMESTAMP), + BOOL("bool", Overload.Conversions.BOOL_TO_BOOL, Overload.Conversions.STRING_TO_BOOL), + + // String matchers + MATCHES("matches", Overload.StringMatchers.MATCHES, Overload.StringMatchers.MATCHES_STRING), + CONTAINS("contains", Overload.StringMatchers.CONTAINS_STRING), + ENDS_WITH("endsWith", Overload.StringMatchers.ENDS_WITH_STRING), + STARTS_WITH("startsWith", Overload.StringMatchers.STARTS_WITH_STRING), + + // Date/time operations + GET_FULL_YEAR( + "getFullYear", + Overload.DateTime.TIMESTAMP_TO_YEAR, + Overload.DateTime.TIMESTAMP_TO_YEAR_WITH_TZ), + GET_MONTH( + "getMonth", + Overload.DateTime.TIMESTAMP_TO_MONTH, + Overload.DateTime.TIMESTAMP_TO_MONTH_WITH_TZ), + GET_DAY_OF_YEAR( + "getDayOfYear", + Overload.DateTime.TIMESTAMP_TO_DAY_OF_YEAR, + Overload.DateTime.TIMESTAMP_TO_DAY_OF_YEAR_WITH_TZ), + GET_DAY_OF_MONTH( + "getDayOfMonth", + Overload.DateTime.TIMESTAMP_TO_DAY_OF_MONTH, + Overload.DateTime.TIMESTAMP_TO_DAY_OF_MONTH_WITH_TZ), + GET_DATE( + "getDate", + Overload.DateTime.TIMESTAMP_TO_DAY_OF_MONTH_1_BASED, + Overload.DateTime.TIMESTAMP_TO_DAY_OF_MONTH_1_BASED_WITH_TZ), + GET_DAY_OF_WEEK( + "getDayOfWeek", + Overload.DateTime.TIMESTAMP_TO_DAY_OF_WEEK, + Overload.DateTime.TIMESTAMP_TO_DAY_OF_WEEK_WITH_TZ), + GET_HOURS( + "getHours", + Overload.DateTime.TIMESTAMP_TO_HOURS, + Overload.DateTime.TIMESTAMP_TO_HOURS_WITH_TZ, + Overload.DateTime.DURATION_TO_HOURS), + GET_MINUTES( + "getMinutes", + Overload.DateTime.TIMESTAMP_TO_MINUTES, + Overload.DateTime.TIMESTAMP_TO_MINUTES_WITH_TZ, + Overload.DateTime.DURATION_TO_MINUTES), + GET_SECONDS( + "getSeconds", + Overload.DateTime.TIMESTAMP_TO_SECONDS, + Overload.DateTime.TIMESTAMP_TO_SECONDS_WITH_TZ, + Overload.DateTime.DURATION_TO_SECONDS), + GET_MILLISECONDS( + "getMilliseconds", + Overload.DateTime.TIMESTAMP_TO_MILLISECONDS, + Overload.DateTime.TIMESTAMP_TO_MILLISECONDS_WITH_TZ, + Overload.DateTime.DURATION_TO_MILLISECONDS), + + // Comparisons + LESS( + Operator.LESS, + Overload.Comparison.LESS_BOOL, + Overload.Comparison.LESS_INT64, + Overload.Comparison.LESS_UINT64, + Overload.Comparison.LESS_DOUBLE, + Overload.Comparison.LESS_STRING, + Overload.Comparison.LESS_BYTES, + Overload.Comparison.LESS_TIMESTAMP, + Overload.Comparison.LESS_DURATION, + Overload.Comparison.LESS_INT64_UINT64, + Overload.Comparison.LESS_UINT64_INT64, + Overload.Comparison.LESS_INT64_DOUBLE, + Overload.Comparison.LESS_DOUBLE_INT64, + Overload.Comparison.LESS_UINT64_DOUBLE, + Overload.Comparison.LESS_DOUBLE_UINT64), + LESS_EQUALS( + Operator.LESS_EQUALS, + Overload.Comparison.LESS_EQUALS_BOOL, + Overload.Comparison.LESS_EQUALS_INT64, + Overload.Comparison.LESS_EQUALS_UINT64, + Overload.Comparison.LESS_EQUALS_DOUBLE, + Overload.Comparison.LESS_EQUALS_STRING, + Overload.Comparison.LESS_EQUALS_BYTES, + Overload.Comparison.LESS_EQUALS_TIMESTAMP, + Overload.Comparison.LESS_EQUALS_DURATION, + Overload.Comparison.LESS_EQUALS_INT64_UINT64, + Overload.Comparison.LESS_EQUALS_UINT64_INT64, + Overload.Comparison.LESS_EQUALS_INT64_DOUBLE, + Overload.Comparison.LESS_EQUALS_DOUBLE_INT64, + Overload.Comparison.LESS_EQUALS_UINT64_DOUBLE, + Overload.Comparison.LESS_EQUALS_DOUBLE_UINT64), + GREATER( + Operator.GREATER, + Overload.Comparison.GREATER_BOOL, + Overload.Comparison.GREATER_INT64, + Overload.Comparison.GREATER_UINT64, + Overload.Comparison.GREATER_DOUBLE, + Overload.Comparison.GREATER_STRING, + Overload.Comparison.GREATER_BYTES, + Overload.Comparison.GREATER_TIMESTAMP, + Overload.Comparison.GREATER_DURATION, + Overload.Comparison.GREATER_INT64_UINT64, + Overload.Comparison.GREATER_UINT64_INT64, + Overload.Comparison.GREATER_INT64_DOUBLE, + Overload.Comparison.GREATER_DOUBLE_INT64, + Overload.Comparison.GREATER_UINT64_DOUBLE, + Overload.Comparison.GREATER_DOUBLE_UINT64), + GREATER_EQUALS( + Operator.GREATER_EQUALS, + Overload.Comparison.GREATER_EQUALS_BOOL, + Overload.Comparison.GREATER_EQUALS_INT64, + Overload.Comparison.GREATER_EQUALS_UINT64, + Overload.Comparison.GREATER_EQUALS_DOUBLE, + Overload.Comparison.GREATER_EQUALS_STRING, + Overload.Comparison.GREATER_EQUALS_BYTES, + Overload.Comparison.GREATER_EQUALS_TIMESTAMP, + Overload.Comparison.GREATER_EQUALS_DURATION, + Overload.Comparison.GREATER_EQUALS_INT64_UINT64, + Overload.Comparison.GREATER_EQUALS_UINT64_INT64, + Overload.Comparison.GREATER_EQUALS_INT64_DOUBLE, + Overload.Comparison.GREATER_EQUALS_DOUBLE_INT64, + Overload.Comparison.GREATER_EQUALS_UINT64_DOUBLE, + Overload.Comparison.GREATER_EQUALS_DOUBLE_UINT64), + ; + + private final String functionName; + private final CelFunctionDecl celFunctionDecl; + private final ImmutableSet standardOverloads; + private final boolean isDeprecated; + + /** Container class for CEL standard function overloads. */ + public static final class Overload { + + /** + * Overloads for internal functions that may have been rewritten by macros (ex: @in), or those + * used for special purposes (comprehensions, type denotations etc). + */ + public enum InternalOperator implements StandardOverload { + IN_LIST( + CelOverloadDecl.newGlobalOverload( + "in_list", "list membership", SimpleType.BOOL, TYPE_PARAM_A, LIST_OF_A)), + IN_MAP( + CelOverloadDecl.newGlobalOverload( + "in_map", "map key membership", SimpleType.BOOL, TYPE_PARAM_A, MAP_OF_AB)), + NOT_STRICTLY_FALSE( + CelOverloadDecl.newGlobalOverload( + "not_strictly_false", + "false if argument is false, true otherwise (including errors and unknowns)", + SimpleType.BOOL, + SimpleType.BOOL)), + TYPE( + CelOverloadDecl.newGlobalOverload( + "type", "returns type of value", TypeType.create(TYPE_PARAM_A), TYPE_PARAM_A)), + ; + + private final CelOverloadDecl celOverloadDecl; + + InternalOperator(CelOverloadDecl overloadDecl) { + this.celOverloadDecl = overloadDecl; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + } + + /** Overloads for logical operators that return a bool as a result. */ + public enum BooleanOperator implements StandardOverload { + CONDITIONAL( + CelOverloadDecl.newGlobalOverload( + "conditional", + "conditional", + TYPE_PARAM_A, + SimpleType.BOOL, + TYPE_PARAM_A, + TYPE_PARAM_A)), + LOGICAL_NOT( + CelOverloadDecl.newGlobalOverload( + "logical_not", "logical not", SimpleType.BOOL, SimpleType.BOOL)), + LOGICAL_OR( + CelOverloadDecl.newGlobalOverload( + "logical_or", "logical or", SimpleType.BOOL, SimpleType.BOOL, SimpleType.BOOL)), + LOGICAL_AND( + CelOverloadDecl.newGlobalOverload( + "logical_and", "logical_and", SimpleType.BOOL, SimpleType.BOOL, SimpleType.BOOL)), + ; + + private final CelOverloadDecl celOverloadDecl; + + BooleanOperator(CelOverloadDecl overloadDecl) { + this.celOverloadDecl = overloadDecl; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + } + + /** Overloads for functions that test relations. */ + public enum Relation implements StandardOverload { + EQUALS( + CelOverloadDecl.newGlobalOverload( + "equals", "equality", SimpleType.BOOL, TYPE_PARAM_A, TYPE_PARAM_A)), + NOT_EQUALS( + CelOverloadDecl.newGlobalOverload( + "not_equals", "inequality", SimpleType.BOOL, TYPE_PARAM_A, TYPE_PARAM_A)), + ; + private final CelOverloadDecl celOverloadDecl; + + Relation(CelOverloadDecl overloadDecl) { + this.celOverloadDecl = overloadDecl; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + } + + /** Overloads for performing arithmetic operations. */ + public enum Arithmetic implements StandardOverload { + + // Add + ADD_STRING( + CelOverloadDecl.newGlobalOverload( + "add_string", + "string concatenation", + SimpleType.STRING, + SimpleType.STRING, + SimpleType.STRING)), + ADD_BYTES( + CelOverloadDecl.newGlobalOverload( + "add_bytes", + "bytes concatenation", + SimpleType.BYTES, + SimpleType.BYTES, + SimpleType.BYTES)), + ADD_LIST( + CelOverloadDecl.newGlobalOverload( + "add_list", "list concatenation", LIST_OF_A, LIST_OF_A, LIST_OF_A)), + ADD_TIMESTAMP_DURATION( + CelOverloadDecl.newGlobalOverload( + "add_timestamp_duration", + "arithmetic", + SimpleType.TIMESTAMP, + SimpleType.TIMESTAMP, + SimpleType.DURATION)), + ADD_DURATION_TIMESTAMP( + CelOverloadDecl.newGlobalOverload( + "add_duration_timestamp", + "arithmetic", + SimpleType.TIMESTAMP, + SimpleType.DURATION, + SimpleType.TIMESTAMP)), + ADD_DURATION_DURATION( + CelOverloadDecl.newGlobalOverload( + "add_duration_duration", + "arithmetic", + SimpleType.DURATION, + SimpleType.DURATION, + SimpleType.DURATION)), + ADD_INT64( + CelOverloadDecl.newGlobalOverload( + "add_int64", "arithmetic", SimpleType.INT, SimpleType.INT, SimpleType.INT)), + ADD_UINT64( + CelOverloadDecl.newGlobalOverload( + "add_uint64", "arithmetic", SimpleType.UINT, SimpleType.UINT, SimpleType.UINT)), + ADD_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "add_double", + "arithmetic", + SimpleType.DOUBLE, + SimpleType.DOUBLE, + SimpleType.DOUBLE)), + + // Subtract + SUBTRACT_INT64( + CelOverloadDecl.newGlobalOverload( + "subtract_int64", "arithmetic", SimpleType.INT, SimpleType.INT, SimpleType.INT)), + SUBTRACT_UINT64( + CelOverloadDecl.newGlobalOverload( + "subtract_uint64", + "arithmetic", + SimpleType.UINT, + SimpleType.UINT, + SimpleType.UINT)), + SUBTRACT_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "subtract_double", + "arithmetic", + SimpleType.DOUBLE, + SimpleType.DOUBLE, + SimpleType.DOUBLE)), + SUBTRACT_TIMESTAMP_TIMESTAMP( + CelOverloadDecl.newGlobalOverload( + "subtract_timestamp_timestamp", + "arithmetic", + SimpleType.DURATION, + SimpleType.TIMESTAMP, + SimpleType.TIMESTAMP)), + SUBTRACT_TIMESTAMP_DURATION( + CelOverloadDecl.newGlobalOverload( + "subtract_timestamp_duration", + "arithmetic", + SimpleType.TIMESTAMP, + SimpleType.TIMESTAMP, + SimpleType.DURATION)), + SUBTRACT_DURATION_DURATION( + CelOverloadDecl.newGlobalOverload( + "subtract_duration_duration", + "arithmetic", + SimpleType.DURATION, + SimpleType.DURATION, + SimpleType.DURATION)), + + // Multiply + MULTIPLY_INT64( + CelOverloadDecl.newGlobalOverload( + "multiply_int64", "arithmetic", SimpleType.INT, SimpleType.INT, SimpleType.INT)), + MULTIPLY_UINT64( + CelOverloadDecl.newGlobalOverload( + "multiply_uint64", + "arithmetic", + SimpleType.UINT, + SimpleType.UINT, + SimpleType.UINT)), + MULTIPLY_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "multiply_double", + "arithmetic", + SimpleType.DOUBLE, + SimpleType.DOUBLE, + SimpleType.DOUBLE)), + + // Divide + DIVIDE_INT64( + CelOverloadDecl.newGlobalOverload( + "divide_int64", "arithmetic", SimpleType.INT, SimpleType.INT, SimpleType.INT)), + DIVIDE_UINT64( + CelOverloadDecl.newGlobalOverload( + "divide_uint64", "arithmetic", SimpleType.UINT, SimpleType.UINT, SimpleType.UINT)), + DIVIDE_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "divide_double", + "arithmetic", + SimpleType.DOUBLE, + SimpleType.DOUBLE, + SimpleType.DOUBLE)), + + // Modulo + MODULO_INT64( + CelOverloadDecl.newGlobalOverload( + "modulo_int64", "arithmetic", SimpleType.INT, SimpleType.INT, SimpleType.INT)), + MODULO_UINT64( + CelOverloadDecl.newGlobalOverload( + "modulo_uint64", "arithmetic", SimpleType.UINT, SimpleType.UINT, SimpleType.UINT)), + NEGATE_INT64( + CelOverloadDecl.newGlobalOverload( + "negate_int64", "negation", SimpleType.INT, SimpleType.INT)), + NEGATE_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "negate_double", "negation", SimpleType.DOUBLE, SimpleType.DOUBLE)), + ; + private final CelOverloadDecl celOverloadDecl; + + Arithmetic(CelOverloadDecl overloadDecl) { + this.celOverloadDecl = overloadDecl; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + } + + /** Overloads for indexing a list or a map. */ + public enum Index implements StandardOverload { + INDEX_LIST( + CelOverloadDecl.newGlobalOverload( + "index_list", "list indexing", TYPE_PARAM_A, LIST_OF_A, SimpleType.INT)), + INDEX_MAP( + CelOverloadDecl.newGlobalOverload( + "index_map", "map indexing", TYPE_PARAM_B, MAP_OF_AB, TYPE_PARAM_A)), + ; + private final CelOverloadDecl celOverloadDecl; + + Index(CelOverloadDecl overloadDecl) { + this.celOverloadDecl = overloadDecl; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + } + + /** Overloads for retrieving the size of a literal or a collection. */ + public enum Size implements StandardOverload { + SIZE_STRING( + CelOverloadDecl.newGlobalOverload( + "size_string", "string length", SimpleType.INT, SimpleType.STRING)), + SIZE_BYTES( + CelOverloadDecl.newGlobalOverload( + "size_bytes", "bytes length", SimpleType.INT, SimpleType.BYTES)), + SIZE_LIST( + CelOverloadDecl.newGlobalOverload("size_list", "list size", SimpleType.INT, LIST_OF_A)), + SIZE_MAP( + CelOverloadDecl.newGlobalOverload("size_map", "map size", SimpleType.INT, MAP_OF_AB)), + STRING_SIZE( + CelOverloadDecl.newMemberOverload( + "string_size", "string length", SimpleType.INT, SimpleType.STRING)), + BYTES_SIZE( + CelOverloadDecl.newMemberOverload( + "bytes_size", "bytes length", SimpleType.INT, SimpleType.BYTES)), + LIST_SIZE( + CelOverloadDecl.newMemberOverload("list_size", "list size", SimpleType.INT, LIST_OF_A)), + MAP_SIZE( + CelOverloadDecl.newMemberOverload("map_size", "map size", SimpleType.INT, MAP_OF_AB)), + ; + + private final CelOverloadDecl celOverloadDecl; + + Size(CelOverloadDecl overloadDecl) { + this.celOverloadDecl = overloadDecl; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + } + + /** Overloads for performing type conversions. */ + public enum Conversions implements StandardOverload { + // Bool conversions + BOOL_TO_BOOL( + CelOverloadDecl.newGlobalOverload( + "bool_to_bool", "type conversion (identity)", SimpleType.BOOL, SimpleType.BOOL)), + STRING_TO_BOOL( + CelOverloadDecl.newGlobalOverload( + "string_to_bool", "type conversion", SimpleType.BOOL, SimpleType.STRING)), + + // Int conversions + INT64_TO_INT64( + CelOverloadDecl.newGlobalOverload( + "int64_to_int64", "type conversion (identity)", SimpleType.INT, SimpleType.INT)), + UINT64_TO_INT64( + CelOverloadDecl.newGlobalOverload( + "uint64_to_int64", "type conversion", SimpleType.INT, SimpleType.UINT)), + DOUBLE_TO_INT64( + CelOverloadDecl.newGlobalOverload( + "double_to_int64", "type conversion", SimpleType.INT, SimpleType.DOUBLE)), + STRING_TO_INT64( + CelOverloadDecl.newGlobalOverload( + "string_to_int64", "type conversion", SimpleType.INT, SimpleType.STRING)), + TIMESTAMP_TO_INT64( + CelOverloadDecl.newGlobalOverload( + "timestamp_to_int64", + "Convert timestamp to int64 in seconds since Unix epoch.", + SimpleType.INT, + SimpleType.TIMESTAMP)), + // Uint conversions + UINT64_TO_UINT64( + CelOverloadDecl.newGlobalOverload( + "uint64_to_uint64", + "type conversion (identity)", + SimpleType.UINT, + SimpleType.UINT)), + INT64_TO_UINT64( + CelOverloadDecl.newGlobalOverload( + "int64_to_uint64", "type conversion", SimpleType.UINT, SimpleType.INT)), + DOUBLE_TO_UINT64( + CelOverloadDecl.newGlobalOverload( + "double_to_uint64", "type conversion", SimpleType.UINT, SimpleType.DOUBLE)), + STRING_TO_UINT64( + CelOverloadDecl.newGlobalOverload( + "string_to_uint64", "type conversion", SimpleType.UINT, SimpleType.STRING)), + // Double conversions + DOUBLE_TO_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "double_to_double", + "type conversion (identity)", + SimpleType.DOUBLE, + SimpleType.DOUBLE)), + INT64_TO_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "int64_to_double", "type conversion", SimpleType.DOUBLE, SimpleType.INT)), + UINT64_TO_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "uint64_to_double", "type conversion", SimpleType.DOUBLE, SimpleType.UINT)), + STRING_TO_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "string_to_double", "type conversion", SimpleType.DOUBLE, SimpleType.STRING)), + // String conversions + STRING_TO_STRING( + CelOverloadDecl.newGlobalOverload( + "string_to_string", + "type conversion (identity)", + SimpleType.STRING, + SimpleType.STRING)), + INT64_TO_STRING( + CelOverloadDecl.newGlobalOverload( + "int64_to_string", "type conversion", SimpleType.STRING, SimpleType.INT)), + UINT64_TO_STRING( + CelOverloadDecl.newGlobalOverload( + "uint64_to_string", "type conversion", SimpleType.STRING, SimpleType.UINT)), + DOUBLE_TO_STRING( + CelOverloadDecl.newGlobalOverload( + "double_to_string", "type conversion", SimpleType.STRING, SimpleType.DOUBLE)), + BOOL_TO_STRING( + CelOverloadDecl.newGlobalOverload( + "bool_to_string", "type conversion", SimpleType.STRING, SimpleType.BOOL)), + BYTES_TO_STRING( + CelOverloadDecl.newGlobalOverload( + "bytes_to_string", "type conversion", SimpleType.STRING, SimpleType.BYTES)), + TIMESTAMP_TO_STRING( + CelOverloadDecl.newGlobalOverload( + "timestamp_to_string", "type_conversion", SimpleType.STRING, SimpleType.TIMESTAMP)), + DURATION_TO_STRING( + CelOverloadDecl.newGlobalOverload( + "duration_to_string", "type_conversion", SimpleType.STRING, SimpleType.DURATION)), + // Bytes conversions + BYTES_TO_BYTES( + CelOverloadDecl.newGlobalOverload( + "bytes_to_bytes", + "type conversion (identity)", + SimpleType.BYTES, + SimpleType.BYTES)), + STRING_TO_BYTES( + CelOverloadDecl.newGlobalOverload( + "string_to_bytes", "type conversion", SimpleType.BYTES, SimpleType.STRING)), + // Duration conversions + DURATION_TO_DURATION( + CelOverloadDecl.newGlobalOverload( + "duration_to_duration", + "type conversion (identity)", + SimpleType.DURATION, + SimpleType.DURATION)), + STRING_TO_DURATION( + CelOverloadDecl.newGlobalOverload( + "string_to_duration", + "type conversion, duration should be end with \"s\", which stands for seconds", + SimpleType.DURATION, + SimpleType.STRING)), + // Timestamp conversions + STRING_TO_TIMESTAMP( + CelOverloadDecl.newGlobalOverload( + "string_to_timestamp", + "Type conversion of strings to timestamps according to RFC3339. Example:" + + " \"1972-01-01T10:00:20.021-05:00\".", + SimpleType.TIMESTAMP, + SimpleType.STRING)), + TIMESTAMP_TO_TIMESTAMP( + CelOverloadDecl.newGlobalOverload( + "timestamp_to_timestamp", + "type conversion (identity)", + SimpleType.TIMESTAMP, + SimpleType.TIMESTAMP)), + INT64_TO_TIMESTAMP( + CelOverloadDecl.newGlobalOverload( + "int64_to_timestamp", + "Type conversion of integers as Unix epoch seconds to timestamps.", + SimpleType.TIMESTAMP, + SimpleType.INT)), + + // Dyn conversions + TO_DYN( + CelOverloadDecl.newGlobalOverload( + "to_dyn", "type conversion", SimpleType.DYN, TYPE_PARAM_A)), + ; + private final CelOverloadDecl celOverloadDecl; + + Conversions(CelOverloadDecl overloadDecl) { + this.celOverloadDecl = overloadDecl; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + } + + /** + * Overloads for functions performing string matching, such as regular expressions or contains + * check. + */ + public enum StringMatchers implements StandardOverload { + MATCHES( + CelOverloadDecl.newGlobalOverload( + "matches", + "matches first argument against regular expression in second argument", + SimpleType.BOOL, + SimpleType.STRING, + SimpleType.STRING)), + + MATCHES_STRING( + CelOverloadDecl.newMemberOverload( + "matches_string", + "matches the self argument against regular expression in first argument", + SimpleType.BOOL, + SimpleType.STRING, + SimpleType.STRING)), + + CONTAINS_STRING( + CelOverloadDecl.newMemberOverload( + "contains_string", + "tests whether the string operand contains the substring", + SimpleType.BOOL, + SimpleType.STRING, + SimpleType.STRING)), + + ENDS_WITH_STRING( + CelOverloadDecl.newMemberOverload( + "ends_with_string", + "tests whether the string operand ends with the suffix argument", + SimpleType.BOOL, + SimpleType.STRING, + SimpleType.STRING)), + + STARTS_WITH_STRING( + CelOverloadDecl.newMemberOverload( + "starts_with_string", + "tests whether the string operand starts with the prefix argument", + SimpleType.BOOL, + SimpleType.STRING, + SimpleType.STRING)), + ; + private final CelOverloadDecl celOverloadDecl; + + StringMatchers(CelOverloadDecl overloadDecl) { + this.celOverloadDecl = overloadDecl; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + } + + /** Overloads for functions performing date/time operations. */ + public enum DateTime implements StandardOverload { + TIMESTAMP_TO_YEAR( + CelOverloadDecl.newMemberOverload( + "timestamp_to_year", + "get year from the date in UTC", + SimpleType.INT, + SimpleType.TIMESTAMP)), + TIMESTAMP_TO_YEAR_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_year_with_tz", + "get year from the date with timezone", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + TIMESTAMP_TO_MONTH( + CelOverloadDecl.newMemberOverload( + "timestamp_to_month", + "get month from the date in UTC, 0-11", + SimpleType.INT, + SimpleType.TIMESTAMP)), + + TIMESTAMP_TO_MONTH_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_month_with_tz", + "get month from the date with timezone, 0-11", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + TIMESTAMP_TO_DAY_OF_YEAR( + CelOverloadDecl.newMemberOverload( + "timestamp_to_day_of_year", + "get day of year from the date in UTC, zero-based indexing", + SimpleType.INT, + SimpleType.TIMESTAMP)), + + TIMESTAMP_TO_DAY_OF_YEAR_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_day_of_year_with_tz", + "get day of year from the date with timezone, zero-based indexing", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + TIMESTAMP_TO_DAY_OF_MONTH( + CelOverloadDecl.newMemberOverload( + "timestamp_to_day_of_month", + "get day of month from the date in UTC, zero-based indexing", + SimpleType.INT, + SimpleType.TIMESTAMP)), + + TIMESTAMP_TO_DAY_OF_MONTH_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_day_of_month_with_tz", + "get day of month from the date with timezone, zero-based indexing", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + TIMESTAMP_TO_DAY_OF_MONTH_1_BASED( + CelOverloadDecl.newMemberOverload( + "timestamp_to_day_of_month_1_based", + "get day of month from the date in UTC, one-based indexing", + SimpleType.INT, + SimpleType.TIMESTAMP)), + TIMESTAMP_TO_DAY_OF_MONTH_1_BASED_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_day_of_month_1_based_with_tz", + "get day of month from the date with timezone, one-based indexing", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + TIMESTAMP_TO_DAY_OF_WEEK( + CelOverloadDecl.newMemberOverload( + "timestamp_to_day_of_week", + "get day of week from the date in UTC, zero-based, zero for Sunday", + SimpleType.INT, + SimpleType.TIMESTAMP)), + + TIMESTAMP_TO_DAY_OF_WEEK_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_day_of_week_with_tz", + "get day of week from the date with timezone, zero-based, zero for Sunday", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + TIMESTAMP_TO_HOURS( + CelOverloadDecl.newMemberOverload( + "timestamp_to_hours", + "get hours from the date in UTC, 0-23", + SimpleType.INT, + SimpleType.TIMESTAMP)), + + TIMESTAMP_TO_HOURS_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_hours_with_tz", + "get hours from the date with timezone, 0-23", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + DURATION_TO_HOURS( + CelOverloadDecl.newMemberOverload( + "duration_to_hours", + "get hours from duration", + SimpleType.INT, + SimpleType.DURATION)), + TIMESTAMP_TO_MINUTES( + CelOverloadDecl.newMemberOverload( + "timestamp_to_minutes", + "get minutes from the date in UTC, 0-59", + SimpleType.INT, + SimpleType.TIMESTAMP)), + + TIMESTAMP_TO_MINUTES_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_minutes_with_tz", + "get minutes from the date with timezone, 0-59", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + DURATION_TO_MINUTES( + CelOverloadDecl.newMemberOverload( + "duration_to_minutes", + "get minutes from duration", + SimpleType.INT, + SimpleType.DURATION)), + TIMESTAMP_TO_SECONDS( + CelOverloadDecl.newMemberOverload( + "timestamp_to_seconds", + "get seconds from the date in UTC, 0-59", + SimpleType.INT, + SimpleType.TIMESTAMP)), + + TIMESTAMP_TO_SECONDS_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_seconds_with_tz", + "get seconds from the date with timezone, 0-59", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + DURATION_TO_SECONDS( + CelOverloadDecl.newMemberOverload( + "duration_to_seconds", + "get seconds from duration", + SimpleType.INT, + SimpleType.DURATION)), + TIMESTAMP_TO_MILLISECONDS( + CelOverloadDecl.newMemberOverload( + "timestamp_to_milliseconds", + "get milliseconds from the date in UTC, 0-999", + SimpleType.INT, + SimpleType.TIMESTAMP)), + + TIMESTAMP_TO_MILLISECONDS_WITH_TZ( + CelOverloadDecl.newMemberOverload( + "timestamp_to_milliseconds_with_tz", + "get milliseconds from the date with timezone, 0-999", + SimpleType.INT, + SimpleType.TIMESTAMP, + SimpleType.STRING)), + + DURATION_TO_MILLISECONDS( + CelOverloadDecl.newMemberOverload( + "duration_to_milliseconds", + "milliseconds from duration, 0-999", + SimpleType.INT, + SimpleType.DURATION)), + ; + private final CelOverloadDecl celOverloadDecl; + + DateTime(CelOverloadDecl overloadDecl) { + this.celOverloadDecl = overloadDecl; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + } + + /** Overloads for performing numeric comparisons. */ + public enum Comparison implements StandardOverload { + // Less + LESS_BOOL( + CelOverloadDecl.newGlobalOverload( + "less_bool", "ordering", SimpleType.BOOL, SimpleType.BOOL, SimpleType.BOOL), + false), + LESS_INT64( + CelOverloadDecl.newGlobalOverload( + "less_int64", "ordering", SimpleType.BOOL, SimpleType.INT, SimpleType.INT), + false), + LESS_UINT64( + CelOverloadDecl.newGlobalOverload( + "less_uint64", "ordering", SimpleType.BOOL, SimpleType.UINT, SimpleType.UINT), + false), + LESS_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "less_double", "ordering", SimpleType.BOOL, SimpleType.DOUBLE, SimpleType.DOUBLE), + false), + LESS_STRING( + CelOverloadDecl.newGlobalOverload( + "less_string", "ordering", SimpleType.BOOL, SimpleType.STRING, SimpleType.STRING), + false), + LESS_BYTES( + CelOverloadDecl.newGlobalOverload( + "less_bytes", "ordering", SimpleType.BOOL, SimpleType.BYTES, SimpleType.BYTES), + false), + LESS_TIMESTAMP( + CelOverloadDecl.newGlobalOverload( + "less_timestamp", + "ordering", + SimpleType.BOOL, + SimpleType.TIMESTAMP, + SimpleType.TIMESTAMP), + false), + LESS_DURATION( + CelOverloadDecl.newGlobalOverload( + "less_duration", + "ordering", + SimpleType.BOOL, + SimpleType.DURATION, + SimpleType.DURATION), + false), + LESS_INT64_UINT64( + CelOverloadDecl.newGlobalOverload( + "less_int64_uint64", + "Compare a signed integer value to an unsigned integer value", + SimpleType.BOOL, + SimpleType.INT, + SimpleType.UINT), + true), + LESS_UINT64_INT64( + CelOverloadDecl.newGlobalOverload( + "less_uint64_int64", + "Compare an unsigned integer value to a signed integer value", + SimpleType.BOOL, + SimpleType.UINT, + SimpleType.INT), + true), + LESS_INT64_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "less_int64_double", + "Compare a signed integer value to a double value, coalesces the integer to a" + + " double", + SimpleType.BOOL, + SimpleType.INT, + SimpleType.DOUBLE), + true), + LESS_DOUBLE_INT64( + CelOverloadDecl.newGlobalOverload( + "less_double_int64", + "Compare a double value to a signed integer value, coalesces the integer to a" + + " double", + SimpleType.BOOL, + SimpleType.DOUBLE, + SimpleType.INT), + true), + LESS_UINT64_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "less_uint64_double", + "Compare an unsigned integer value to a double value, coalesces the unsigned" + + " integer to a double", + SimpleType.BOOL, + SimpleType.UINT, + SimpleType.DOUBLE), + true), + LESS_DOUBLE_UINT64( + CelOverloadDecl.newGlobalOverload( + "less_double_uint64", + "Compare a double value to an unsigned integer value, coalesces the unsigned" + + " integer to a double", + SimpleType.BOOL, + SimpleType.DOUBLE, + SimpleType.UINT), + true), + // Less Equals + LESS_EQUALS_BOOL( + Comparison.LESS_BOOL.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_BOOL + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + false), + LESS_EQUALS_INT64( + Comparison.LESS_INT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_INT64 + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + false), + LESS_EQUALS_UINT64( + Comparison.LESS_UINT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_UINT64 + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + false), + LESS_EQUALS_DOUBLE( + Comparison.LESS_DOUBLE.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_DOUBLE + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + false), + LESS_EQUALS_STRING( + Comparison.LESS_STRING.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_STRING + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + false), + LESS_EQUALS_BYTES( + Comparison.LESS_BYTES.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_BYTES + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + false), + LESS_EQUALS_TIMESTAMP( + Comparison.LESS_TIMESTAMP.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_TIMESTAMP + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + false), + LESS_EQUALS_DURATION( + Comparison.LESS_DURATION.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_DURATION + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + false), + LESS_EQUALS_INT64_UINT64( + Comparison.LESS_INT64_UINT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_INT64_UINT64 + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + true), + LESS_EQUALS_UINT64_INT64( + Comparison.LESS_UINT64_INT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_UINT64_INT64 + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + true), + LESS_EQUALS_INT64_DOUBLE( + Comparison.LESS_INT64_DOUBLE.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_INT64_DOUBLE + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + true), + LESS_EQUALS_DOUBLE_INT64( + Comparison.LESS_DOUBLE_INT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_DOUBLE_INT64 + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + true), + LESS_EQUALS_UINT64_DOUBLE( + Comparison.LESS_UINT64_DOUBLE.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_UINT64_DOUBLE + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + true), + LESS_EQUALS_DOUBLE_UINT64( + Comparison.LESS_DOUBLE_UINT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_DOUBLE_UINT64 + .celOverloadDecl + .overloadId() + .replace("less", "less_equals")) + .build(), + true), + + // Greater + GREATER_BOOL( + CelOverloadDecl.newGlobalOverload( + "greater_bool", "ordering", SimpleType.BOOL, SimpleType.BOOL, SimpleType.BOOL), + false), + GREATER_INT64( + CelOverloadDecl.newGlobalOverload( + "greater_int64", "ordering", SimpleType.BOOL, SimpleType.INT, SimpleType.INT), + false), + GREATER_UINT64( + CelOverloadDecl.newGlobalOverload( + "greater_uint64", "ordering", SimpleType.BOOL, SimpleType.UINT, SimpleType.UINT), + false), + GREATER_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "greater_double", + "ordering", + SimpleType.BOOL, + SimpleType.DOUBLE, + SimpleType.DOUBLE), + false), + GREATER_STRING( + CelOverloadDecl.newGlobalOverload( + "greater_string", + "ordering", + SimpleType.BOOL, + SimpleType.STRING, + SimpleType.STRING), + false), + GREATER_BYTES( + CelOverloadDecl.newGlobalOverload( + "greater_bytes", "ordering", SimpleType.BOOL, SimpleType.BYTES, SimpleType.BYTES), + false), + GREATER_TIMESTAMP( + CelOverloadDecl.newGlobalOverload( + "greater_timestamp", + "ordering", + SimpleType.BOOL, + SimpleType.TIMESTAMP, + SimpleType.TIMESTAMP), + false), + GREATER_DURATION( + CelOverloadDecl.newGlobalOverload( + "greater_duration", + "ordering", + SimpleType.BOOL, + SimpleType.DURATION, + SimpleType.DURATION), + false), + GREATER_INT64_UINT64( + CelOverloadDecl.newGlobalOverload( + "greater_int64_uint64", + "Compare a signed integer value to an unsigned integer value", + SimpleType.BOOL, + SimpleType.INT, + SimpleType.UINT), + true), + GREATER_UINT64_INT64( + CelOverloadDecl.newGlobalOverload( + "greater_uint64_int64", + "Compare an unsigned integer value to a signed integer value", + SimpleType.BOOL, + SimpleType.UINT, + SimpleType.INT), + true), + GREATER_INT64_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "greater_int64_double", + "Compare a signed integer value to a double value, coalesces the integer to a" + + " double", + SimpleType.BOOL, + SimpleType.INT, + SimpleType.DOUBLE), + true), + GREATER_DOUBLE_INT64( + CelOverloadDecl.newGlobalOverload( + "greater_double_int64", + "Compare a double value to a signed integer value, coalesces the integer to a" + + " double", + SimpleType.BOOL, + SimpleType.DOUBLE, + SimpleType.INT), + true), + GREATER_UINT64_DOUBLE( + CelOverloadDecl.newGlobalOverload( + "greater_uint64_double", + "Compare an unsigned integer value to a double value, coalesces the unsigned" + + " integer to a double", + SimpleType.BOOL, + SimpleType.UINT, + SimpleType.DOUBLE), + true), + GREATER_DOUBLE_UINT64( + CelOverloadDecl.newGlobalOverload( + "greater_double_uint64", + "Compare a double value to an unsigned integer value, coalesces the unsigned" + + " integer to a double", + SimpleType.BOOL, + SimpleType.DOUBLE, + SimpleType.UINT), + true), + + // Greater Equals + GREATER_EQUALS_BOOL( + Comparison.LESS_BOOL.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_BOOL + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + false), + GREATER_EQUALS_INT64( + Comparison.LESS_INT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_INT64 + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + false), + GREATER_EQUALS_UINT64( + Comparison.LESS_UINT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_UINT64 + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + false), + GREATER_EQUALS_DOUBLE( + Comparison.LESS_DOUBLE.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_DOUBLE + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + false), + GREATER_EQUALS_STRING( + Comparison.LESS_STRING.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_STRING + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + false), + GREATER_EQUALS_BYTES( + Comparison.LESS_BYTES.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_BYTES + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + false), + GREATER_EQUALS_TIMESTAMP( + Comparison.LESS_TIMESTAMP.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_TIMESTAMP + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + false), + GREATER_EQUALS_DURATION( + Comparison.LESS_DURATION.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_DURATION + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + false), + GREATER_EQUALS_INT64_UINT64( + Comparison.LESS_INT64_UINT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_INT64_UINT64 + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + true), + GREATER_EQUALS_UINT64_INT64( + Comparison.LESS_UINT64_INT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_UINT64_INT64 + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + true), + GREATER_EQUALS_INT64_DOUBLE( + Comparison.LESS_INT64_DOUBLE.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_INT64_DOUBLE + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + true), + GREATER_EQUALS_DOUBLE_INT64( + Comparison.LESS_DOUBLE_INT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_DOUBLE_INT64 + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + true), + GREATER_EQUALS_UINT64_DOUBLE( + Comparison.LESS_UINT64_DOUBLE.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_UINT64_DOUBLE + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + true), + GREATER_EQUALS_DOUBLE_UINT64( + Comparison.LESS_DOUBLE_UINT64.celOverloadDecl.toBuilder() + .setOverloadId( + Comparison.LESS_DOUBLE_UINT64 + .celOverloadDecl + .overloadId() + .replace("less", "greater_equals")) + .build(), + true), + ; + + private final CelOverloadDecl celOverloadDecl; + private final boolean isHeterogeneousComparison; + + Comparison(CelOverloadDecl overloadDecl, boolean isHeterogeneousComparison) { + this.celOverloadDecl = overloadDecl; + this.isHeterogeneousComparison = isHeterogeneousComparison; + } + + public boolean isHeterogeneousComparison() { + return isHeterogeneousComparison; + } + + @Override + public CelOverloadDecl celOverloadDecl() { + return this.celOverloadDecl; + } + + /** Finds a Comparison by its overload ID. */ + public static Optional fromOverloadId(String overloadId) { + for (Comparison c : values()) { + if (c.celOverloadDecl().overloadId().equals(overloadId)) { + return Optional.of(c); + } + } + return Optional.empty(); + } + } + + private Overload() {} + } + + /** Gets the declaration for this standard function. */ + private CelFunctionDecl withOverloads(Iterable overloads) { + return newCelFunctionDecl(functionName, ImmutableSet.copyOf(overloads)); + } + + public CelFunctionDecl functionDecl() { + return celFunctionDecl; + } + + public String functionName() { + return functionName; + } + + boolean isDeprecated() { + return isDeprecated; + } + + StandardFunction(Operator operator, StandardOverload... overloads) { + this(false, operator.getFunction(), overloads); + } + + StandardFunction(String functionName, StandardOverload... overloads) { + this(false, functionName, overloads); + } + + StandardFunction(boolean isDeprecated, String functionName, StandardOverload... overloads) { + this.isDeprecated = isDeprecated; + this.functionName = functionName; + this.standardOverloads = ImmutableSet.copyOf(overloads); + this.celFunctionDecl = newCelFunctionDecl(functionName, this.standardOverloads); + } + + private static CelFunctionDecl newCelFunctionDecl( + String functionName, ImmutableSet overloads) { + return CelFunctionDecl.newFunctionDeclaration( + functionName, + overloads.stream().map(StandardOverload::celOverloadDecl).collect(toImmutableSet())); + } + } + + /** Standard CEL identifiers. */ + public enum StandardIdentifier { + INT(newStandardIdentDecl(SimpleType.INT)), + UINT(newStandardIdentDecl(SimpleType.UINT)), + BOOL(newStandardIdentDecl(SimpleType.BOOL)), + DOUBLE(newStandardIdentDecl(SimpleType.DOUBLE)), + BYTES(newStandardIdentDecl(SimpleType.BYTES)), + STRING(newStandardIdentDecl(SimpleType.STRING)), + DYN(newStandardIdentDecl(SimpleType.DYN)), + TYPE(newStandardIdentDecl("type", SimpleType.DYN)), + NULL_TYPE(newStandardIdentDecl("null_type", SimpleType.NULL_TYPE)), + LIST(newStandardIdentDecl("list", ListType.create(SimpleType.DYN))), + MAP(newStandardIdentDecl("map", MapType.create(SimpleType.DYN, SimpleType.DYN))), + ; + + private static CelIdentDecl newStandardIdentDecl(CelType celType) { + return newStandardIdentDecl(CelTypes.format(celType), celType); + } + + private static CelIdentDecl newStandardIdentDecl(String identName, CelType celType) { + return CelIdentDecl.newBuilder() + .setName(identName) + .setType(TypeType.create(celType)) + .setDoc("type denotation") + .build(); + } + + private final CelIdentDecl identDecl; + + public CelIdentDecl identDecl() { + return identDecl; + } + + StandardIdentifier(CelIdentDecl identDecl) { + this.identDecl = identDecl; + } + } + + /** General interface for defining a standard function overload. */ + @Immutable + public interface StandardOverload { + CelOverloadDecl celOverloadDecl(); + } + + /** Set of all standard function names. */ + public static ImmutableSet getAllFunctionNames() { + return stream(StandardFunction.values()) + .filter(f -> !f.isDeprecated) + .map(f -> f.functionName) + .collect(toImmutableSet()); + } + + /** Builder for constructing the set of standard function/identifiers. */ + public static final class Builder { + + private ImmutableSet includeFunctions; + private ImmutableSet excludeFunctions; + private FunctionFilter functionFilter; + + private ImmutableSet includeIdentifiers; + private ImmutableSet excludeIdentifiers; + private IdentifierFilter identifierFilter; + + @CanIgnoreReturnValue + public Builder excludeFunctions(StandardFunction... functions) { + return excludeFunctions(ImmutableSet.copyOf(functions)); + } + + @CanIgnoreReturnValue + public Builder excludeFunctions(Iterable functions) { + this.excludeFunctions = checkNotNull(ImmutableSet.copyOf(functions)); + return this; + } + + @CanIgnoreReturnValue + public Builder includeFunctions(StandardFunction... functions) { + return includeFunctions(ImmutableSet.copyOf(functions)); + } + + @CanIgnoreReturnValue + public Builder includeFunctions(Iterable functions) { + this.includeFunctions = checkNotNull(ImmutableSet.copyOf(functions)); + return this; + } + + @CanIgnoreReturnValue + public Builder filterFunctions(FunctionFilter functionFilter) { + this.functionFilter = functionFilter; + return this; + } + + @CanIgnoreReturnValue + public Builder excludeIdentifiers(StandardIdentifier... identifiers) { + return excludeIdentifiers(ImmutableSet.copyOf(identifiers)); + } + + @CanIgnoreReturnValue + public Builder excludeIdentifiers(Iterable identifiers) { + this.excludeIdentifiers = checkNotNull(ImmutableSet.copyOf(identifiers)); + return this; + } + + @CanIgnoreReturnValue + public Builder includeIdentifiers(StandardIdentifier... identifiers) { + return includeIdentifiers(ImmutableSet.copyOf(identifiers)); + } + + @CanIgnoreReturnValue + public Builder includeIdentifiers(Iterable identifiers) { + this.includeIdentifiers = checkNotNull(ImmutableSet.copyOf(identifiers)); + return this; + } + + @CanIgnoreReturnValue + public Builder filterIdentifiers(IdentifierFilter identifierFilter) { + this.identifierFilter = identifierFilter; + return this; + } + + private static void assertOneSettingIsSet( + boolean a, boolean b, boolean c, String errorMessage) { + int count = 0; + if (a) { + count++; + } + if (b) { + count++; + } + if (c) { + count++; + } + + if (count > 1) { + throw new IllegalArgumentException(errorMessage); + } + } + + public CelStandardDeclarations build() { + boolean hasIncludeFunctions = !this.includeFunctions.isEmpty(); + boolean hasExcludeFunctions = !this.excludeFunctions.isEmpty(); + boolean hasFilterFunction = this.functionFilter != null; + assertOneSettingIsSet( + hasIncludeFunctions, + hasExcludeFunctions, + hasFilterFunction, + "You may only populate one of the following builder methods: includeFunctions," + + " excludeFunctions or filterFunctions"); + boolean hasIncludeIdentifiers = !this.includeIdentifiers.isEmpty(); + boolean hasExcludeIdentifiers = !this.excludeIdentifiers.isEmpty(); + boolean hasIdentifierFilter = this.identifierFilter != null; + assertOneSettingIsSet( + hasIncludeIdentifiers, + hasExcludeIdentifiers, + hasIdentifierFilter, + "You may only populate one of the following builder methods: includeIdentifiers," + + " excludeIdentifiers or filterIdentifiers"); + + ImmutableSet.Builder functionDeclBuilder = ImmutableSet.builder(); + for (StandardFunction standardFunction : StandardFunction.values()) { + if (hasIncludeFunctions) { + if (this.includeFunctions.contains(standardFunction)) { + functionDeclBuilder.add(standardFunction.celFunctionDecl); + } + continue; + } + if (hasExcludeFunctions) { + if (!this.excludeFunctions.contains(standardFunction)) { + functionDeclBuilder.add(standardFunction.celFunctionDecl); + } + continue; + } + if (hasFilterFunction) { + ImmutableSet.Builder overloadBuilder = ImmutableSet.builder(); + for (StandardOverload standardOverload : standardFunction.standardOverloads) { + boolean includeOverload = functionFilter.include(standardFunction, standardOverload); + if (includeOverload) { + overloadBuilder.add(standardOverload); + } + } + + ImmutableSet overloads = overloadBuilder.build(); + if (!overloads.isEmpty()) { + functionDeclBuilder.add(standardFunction.withOverloads(overloadBuilder.build())); + } + continue; + } + + functionDeclBuilder.add(standardFunction.celFunctionDecl); + } + + ImmutableSet.Builder identBuilder = ImmutableSet.builder(); + for (StandardIdentifier standardIdentifier : StandardIdentifier.values()) { + if (hasIncludeIdentifiers) { + if (this.includeIdentifiers.contains(standardIdentifier)) { + identBuilder.add(standardIdentifier.identDecl); + } + continue; + } + + if (hasExcludeIdentifiers) { + if (!this.excludeIdentifiers.contains(standardIdentifier)) { + identBuilder.add(standardIdentifier.identDecl); + } + continue; + } + + if (hasIdentifierFilter) { + boolean includeIdent = identifierFilter.include(standardIdentifier); + if (includeIdent) { + identBuilder.add(standardIdentifier.identDecl); + } + continue; + } + + identBuilder.add(standardIdentifier.identDecl); + } + + return new CelStandardDeclarations(functionDeclBuilder.build(), identBuilder.build()); + } + + private Builder() { + this.includeFunctions = ImmutableSet.of(); + this.excludeFunctions = ImmutableSet.of(); + this.includeIdentifiers = ImmutableSet.of(); + this.excludeIdentifiers = ImmutableSet.of(); + } + + /** + * Functional interface for filtering standard functions. Returning true in the callback will + * include the function in the environment. + */ + @FunctionalInterface + public interface FunctionFilter { + boolean include(StandardFunction standardFunction, StandardOverload standardOverload); + } + + /** + * Functional interface for filtering standard identifiers. Returning true in the callback will + * include the identifier in the environment. + */ + @FunctionalInterface + public interface IdentifierFilter { + boolean include(StandardIdentifier standardIdentifier); + } + } + + public static Builder newBuilder() { + return new Builder(); + } + + ImmutableSet functionDecls() { + return celFunctionDecls; + } + + ImmutableSet identifierDecls() { + return celIdentDecls; + } + + private CelStandardDeclarations( + ImmutableSet celFunctionDecls, ImmutableSet celIdentDecls) { + this.celFunctionDecls = celFunctionDecls; + this.celIdentDecls = celIdentDecls; + } +} diff --git a/checker/src/main/java/dev/cel/checker/DescriptorTypeProvider.java b/checker/src/main/java/dev/cel/checker/DescriptorTypeProvider.java new file mode 100644 index 000000000..b5f849d50 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/DescriptorTypeProvider.java @@ -0,0 +1,539 @@ +// Copyright 2023 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.checker; + +import dev.cel.expr.Type; +import com.google.auto.value.AutoValue; +import com.google.common.base.Ascii; +import com.google.common.base.Joiner; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.DescriptorProtos.FieldDescriptorProto; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.EnumDescriptor; +import com.google.protobuf.Descriptors.EnumValueDescriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.Descriptors.OneofDescriptor; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.FileDescriptorSetConverter; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import org.jspecify.annotations.Nullable; + +/** + * The {@code DescriptorTypeProvider} provides type information for one or more {@link Descriptor} + * instances of proto messages. + * + *

TODO: Unify implementation across the runtime (i.e: DescriptorMessageProvider) + * and the compilation. This class can likely be eliminated as part of the work. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public class DescriptorTypeProvider implements TypeProvider { + + @SuppressWarnings("Immutable") + private final SymbolTable symbolTable; + + /** Constructs the empty provider, which will resolve nothing. */ + public DescriptorTypeProvider() { + this(new ArrayList()); + } + + /** + * Constructs a provider based on the given file descriptor set proto, as it is emitted by the + * protocol compiler. + */ + public DescriptorTypeProvider(FileDescriptorSet descriptorSet) { + this(FileDescriptorSetConverter.convert(descriptorSet)); + } + + public DescriptorTypeProvider(Collection fileDescriptors) { + this.symbolTable = new SymbolTable(ImmutableList.copyOf(fileDescriptors)); + } + + public DescriptorTypeProvider(Iterable descriptors) { + this.symbolTable = new SymbolTable(ImmutableList.copyOf(descriptors)); + } + + @Override + public @Nullable Type lookupType(String typeName) { + TypeDef typeDef = lookupMessageTypeDef(typeName); + return typeDef != null ? Types.create(Types.createMessage(typeDef.name())) : null; + } + + @Override + public @Nullable Integer lookupEnumValue(String enumName) { + int dot = enumName.lastIndexOf('.'); + if (dot > 0) { + String enumTypeName = enumName.substring(0, dot); + String enumValueName = enumName.substring(dot + 1); + TypeDef typeDef = symbolTable.lookupTypeDef(enumTypeName); + if (typeDef != null && typeDef.isEnum()) { + EnumValueDef enumValueDef = typeDef.findEnumValue(enumValueName); + if (enumValueDef != null) { + return enumValueDef.value(); + } + } + } + return null; + } + + @Override + public @Nullable FieldType lookupFieldType(Type type, String fieldName) { + TypeDef messageTypeDef = lookupMessageTypeDef(type.getMessageType()); + if (messageTypeDef == null) { + return null; + } + FieldDef fieldDef = messageTypeDef.lookupField(fieldName); + if (fieldDef == null) { + return null; + } + return FieldType.of(fieldDefToType(fieldDef)); + } + + @Override + public @Nullable ImmutableSet lookupFieldNames(Type type) { + if (type.getTypeKindCase() != Type.TypeKindCase.MESSAGE_TYPE) { + return null; + } + TypeDef messageTypeDef = lookupMessageTypeDef(type.getMessageType()); + if (messageTypeDef == null) { + return null; + } + ImmutableSet.Builder fields = ImmutableSet.builder(); + for (FieldDef fieldDef : messageTypeDef.fields()) { + fields.add(fieldDef.name()); + } + return fields.build(); + } + + @Override + public @Nullable ExtensionFieldType lookupExtensionType(String extensionName) { + return symbolTable.lookupExtension(extensionName); + } + + private @Nullable TypeDef lookupMessageTypeDef(String typeName) { + TypeDef typeDef = symbolTable.lookupTypeDef(typeName); + return (typeDef != null && typeDef.isMessage()) ? typeDef : null; + } + + private static Type fieldDefToType(FieldDef fieldDef) { + if (fieldDef.isMap()) { + return Types.createMap( + typeDefToType(fieldDef.mapEntryType().keyType()), + typeDefToType(fieldDef.mapEntryType().valueType())); + } + if (fieldDef.repeated()) { + return Types.createList(typeDefToType(fieldDef.type())); + } + return typeDefToType(fieldDef.type()); + } + + private static Type typeDefToType(TypeDef typeDef) { + if (typeDef.isMessage()) { + if (Types.WELL_KNOWN_TYPE_MAP.containsKey(typeDef.name())) { + return Types.WELL_KNOWN_TYPE_MAP.get(typeDef.name()); + } + return Types.createMessage(typeDef.name()); + } + if (Types.PRIMITIVE_TYPE_MAP.containsKey(typeDef.protoType())) { + return Types.PRIMITIVE_TYPE_MAP.get(typeDef.protoType()); + } + if (typeDef.isEnum()) { + return Types.INT64; + } + throw new IllegalArgumentException("unexpected typeDef: " + typeDef); + } + + /** + * Helper class to construct a symbol table for messages, enums, and their respective + * declarations. + * + *

The symbol table is built from the eagerly and is not a pure representation of Proto, but + * rather just enough of one to serve the needs of CEL. + */ + protected static class SymbolTable { + + private final ImmutableMap typeMap; + private final ImmutableMap extensionMap; + + public SymbolTable(Iterable fileDescriptors) { + Set processedFiles = new HashSet<>(); + Map typeMap = new HashMap<>(); + Map extensionMap = new HashMap<>(); + for (FileDescriptor fileDescriptor : fileDescriptors) { + // Message descriptors may depend on enums present within the file where they are declared. + // Be certain to process the file descriptor holding the message rather than just the + // descriptor for the message. + if (processedFiles.add(fileDescriptor.getFullName())) { + for (Descriptor messageDescriptor : fileDescriptor.getMessageTypes()) { + buildTypeDef(messageDescriptor, typeMap); + } + for (EnumDescriptor enumDescriptor : fileDescriptor.getEnumTypes()) { + buildTypeDef(enumDescriptor, typeMap); + } + for (FieldDescriptor extensionDescriptor : fileDescriptor.getExtensions()) { + FieldDef field = buildFieldDef(extensionDescriptor, typeMap); + if (field != null) { + extensionMap.put( + extensionDescriptor.getFullName(), + ExtensionFieldType.of( + fieldDefToType(field), + Types.createMessage(extensionDescriptor.getContainingType().getFullName()))); + } + } + } + } + this.typeMap = ImmutableMap.copyOf(typeMap); + this.extensionMap = ImmutableMap.copyOf(extensionMap); + } + + public SymbolTable(List descriptors) { + this(Iterables.transform(descriptors, Descriptor::getFile)); + } + + /** Find a {@link TypeDef} by qualified {@code typeName}. */ + private @Nullable TypeDef lookupTypeDef(String typeName) { + // In proto-land it is common to prefix the type-name with a dot. Generally, the dot is + // stripped prior to type resolution. + typeName = typeName.startsWith(".") ? typeName.substring(1) : typeName; + return typeMap.get(typeName); + } + + private @Nullable ExtensionFieldType lookupExtension(String extensionName) { + extensionName = extensionName.startsWith(".") ? extensionName.substring(1) : extensionName; + return extensionMap.get(extensionName); + } + + /** Build a message {@link TypeDef}. */ + @CanIgnoreReturnValue + private TypeDef buildTypeDef(Descriptor descriptor, Map typeMap) { + // If the type has already been resolved, return it. This should account for fields which + // refer to the type of the message being defined. + String typeName = descriptor.getFullName(); + if (typeMap.containsKey(typeName)) { + return typeMap.get(typeName); + } + + // Initialize the type entry since types can be nested. + Set fields = new HashSet<>(); + TypeDef typeDef = TypeDef.ofMessage(typeName, fields); + typeMap.put(typeName, typeDef); + + // Build the type definitions for nested types and enums. + for (EnumDescriptor enumDescriptor : descriptor.getEnumTypes()) { + buildTypeDef(enumDescriptor, typeMap); + } + for (Descriptor nested : descriptor.getNestedTypes()) { + buildTypeDef(nested, typeMap); + } + + // Populate the typeDef fields set from fields and one-of fields. + // This is somewhat dirty in that it modifies a value within the typeMap; however, + // unavoidable due to the recursive nature of proto field definitions. + for (FieldDescriptor fieldDescriptor : descriptor.getFields()) { + FieldDef field = buildFieldDef(fieldDescriptor, typeMap); + if (field != null) { + fields.add(field); + } + } + for (OneofDescriptor oneof : descriptor.getOneofs()) { + for (FieldDescriptor oneofFieldDescriptor : oneof.getFields()) { + FieldDef field = buildFieldDef(oneofFieldDescriptor, typeMap); + if (field != null) { + fields.add(field); + } + } + } + return typeDef; + } + + /** Build an enum {@link TypeDef}. */ + @CanIgnoreReturnValue + private TypeDef buildTypeDef(EnumDescriptor descriptor, Map typeMap) { + String typeName = descriptor.getFullName(); + if (typeMap.containsKey(typeName)) { + return typeMap.get(typeName); + } + Set enumValues = new HashSet<>(); + // + TypeDef typeDef = TypeDef.ofEnum(typeName, enumValues); + typeMap.put(typeName, typeDef); + for (EnumValueDescriptor enumValue : descriptor.getValues()) { + enumValues.add(EnumValueDef.of(enumValue.getName(), enumValue.getNumber())); + } + return typeDef; + } + + /** Build a {@link FieldDef}. Null if the field type is not-supported, i.e. proto groups. */ + private @Nullable FieldDef buildFieldDef( + FieldDescriptor fieldDescriptor, Map typeMap) { + String fieldName = fieldDescriptor.getName(); + boolean repeated = fieldDescriptor.isRepeated(); + switch (fieldDescriptor.getType()) { + case GROUP: + case MESSAGE: + if (fieldDescriptor.isMapField()) { + FieldDef keyField = + buildFieldDef(fieldDescriptor.getMessageType().getFields().get(0), typeMap); + FieldDef valueField = + buildFieldDef(fieldDescriptor.getMessageType().getFields().get(1), typeMap); + if (keyField != null && valueField != null) { + return FieldDef.of(fieldName, MapEntryDef.of(keyField.type(), valueField.type())); + } + // Either the key or field was an unsupported field type. + return null; + } + TypeDef messageDef = buildTypeDef(fieldDescriptor.getMessageType(), typeMap); + return FieldDef.of(fieldName, messageDef, repeated); + case ENUM: + TypeDef enumDef = buildTypeDef(fieldDescriptor.getEnumType(), typeMap); + return FieldDef.of(fieldName, enumDef, repeated); + case DOUBLE: + case FLOAT: + case FIXED32: + case FIXED64: + case INT32: + case INT64: + case SINT32: + case SINT64: + case SFIXED32: + case SFIXED64: + case UINT32: + case UINT64: + case BOOL: + case STRING: + case BYTES: + TypeDef primitiveDef = TypeDef.of(fieldDescriptor.toProto().getType()); + return FieldDef.of(fieldName, primitiveDef, repeated); + } + // Unsupported types yield a null type resolution. + return null; + } + } + + /** Value object for a proto-based primitive, message, or enum definition. */ + @AutoValue + protected abstract static class TypeDef { + + /** The qualified name of the message or enum. */ + public abstract String name(); + + /** The proto-based type enum for the type. */ + public abstract FieldDescriptorProto.Type protoType(); + + /** + * The set of {@link FieldDef} values for a message. Non-null when {@link #isMessage} is true. + */ + public abstract @Nullable Iterable fields(); + + /** + * The set of {@link EnumValueDef} values for an enum. Non-null when {@link #isEnum} is true. + */ + public abstract @Nullable Iterable enumValues(); + + /** Return whether the type is an enum. */ + public boolean isEnum() { + return enumValues() != null; + } + + /** Return whether the type is a message. */ + public boolean isMessage() { + return fields() != null; + } + + public @Nullable FieldDef lookupField(String name) { + for (FieldDef field : fields()) { + if (field.name().equals(name)) { + return field; + } + } + return null; + } + + public @Nullable EnumValueDef findEnumValue(String name) { + for (EnumValueDef enumValue : enumValues()) { + if (enumValue.name().equals(name)) { + return enumValue; + } + } + return null; + } + + @Override + public final boolean equals(Object other) { + // override the equality behavior as the recursive nature of proto fields can cause a stack + // overflow. + return other instanceof TypeDef && ((TypeDef) other).name().equals(name()); + } + + @Override + public final int hashCode() { + // override the hashcode to match the equality behavior. + return name().hashCode(); + } + + @Override + public final String toString() { + Joiner joiner = Joiner.on("\n"); + return String.format( + "%s {\n%s\n}", + name(), + isMessage() + ? joiner.join(fields()) + : isEnum() ? joiner.join(enumValues()) : Ascii.toLowerCase(protoType().name())); + } + + /** Create a {@code TypeDef} for a primitive type. */ + public static TypeDef of(FieldDescriptorProto.Type protoType) { + return new AutoValue_DescriptorTypeProvider_TypeDef( + Ascii.toLowerCase(protoType.name()), protoType, null, null); + } + + /** + * Create a {@code TypeDef} for a message type given the qualified message {@code name} in which + * it was written, and the {@code fields} declared within it. + */ + static TypeDef ofMessage(String name, Iterable fields) { + return new AutoValue_DescriptorTypeProvider_TypeDef( + name, FieldDescriptorProto.Type.TYPE_MESSAGE, fields, null); + } + + /** + * Create a {@code TypeDef} for an enum type given the qualified enum {@code name}, in which it + * was written, and the {@code enumValues} declared within it. + */ + static TypeDef ofEnum(String name, Iterable enumValues) { + return new AutoValue_DescriptorTypeProvider_TypeDef( + name, FieldDescriptorProto.Type.TYPE_ENUM, null, enumValues); + } + } + + /** + * Value object for a proto-based field definition. + * + *

Only one of the {@link #type} or {@link #mapEntryType} may be set. + */ + @AutoValue + protected abstract static class FieldDef { + + /** The field name. */ + public abstract String name(); + + /** The field {@code TypeDef}. Null if {@link #isMap} is true. */ + public abstract @Nullable TypeDef type(); + + /** The field {@code MapEntryDef}. Null if {@link #isMap} is false. */ + public abstract @Nullable MapEntryDef mapEntryType(); + + /** The field is repeated if it is a list or map type. */ + public abstract boolean repeated(); + + /** The field is a map if it has a non-null {@link #mapEntryType}. */ + public boolean isMap() { + return mapEntryType() != null; + } + + @Override + public final boolean equals(Object other) { + // Override equality testing as the nested nature of protos can cause a stack overflow here. + return other instanceof FieldDef && ((FieldDef) other).name().equals(name()); + } + + @Override + public final int hashCode() { + // Override hashCode to map to the equality constraint. + return name().hashCode(); + } + + @Override + public final String toString() { + return String.format( + "%s %s;", + isMap() + ? mapEntryType().toString() + : repeated() ? "repeated " + type().name() : type().name(), + name()); + } + + /** + * Create a {@code FieldDef} for a non-map field with a {@code name} and {@code type} which may + * be {@code repeated}/ + */ + static FieldDef of(String name, TypeDef type, boolean repeated) { + return new AutoValue_DescriptorTypeProvider_FieldDef(name, type, null, repeated); + } + + /** Create a {@code FieldDef} for a field with a {@code name} and {@code mapEntryType}. */ + static FieldDef of(String name, MapEntryDef mapEntryType) { + return new AutoValue_DescriptorTypeProvider_FieldDef(name, null, mapEntryType, true); + } + } + + /** Value object for an enum {@link #name} and {@link #value}. */ + @AutoValue + protected abstract static class EnumValueDef { + + /** The simple name of the enum value within a containing enum {@code TypeDef}. */ + public abstract String name(); + + /** The numeric value of the enum value. */ + public abstract int value(); + + @Override + public final String toString() { + return String.format("%s = %d", Ascii.toUpperCase(name()), value()); + } + + /** Construct a {@ EnumValueDef} from a {@code name} and numeric {@code value}. */ + static EnumValueDef of(String name, int value) { + return new AutoValue_DescriptorTypeProvider_EnumValueDef(name, value); + } + } + + /** Value object for Map entry {@code TypeDef} information. */ + @AutoValue + protected abstract static class MapEntryDef { + + /** The {@code TypeDef} of the map entry key. */ + public abstract TypeDef keyType(); + + /** The {@code TypeDef} of the map entry value. */ + public abstract TypeDef valueType(); + + @Override + public final String toString() { + return String.format("map<%s, %s>", keyType().name(), valueType().name()); + } + + /** Construct a {@code MapEntryDef} from a {@code keyType} and {@code valueType}. */ + static MapEntryDef of(TypeDef keyType, TypeDef valueType) { + return new AutoValue_DescriptorTypeProvider_MapEntryDef(keyType, valueType); + } + } +} diff --git a/checker/src/main/java/dev/cel/checker/Env.java b/checker/src/main/java/dev/cel/checker/Env.java new file mode 100644 index 000000000..75ed7cf1f --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/Env.java @@ -0,0 +1,1035 @@ +// Copyright 2023 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.checker; + +import dev.cel.expr.Constant; +import dev.cel.expr.Decl; +import dev.cel.expr.Decl.FunctionDecl.Overload; +import dev.cel.expr.Expr; +import dev.cel.expr.Type; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.checker.CelStandardDeclarations.StandardFunction.Overload.Comparison; +import dev.cel.checker.CelStandardDeclarations.StandardFunction.Overload.Conversions; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.annotations.Internal; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExprConverter; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelReference; +import dev.cel.common.internal.Errors; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypes; +import dev.cel.common.types.SimpleType; +import dev.cel.parser.CelStandardMacro; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** + * Environment used during checking of expressions. Provides name resolution and error reporting. + * + *

Note: the environment is not thread-safe. Create multiple envs from scratch for working with + * different threads. + * + *

CEL Library Internals. Do Not Use. CEL-Java users should leverage the Fluent APIs instead. See + * {@code CelCompilerFactory}. + */ +@Internal +public class Env { + + /** The top-most scope in the environment, for use with {@link #getDeclGroup(int)}. */ + public static final int ROOT_SCOPE = 0; + + /** An ident declaration to represent an error. */ + public static final CelIdentDecl ERROR_IDENT_DECL = + CelIdentDecl.newBuilder().setName("*error*").setType(SimpleType.ERROR).build(); + + /** A function declaration to represent an error. */ + public static final CelFunctionDecl ERROR_FUNCTION_DECL = + CelFunctionDecl.newBuilder().setName("*error*").build(); + + /** Type provider responsible for resolving CEL message references to strong types. */ + private final TypeProvider typeProvider; + + /** + * Stack of declaration groups where each entry in stack represents a scope capable of hinding + * declarations lower in the stack. + */ + private final ArrayList decls = new ArrayList<>(); + + /** A map from expression ids into references resolved for the overall tree so far. */ + private final Map referenceMap = new LinkedHashMap<>(); + + /** A map from expression ids into types resolved for the overall tree so far. */ + private final Map typeMap = new LinkedHashMap<>(); + + /** Object used for error reporting. */ + private final Errors errors; + + /** CEL Feature flags. */ + private final CelOptions celOptions; + + private static final CelOptions LEGACY_TYPE_CHECKER_OPTIONS = + CelOptions.newBuilder() + .disableCelStandardEquality(false) + .enableNamespacedDeclarations(false) + .build(); + + private Env( + Errors errors, TypeProvider typeProvider, DeclGroup declGroup, CelOptions celOptions) { + this.celOptions = celOptions; + this.errors = Preconditions.checkNotNull(errors); + this.typeProvider = Preconditions.checkNotNull(typeProvider); + this.decls.add(Preconditions.checkNotNull(declGroup)); + } + + /** + * @deprecated Do not use. This exists for compatibility reasons. Migrate to CEL-Java fluent APIs. + * See {@code CelCompilerFactory}. + */ + @Deprecated + public static Env unconfigured(Errors errors) { + return unconfigured(errors, LEGACY_TYPE_CHECKER_OPTIONS); + } + + /** + * Creates an unconfigured {@code Env} value without the standard CEL types, functions, and + * operators with a reference to the configured {@code celOptions}. + */ + @VisibleForTesting + static Env unconfigured(Errors errors, CelOptions celOptions) { + return unconfigured(errors, new DescriptorTypeProvider(), celOptions); + } + + /** + * Creates an unconfigured {@code Env} value without the standard CEL types, functions, and + * operators using a custom {@code typeProvider}. + * + * @deprecated Do not use. This exists for compatibility reasons. Migrate to CEL-Java fluent APIs. + * See {@code CelCompilerFactory}. + */ + @Deprecated + public static Env unconfigured(Errors errors, TypeProvider typeProvider, CelOptions celOptions) { + return new Env(errors, typeProvider, new DeclGroup(), celOptions); + } + + /** + * @deprecated Do not use. This exists for compatibility reasons. Migrate to CEL-Java fluent APIs. + * See {@code CelCompilerFactory}. + */ + @Deprecated + public static Env standard(Errors errors) { + return standard(errors, new DescriptorTypeProvider()); + } + + /** + * @deprecated Do not use. This exists for compatibility reasons. Migrate to CEL-Java fluent APIs. + * See {@code CelCompilerFactory}. + */ + @Deprecated + public static Env standard(Errors errors, TypeProvider typeProvider) { + return standard(errors, typeProvider, LEGACY_TYPE_CHECKER_OPTIONS); + } + + /** + * Creates an {@code Env} value configured with the standard types, functions, and operators, + * configured with a custom {@code typeProvider} and a reference to the {@code celOptions} to use + * within the environment. + * + *

Note: standard declarations are configured in an isolated scope, and may be shadowed by + * subsequent declarations with the same signature. + * + * @deprecated Do not use. This exists for compatibility reasons. Migrate to CEL-Java fluent APIs. + * See {@code CelCompilerFactory}. + */ + @Deprecated + public static Env standard(Errors errors, TypeProvider typeProvider, CelOptions celOptions) { + CelStandardDeclarations celStandardDeclaration = + CelStandardDeclarations.newBuilder() + .filterFunctions( + (function, overload) -> { + switch (function) { + case INT: + if (!celOptions.enableUnsignedLongs() + && overload.equals(Conversions.INT64_TO_INT64)) { + return false; + } + break; + case TIMESTAMP: + // TODO: Remove this flag guard once the feature has been + // auto-enabled. + if (!celOptions.enableTimestampEpoch() + && overload.equals(Conversions.INT64_TO_TIMESTAMP)) { + return false; + } + break; + default: + if (!celOptions.enableHeterogeneousNumericComparisons() + && overload instanceof Comparison) { + Comparison comparison = (Comparison) overload; + if (comparison.isHeterogeneousComparison()) { + return false; + } + } + break; + } + return true; + }) + .build(); + + return standard(celStandardDeclaration, errors, typeProvider, celOptions); + } + + public static Env standard( + CelStandardDeclarations celStandardDeclaration, + Errors errors, + TypeProvider typeProvider, + CelOptions celOptions) { + Env env = Env.unconfigured(errors, typeProvider, celOptions); + // Isolate the standard declarations into their own scope for forward compatibility. + celStandardDeclaration.functionDecls().forEach(env::add); + celStandardDeclaration.identifierDecls().forEach(env::add); + + env.enterScope(); + return env; + } + + /** Returns the current Errors object. */ + public Errors getErrorContext() { + return errors; + } + + /** Returns the {@code TypeProvider}. */ + public TypeProvider getTypeProvider() { + return typeProvider; + } + + /** + * Enters a new scope. All new declarations added to the environment exist only in this scope, and + * will shadow declarations of the same name in outer scopes. This includes overloads in outer + * scope (overloads from different scopes are not merged). + */ + public void enterScope() { + decls.add(new DeclGroup()); + } + + /** Exits a previously opened scope, forgetting all declarations created in this scope. */ + public void exitScope() { + Preconditions.checkState(!decls.isEmpty(), "Cannot exit top-level environment scope"); + decls.remove(decls.size() - 1); + } + + /** Return the current scope depth for the environment. */ + public int scopeDepth() { + return decls.size() - 1; + } + + /** Returns the top-most declaration scope. */ + public DeclGroup getDeclGroup() { + return Iterables.getLast(decls); + } + + /** + * Returns the {@code DeclGroup} at the given {@code scopeDepth}, where depth of {@code 0} + * represents root scope. + */ + public DeclGroup getDeclGroup(int scopeDepth) { + Preconditions.checkArgument( + scopeDepth <= scopeDepth() && scopeDepth >= 0, "Invalid scope depth."); + return decls.get(scopeDepth); + } + + /** Reset type and ref maps. This must be called before type checking an expression. */ + public void resetTypeAndRefMaps() { + typeMap.clear(); + referenceMap.clear(); + } + + /** Returns the reference map. */ + public Map getRefMap() { + return referenceMap; + } + + /** Returns the type map. */ + public Map getTypeMap() { + return typeMap; + } + + /** + * Returns the type associated with an expression by expression id. It's an error to call this + * method if the type is not present. + * + * @deprecated Do not use. Migrate to CEL-Java fluent APIs. + */ + @Deprecated + public Type getType(Expr expr) { + Preconditions.checkNotNull(expr); + CelExpr celExpr = CelExprConverter.fromExpr(expr); + CelType celType = + Preconditions.checkNotNull(typeMap.get(celExpr.id()), "expression has no type"); + return CelProtoTypes.celTypeToType(celType); + } + + /** + * Returns the type associated with a mutable expression by expression id. It's an error to call + * this method if the type is not present. + */ + CelType getType(CelMutableExpr expr) { + return Preconditions.checkNotNull(typeMap.get(expr.id()), "expression has no type"); + } + + /** + * Sets the type associated with a mutable expression by id. It's an error if the type is already + * set and is different than the provided one. Returns the expression parameter. + */ + @CanIgnoreReturnValue + CelMutableExpr setType(CelMutableExpr expr, CelType type) { + CelType oldType = typeMap.put(expr.id(), type); + Preconditions.checkState( + oldType == null || oldType.equals(type), + "expression already has a type which is incompatible.\n old: %s\n new: %s", + oldType, + type); + return expr; + } + + /** + * Sets the reference associated with a mutable expression. It's an error if the reference is + * already set and is different. + */ + void setRef(CelMutableExpr expr, CelReference reference) { + CelReference oldReference = referenceMap.put(expr.id(), reference); + Preconditions.checkState( + oldReference == null || oldReference.equals(reference), + "expression already has a reference which is incompatible"); + } + + /** + * Adds a declaration to the environment, based on the Decl proto. Will report errors if the + * declaration overlaps with an existing one, or clashes with a macro. + * + * @deprecated Migrate to the CEL-Java fluent APIs and leverage the publicly available native + * types (e.g: {@code CelCompilerFactory} accepts {@code CelFunctionDecl} and {@code + * CelVarDecl}). + */ + @CanIgnoreReturnValue + @Deprecated + public Env add(Decl decl) { + switch (decl.getDeclKindCase()) { + case IDENT: + CelIdentDecl.Builder identBuilder = + CelIdentDecl.newBuilder() + .setName(decl.getName()) + .setType(CelProtoTypes.typeToCelType(decl.getIdent().getType())) + // Note: Setting doc and constant value exists for compatibility reason. This should + // not be set by the users. + .setDoc(decl.getIdent().getDoc()); + if (decl.getIdent().hasValue()) { + identBuilder.setConstant( + CelExprConverter.exprConstantToCelConstant(decl.getIdent().getValue())); + } + return add(identBuilder.build()); + case FUNCTION: + ImmutableList.Builder overloadDeclBuilder = new ImmutableList.Builder<>(); + for (Overload overload : decl.getFunction().getOverloadsList()) { + overloadDeclBuilder.add(CelOverloadDecl.overloadToCelOverload(overload)); + } + return add( + CelFunctionDecl.newBuilder() + .setName(decl.getName()) + .addOverloads(overloadDeclBuilder.build()) + .build()); + default: + break; + } + return this; + } + + @CanIgnoreReturnValue + public Env add(CelFunctionDecl celFunctionDecl) { + return addFunction(sanitizeFunction(celFunctionDecl)); + } + + @CanIgnoreReturnValue + public Env add(CelIdentDecl celIdentDecl) { + return addIdent(sanitizeIdent(celIdentDecl)); + } + + /** + * Adds simple name declaration to the environment for a non-function. + * + * @deprecated Migrate to the CEL-Java fluent APIs and leverage the publicly available native + * types (e.g: {@code CelCompilerFactory} accepts {@code CelFunctionDecl} and {@code + * CelVarDecl}). + */ + @CanIgnoreReturnValue + @Deprecated + public Env add(String name, Type type) { + return add(CelIdentDecl.newIdentDeclaration(name, CelProtoTypes.typeToCelType(type))); + } + + /** + * Note: Used by legacy type-checker users + * + * @deprecated Use {@link #tryLookupCelFunction} instead. + */ + @Deprecated + public @Nullable Decl tryLookupFunction(String container, String name) { + CelFunctionDecl decl = tryLookupCelFunction(CelContainer.ofName(container), name); + if (decl == null) { + return null; + } + + return CelFunctionDecl.celFunctionDeclToDecl(decl); + } + + /** + * Try to lookup a function with the given {@code name} within a {@code container}. + * + *

For protos, the {@code container} may be a package or message name. The code tries to + * resolve the {@code name} first in the container, then within the container parent, and so on + * until the root package is reached. If {@code container} starts with {@code .}, the resolution + * is in the root container only. + * + *

Returns {@code null} if the function cannot be found. + */ + public @Nullable CelFunctionDecl tryLookupCelFunction(CelContainer container, String name) { + for (String cand : container.resolveCandidateNames(name)) { + // First determine whether we know this name already. + CelFunctionDecl decl = findFunctionDecl(cand); + if (decl != null) { + return decl; + } + } + return null; + } + + /** + * @deprecated Use {@link #tryLookupCelIdent} instead. + */ + @Deprecated + public @Nullable Decl tryLookupIdent(CelContainer container, String name) { + CelIdentDecl decl = tryLookupCelIdent(container, name); + if (decl == null) { + return null; + } + + return CelIdentDecl.celIdentToDecl(decl); + } + + /** + * Try to lookup an identifier with the given {@code name} within a {@code container}. + * + *

For protos, the {@code container} may be a package or message name. The code tries to + * resolve the {@code name} first in the container, then within the container parent, and so on + * until the root package is reached. If {@code container} starts with {@code .}, the resolution + * is in the root container only. + * + *

Returns {@code null} if the ident cannot be found. + */ + public @Nullable CelIdentDecl tryLookupCelIdent(CelContainer container, String name) { + // A name with a leading '.' always resolves in the root scope, bypassing local scopes. + if (!name.startsWith(".")) { + // Check if this is a qualified ident, or a field selection. + String simpleName = name; + int dotIndex = name.indexOf('.'); + if (dotIndex > 0) { + simpleName = name.substring(0, dotIndex); + } + + // Attempt to find the decl with just the ident name to account for shadowed variables. + CelIdentDecl decl = tryLookupCelIdentFromLocalScopes(simpleName); + if (decl != null) { + // Appears to be a field selection on a local. + // Return null instead of attempting to resolve qualified name at the root scope + return dotIndex > 0 ? null : decl; + } + } + + for (String cand : container.resolveCandidateNames(name)) { + CelIdentDecl decl = tryLookupCelIdent(cand); + if (decl != null) { + return decl; + } + } + + return null; + } + + private @Nullable CelIdentDecl tryLookupCelIdent(String cand) { + // First determine whether we know this name already. + CelIdentDecl decl = findIdentDecl(cand); + if (decl != null) { + return decl; + } + + // Next try to import the name as a reference to a message type. + // This is done via the type provider. + Optional type = typeProvider.lookupCelType(cand); + if (type.isPresent()) { + decl = CelIdentDecl.newIdentDeclaration(cand, type.get()); + decls.get(0).putIdent(decl); + return decl; + } + + // Next try to import this as an enum value by splitting the name in a type prefix and + // the enum inside. + Integer enumValue = typeProvider.lookupEnumValue(cand); + if (enumValue != null) { + decl = + CelIdentDecl.newBuilder() + .setName(cand) + .setType(SimpleType.INT) + .setConstant(CelConstant.ofValue(enumValue)) + .build(); + + decls.get(0).putIdent(decl); + return decl; + } + return null; + } + + /** + * Lookup a local identifier by name. This searches only comprehension scopes, bypassing standard + * environment or user-defined environment. + * + *

Returns {@code null} if not found in local scopes. + */ + @Nullable CelIdentDecl tryLookupCelIdentFromLocalScopes(String name) { + int firstUserSpaceScope = 2; + // Iterate from the top of the stack down to the first local scope. + // Note that: + // Scope 0: Standard environment + // Scope 1: User defined environment + // Scope 2 and onwards: comprehension scopes + for (int i = decls.size() - 1; i >= firstUserSpaceScope; i--) { + CelIdentDecl ident = decls.get(i).getIdent(name); + if (ident != null) { + return ident; + } + } + return null; + } + + /** + * Lookup a name like {@link #tryLookupCelIdent}, but report an error if the name is not found and + * return the {@link #ERROR_IDENT_DECL}. + */ + public CelIdentDecl lookupIdent(long exprId, int position, CelContainer container, String name) { + CelIdentDecl result = tryLookupCelIdent(container, name); + if (result == null) { + reportError( + exprId, + position, + "undeclared reference to '%s' (in container '%s')", + name, + container.name()); + return ERROR_IDENT_DECL; + } + return result; + } + + /** + * Lookup a name like {@link #tryLookupCelFunction} but report an error if the name is not found + * and return the {@link #ERROR_FUNCTION_DECL}. + */ + public CelFunctionDecl lookupFunction( + long exprId, int position, CelContainer container, String name) { + CelFunctionDecl result = tryLookupCelFunction(container, name); + if (result == null) { + reportError( + exprId, + position, + "undeclared reference to '%s' (in container '%s')", + name, + container.name()); + return ERROR_FUNCTION_DECL; + } + return result; + } + + /** + * Note: Used by legacy type-checker users + * + * @deprecated Use {@link #reportError(long, int, String, Object...) instead.} + */ + @Deprecated + public void reportError(int position, String message, Object... args) { + reportError(0L, position, message, args); + } + + /** Reports an error. */ + public void reportError(long exprId, int position, String message, Object... args) { + errors.reportError(exprId, position, message, args); + } + + boolean enableCompileTimeOverloadResolution() { + return celOptions.enableCompileTimeOverloadResolution(); + } + + boolean enableHomogeneousLiterals() { + return celOptions.enableHomogeneousLiterals(); + } + + boolean enableNamespacedDeclarations() { + return celOptions.enableNamespacedDeclarations(); + } + + /** Add an identifier {@code decl} to the environment. */ + @CanIgnoreReturnValue + private Env addIdent(CelIdentDecl celIdentDecl) { + CelIdentDecl current = getDeclGroup().getIdent(celIdentDecl.name()); + if (current == null) { + getDeclGroup().putIdent(celIdentDecl); + } else { + reportError( + /* exprId= */ 0, + /* position= */ 0, + "overlapping declaration name '%s' (type '%s' cannot be distinguished from '%s')", + celIdentDecl.name(), + CelTypes.format(current.type()), + CelTypes.format(celIdentDecl.type())); + } + return this; + } + + /** Add a function {@code decl} to the environment. */ + @CanIgnoreReturnValue + private Env addFunction(CelFunctionDecl decl) { + CelFunctionDecl current = getDeclGroup().getFunction(decl.name()); + CelFunctionDecl.Builder builder = + current != null ? current.toBuilder() : CelFunctionDecl.newBuilder().setName(decl.name()); + for (CelOverloadDecl overload : decl.overloads()) { + addOverload(builder, overload); + } + getDeclGroup().putFunction(builder.build()); + return this; + } + + /** + * Attempt to extend the declaration with a new overload. This reports an error if the overload + * overlaps with existing ones or with a macro. + */ + private void addOverload(CelFunctionDecl.Builder builder, CelOverloadDecl overload) { + // Compute the type of the overload with all type parameters replaced by DYN. + // We are using a property of Types.substitute which replaces all unbound type + // parameters by DYN. + ImmutableMap emptySubs = ImmutableMap.of(); + + CelType overloadFunction = + CelTypes.createFunctionType(overload.resultType(), overload.parameterTypes()); + CelType overloadTypeErased = Types.substitute(emptySubs, overloadFunction, true); + + // Loop over existing overloads to find any overlap. + for (CelOverloadDecl existing : builder.overloads()) { + CelType existingFunction = + CelTypes.createFunctionType(existing.resultType(), existing.parameterTypes()); + CelType existingTypeErased = Types.substitute(emptySubs, existingFunction, true); + boolean overlap = + Types.isAssignable(emptySubs, overloadTypeErased, existingTypeErased) != null + || Types.isAssignable(emptySubs, existingTypeErased, overloadTypeErased) != null; + if (overlap && existing.isInstanceFunction() == overload.isInstanceFunction()) { + reportError( + /* exprId= */ 0, + /* position= */ 0, + "overlapping overload for name '%s' (type '%s' cannot be distinguished from '%s')", + builder.name(), + CelTypes.format(existingFunction), + CelTypes.format(overloadFunction)); + return; + } + } + + // If this is a function, loop over macros to detect any clash. + for (CelStandardMacro macro : CelStandardMacro.STANDARD_MACROS) { + if (macro.getFunction().equals(builder.name()) + && macro.getDefinition().isReceiverStyle() == overload.isInstanceFunction() + && macro.getDefinition().getArgumentCount() == overload.parameterTypes().size()) { + reportError( + /* exprId= */ 0, + /* position= */ 0, + "overload for name '%s' with %s argument(s) overlaps with predefined macro", + builder.name(), + macro.getDefinition().getArgumentCount()); + return; + } + } + builder.addOverloads(overload); + } + + /** Search for the named identifier declaration. */ + private @Nullable CelIdentDecl findIdentDecl(String name) { + for (DeclGroup declGroup : Lists.reverse(decls)) { + CelIdentDecl ident = declGroup.getIdent(name); + if (ident != null) { + return ident; + } + } + return null; + } + + /** Search for the named function declaration. */ + private @Nullable CelFunctionDecl findFunctionDecl(String name) { + // Search bottom-up for the matching function declarations. + List functions = new ArrayList<>(); + for (DeclGroup declGroup : Lists.reverse(decls)) { + CelFunctionDecl function = declGroup.getFunction(name); + if (function != null) { + functions.add(function); + } + } + // If no functions have the declared name, return null. + if (functions.isEmpty()) { + return null; + } + // If only one function declaration has the specified name, return it. + if (functions.size() == 1) { + return functions.get(0); + } + // Otherwise form a composite view of the overloads, most specific first, as indicated by the + // bottom-up traversal order of the declaration scopes. + Map overloadSignatureMap = new HashMap<>(); + for (CelFunctionDecl function : functions) { + for (CelOverloadDecl overload : function.overloads()) { + // The input signature is enough to disambiguate overloads. When two or more functions in + // different scopes share the same signature, the function in the lowest scope will shadow + // its ancestors. + // + // Note: declaring a function with the same signature in the same scope is an error. + String overloadSignature = + TypeFormatter.formatFunction( + /* resultType= */ null, + overload.parameterTypes(), + overload.isInstanceFunction(), + /* typeParamToDyn= */ true); + overloadSignatureMap.putIfAbsent(overloadSignature, overload); + } + } + + return CelFunctionDecl.newBuilder() + .setName(name) + .addOverloads(overloadSignatureMap.values()) + .build(); + } + + /** + * A helper class for constructing identifier declarations. + * + * @deprecated Use {@code CelVarDecl#newBuilder()} instead. + */ + @Deprecated + public static final class IdentBuilder { + private final CelIdentDecl.Builder builder = CelIdentDecl.newBuilder(); + + /** Create an identifier builder. */ + public IdentBuilder(String name) { + builder.setName(Preconditions.checkNotNull(name)); + } + + /** Set the identifier type. */ + @CanIgnoreReturnValue + public IdentBuilder type(Type value) { + Preconditions.checkNotNull(value); + builder.setType(CelProtoTypes.typeToCelType(Preconditions.checkNotNull(value))); + return this; + } + + /** Set the identifier to a {@code Constant} value. */ + @CanIgnoreReturnValue + public IdentBuilder value(@Nullable Constant value) { + if (value == null) { + builder.clearConstant(); + } else { + builder.setConstant(CelExprConverter.exprConstantToCelConstant(value)); + } + return this; + } + + /** Set the documentation for the identifier. */ + @CanIgnoreReturnValue + public IdentBuilder doc(@Nullable String value) { + if (value == null) { + builder.setDoc(""); + } else { + builder.setDoc(value); + } + return this; + } + + /** Build the ident {@code Decl}. */ + public Decl build() { + return CelIdentDecl.celIdentToDecl(builder.build()); + } + } + + /** + * A helper class for building declarations. + * + * @deprecated Use {@link CelFunctionDecl#newBuilder()} instead. + */ + @Deprecated + public static final class FunctionBuilder { + + private final String name; + private final List overloads = new ArrayList<>(); + private final boolean isInstance; + + /** Create a global function builder. */ + public FunctionBuilder(String name) { + this(name, false); + } + + /** Create an instance function builder. */ + public FunctionBuilder(String name, boolean isInstance) { + this.name = Preconditions.checkNotNull(name); + this.isInstance = isInstance; + } + + /** + * Add the overloads of another function to this function, after replacing the overload id as + * specified. + */ + @CanIgnoreReturnValue + public FunctionBuilder sameAs(Decl func, String idPart, String idPartReplace) { + Preconditions.checkNotNull(func); + for (Overload overload : func.getFunction().getOverloadsList()) { + this.overloads.add( + CelOverloadDecl.overloadToCelOverload(overload).toBuilder() + .setOverloadId(overload.getOverloadId().replace(idPart, idPartReplace)) + .build()); + } + return this; + } + + /** Add an overload. */ + @CanIgnoreReturnValue + public FunctionBuilder add(String id, Type resultType, Type... argTypes) { + return add(id, resultType, ImmutableList.copyOf(argTypes)); + } + + /** Add an overload. */ + @CanIgnoreReturnValue + public FunctionBuilder add(String id, Type resultType, Iterable argTypes) { + ImmutableList.Builder argumentBuilder = new ImmutableList.Builder<>(); + for (Type type : argTypes) { + argumentBuilder.add(CelProtoTypes.typeToCelType(type)); + } + this.overloads.add( + CelOverloadDecl.newBuilder() + .setOverloadId(id) + .setResultType(CelProtoTypes.typeToCelType(resultType)) + .addParameterTypes(argumentBuilder.build()) + .setIsInstanceFunction(isInstance) + .build()); + return this; + } + + /** Add an overload, with type params. */ + @CanIgnoreReturnValue + public FunctionBuilder add( + String id, List typeParams, Type resultType, Type... argTypes) { + return add(id, typeParams, resultType, ImmutableList.copyOf(argTypes)); + } + + /** Add an overload, with type params. */ + @CanIgnoreReturnValue + public FunctionBuilder add( + String id, List typeParams, Type resultType, Iterable argTypes) { + ImmutableList.Builder argumentBuilder = new ImmutableList.Builder<>(); + for (Type type : argTypes) { + argumentBuilder.add(CelProtoTypes.typeToCelType(type)); + } + this.overloads.add( + CelOverloadDecl.newBuilder() + .setOverloadId(id) + .setResultType(CelProtoTypes.typeToCelType(resultType)) + .addParameterTypes(argumentBuilder.build()) + .setIsInstanceFunction(isInstance) + .build()); + return this; + } + + /** Adds documentation to the last added overload. */ + @CanIgnoreReturnValue + public FunctionBuilder doc(@Nullable String value) { + int current = this.overloads.size() - 1; + CelOverloadDecl.Builder builder = this.overloads.get(current).toBuilder(); + if (value == null) { + builder.setDoc(""); + } else { + builder.setDoc(value); + } + this.overloads.set(current, builder.build()); + return this; + } + + /** Build the function {@code Decl}. */ + @CheckReturnValue + public Decl build() { + return CelFunctionDecl.celFunctionDeclToDecl( + CelFunctionDecl.newBuilder().setName(name).addOverloads(overloads).build()); + } + } + + /** + * Object for managing a group of declarations within a scope. + * + *

Identifiers and functions can share the same declaration name, so a simple map will not + * suffice for tracking declaration overloads. + * + *

Whether a given {@code DeclGroup} is mutable or immutable depends on whether the maps + * supplied as input to the group are standard {@code Map} implementations or {@code ImmutableMap} + * implementations. The {DeclGroup#immutableCopy} method is provided as a convenience to make it + * easy to create an instance of the group which will honor the developer's intent. + */ + public static class DeclGroup { + + private final Map idents; + private final Map functions; + + /** Construct an empty {@code DeclGroup}. */ + public DeclGroup() { + this(new HashMap<>(), new HashMap<>()); + } + + /** Construct a new {@code DeclGroup} from the input {@code idents} and {@code functions}. */ + public DeclGroup(Map idents, Map functions) { + this.functions = functions; + this.idents = idents; + } + + /** + * Get an immutable map of the identifiers in the {@code DeclGroup} keyed by declaration name. + */ + public Map getIdents() { + return ImmutableMap.copyOf(idents); + } + + /** Get an immutable map of the functions in the {@code DeclGroup} keyed by declaration name. */ + public Map getFunctions() { + return ImmutableMap.copyOf(functions); + } + + /** Get an identifier declaration by {@code name}. Returns {@code null} if absent. */ + public @Nullable CelIdentDecl getIdent(String name) { + return idents.get(name); + } + + /** Put an identifier declaration into the {@code DeclGroup}. */ + public void putIdent(CelIdentDecl ident) { + idents.put(ident.name(), ident); + } + + /** Get a function declaration by {@code name}. Returns {@code null} if absent. */ + public @Nullable CelFunctionDecl getFunction(String name) { + return functions.get(name); + } + + /** Put a function declaration into the {@code DeclGroup}. */ + public void putFunction(CelFunctionDecl function) { + functions.put(function.name(), function); + } + + /** Create a copy of the {@code DeclGroup} with immutable identifier and function maps. */ + public DeclGroup immutableCopy() { + return new DeclGroup(getIdents(), getFunctions()); + } + } + + /** + * Sanitize the identifier declaration type making sure that proto-based message names are mapped + * to the appropriate CEL type. + */ + private static CelIdentDecl sanitizeIdent(CelIdentDecl decl) { + CelType type = decl.type(); + if (!isWellKnownType(type)) { + return decl; + } + + return CelIdentDecl.newIdentDeclaration(decl.name(), getWellKnownType(decl.type())); + } + + /** + * Sanitize the function declaration type making sure that proto-based message names appearing in + * the result or parameter types are mapped to the appropriate CEL types. + */ + private static CelFunctionDecl sanitizeFunction(CelFunctionDecl func) { + boolean needsSanitizing = false; + for (CelOverloadDecl o : func.overloads()) { + if (isWellKnownType(o.resultType())) { + needsSanitizing = true; + break; + } + for (CelType p : o.parameterTypes()) { + if (isWellKnownType(p)) { + needsSanitizing = true; + break; + } + } + } + if (!needsSanitizing) { + return func; + } + + CelFunctionDecl.Builder funcBuilder = func.toBuilder(); + ImmutableSet.Builder overloadsBuilder = new ImmutableSet.Builder<>(); + for (CelOverloadDecl overloadDecl : funcBuilder.overloads()) { + CelOverloadDecl.Builder overloadBuilder = overloadDecl.toBuilder(); + CelType resultType = overloadBuilder.build().resultType(); + if (isWellKnownType(resultType)) { + overloadBuilder.setResultType(getWellKnownType(resultType)); + } + + ImmutableList.Builder parameterTypeBuilder = ImmutableList.builder(); + for (CelType paramType : overloadBuilder.parameterTypes()) { + if (isWellKnownType(paramType)) { + parameterTypeBuilder.add(getWellKnownType(paramType)); + } else { + parameterTypeBuilder.add(paramType); + } + } + overloadBuilder.setParameterTypes(parameterTypeBuilder.build()); + overloadsBuilder.add(overloadBuilder.build()); + } + return funcBuilder.setOverloads(overloadsBuilder.build()).build(); + } + + static boolean isWellKnownType(CelType type) { + return type.kind() == CelKind.STRUCT && CelTypes.isWellKnownType(type.name()); + } + + static CelType getWellKnownType(CelType type) { + Preconditions.checkArgument(type.kind() == CelKind.STRUCT); + return CelTypes.getWellKnownCelType(type.name()).get(); + } +} diff --git a/checker/src/main/java/dev/cel/checker/ExprChecker.java b/checker/src/main/java/dev/cel/checker/ExprChecker.java new file mode 100644 index 000000000..e3ce99e67 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/ExprChecker.java @@ -0,0 +1,888 @@ +// Copyright 2023 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.checker; + +import static com.google.common.base.Preconditions.checkNotNull; + +import dev.cel.expr.CheckedExpr; +import dev.cel.expr.ParsedExpr; +import dev.cel.expr.Type; +import com.google.auto.value.AutoValue; +import com.google.common.base.Joiner; +import com.google.common.base.Optional; +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Maps; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelMutableAst; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.common.CelSource; +import dev.cel.common.Operator; +import dev.cel.common.annotations.Internal; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExpr.CelMutableCall; +import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; +import dev.cel.common.ast.CelMutableExpr.CelMutableIdent; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; +import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; +import dev.cel.common.ast.CelReference; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypes; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.ProtoMessageType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeType; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import org.jspecify.annotations.Nullable; + +/** + * The expression type checker. + * + *

CEL-Java library internals. Do not use. + * + * @deprecated Please migrate to CEL-Java Fluent APIs instead. See {@code CelCompilerFactory}. + */ +@Internal +@Deprecated +public final class ExprChecker { + private static final CelSource.Extension JSON_NAME_EXTENSION = + CelSource.Extension.create( + "json_name", + CelSource.Extension.Version.of(1, 1), + CelSource.Extension.Component.COMPONENT_RUNTIME); + + /** + * Deprecated type-check API. + * + * @deprecated Do not use. CEL-Java users should leverage the Fluent APIs instead. See {@code + * CelCompilerFactory}. + */ + @CheckReturnValue + @Deprecated + public static CheckedExpr check(Env env, String inContainer, ParsedExpr parsedExpr) { + return typecheck(env, inContainer, parsedExpr, Optional.absent()); + } + + /** + * Deprecated type-check API. + * + * @deprecated Do not use. CEL-Java users should leverage the Fluent APIs instead. See {@code + * CelCompilerFactory}. + */ + @CheckReturnValue + @Deprecated + public static CheckedExpr typecheck( + Env env, String inContainer, ParsedExpr parsedExpr, Optional expectedResultType) { + Optional type = + expectedResultType.isPresent() + ? Optional.of(CelProtoTypes.typeToCelType(expectedResultType.get())) + : Optional.absent(); + CelAbstractSyntaxTree ast = + typecheck( + env, + CelContainer.ofName(inContainer), + CelProtoAbstractSyntaxTree.fromParsedExpr(parsedExpr).getAst(), + type); + + if (ast.isChecked()) { + return CelProtoAbstractSyntaxTree.fromCelAst(ast).toCheckedExpr(); + } + + return CheckedExpr.newBuilder() + .setExpr(parsedExpr.getExpr()) + .setSourceInfo(parsedExpr.getSourceInfo()) + .build(); + } + + /** + * Type-checks the parsed expression within the given environment and returns a checked + * expression. If an expected result type was given, then it verifies that that type matches the + * actual result type. Conditions for type checking and the constructed {@link CheckedExpr} are + * described in checked.proto. + * + *

CEL Library Internals. Do not use. CEL-Java users should use the Fluent APIs instead. + */ + @CheckReturnValue + @Internal + public static CelAbstractSyntaxTree typecheck( + Env env, + CelContainer container, + CelAbstractSyntaxTree ast, + Optional expectedResultType) { + env.resetTypeAndRefMaps(); + final ExprChecker checker = + new ExprChecker( + env, + container, + ast.getSource().getPositionsMap(), + new InferenceContext(), + env.enableCompileTimeOverloadResolution(), + env.enableHomogeneousLiterals(), + env.enableNamespacedDeclarations()); + + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + checker.visit(mutableAst.expr()); + if (expectedResultType.isPresent()) { + checker.assertType(mutableAst.expr(), expectedResultType.get()); + } + // Walk over the final type map substituting any type parameters either by their bound value or + // by DYN. + Map typeMap = + Maps.transformValues(env.getTypeMap(), checker.inferenceContext::finalize); + + CelAbstractSyntaxTree parsedAst = mutableAst.toParsedAst(/* retainSourcePositions= */ true); + return CelAbstractSyntaxTree.newCheckedAst( + parsedAst.getExpr(), + parsedAst.getSource().toBuilder().addAllExtensions(checker.extensions).build(), + env.getRefMap(), + typeMap); + } + + private final Env env; + private final TypeProvider typeProvider; + private final CelContainer container; + private final Map positionMap; + private final InferenceContext inferenceContext; + private final boolean compileTimeOverloadResolution; + private final boolean homogeneousLiterals; + private final boolean namespacedDeclarations; + private final Set extensions; + + private ExprChecker( + Env env, + CelContainer container, + Map positionMap, + InferenceContext inferenceContext, + boolean compileTimeOverloadResolution, + boolean homogeneousLiterals, + boolean namespacedDeclarations) { + this.env = checkNotNull(env); + this.typeProvider = env.getTypeProvider(); + this.positionMap = checkNotNull(positionMap); + this.container = checkNotNull(container); + this.inferenceContext = checkNotNull(inferenceContext); + this.compileTimeOverloadResolution = compileTimeOverloadResolution; + this.homogeneousLiterals = homogeneousLiterals; + this.namespacedDeclarations = namespacedDeclarations; + this.extensions = new HashSet<>(); + } + + /** Visit the {@code expr} value, routing to overloads based on the kind of expression. */ + public void visit(CelMutableExpr expr) { + switch (expr.getKind()) { + case CONSTANT: + visit(expr, expr.constant()); + break; + case IDENT: + visit(expr, expr.ident()); + break; + case SELECT: + visit(expr, expr.select()); + break; + case CALL: + visit(expr, expr.call()); + break; + case LIST: + visit(expr, expr.list()); + break; + case STRUCT: + visit(expr, expr.struct()); + break; + case MAP: + visit(expr, expr.map()); + break; + case COMPREHENSION: + visit(expr, expr.comprehension()); + break; + default: + throw new IllegalArgumentException("unexpected expr kind"); + } + } + + private void visit(CelMutableExpr expr, CelConstant constant) { + switch (constant.getKind()) { + case INT64_VALUE: + env.setType(expr, SimpleType.INT); + break; + case UINT64_VALUE: + env.setType(expr, SimpleType.UINT); + break; + case STRING_VALUE: + env.setType(expr, SimpleType.STRING); + break; + case BYTES_VALUE: + env.setType(expr, SimpleType.BYTES); + break; + case BOOLEAN_VALUE: + env.setType(expr, SimpleType.BOOL); + break; + case NULL_VALUE: + env.setType(expr, SimpleType.NULL_TYPE); + break; + case DOUBLE_VALUE: + env.setType(expr, SimpleType.DOUBLE); + break; + case TIMESTAMP_VALUE: + env.setType(expr, SimpleType.TIMESTAMP); + break; + case DURATION_VALUE: + env.setType(expr, SimpleType.DURATION); + break; + default: + throw new IllegalArgumentException("unexpected constant case: " + constant.getKind()); + } + } + + private void visit(CelMutableExpr expr, CelMutableIdent ident) { + CelIdentDecl decl = env.lookupIdent(expr.id(), getPosition(expr), container, ident.name()); + checkNotNull(decl); + if (decl.equals(Env.ERROR_IDENT_DECL)) { + // error reported + env.setType(expr, SimpleType.ERROR); + env.setRef(expr, makeReference(decl.name(), decl)); + return; + } + + String refName = maybeDisambiguate(ident.name(), decl.name()); + + if (!refName.equals(ident.name())) { + // Overwrite the identifier with its fully qualified name. + expr.setIdent(CelMutableIdent.create(refName)); + } + env.setType(expr, decl.type()); + env.setRef(expr, makeReference(refName, decl)); + } + + private void visit(CelMutableExpr expr, CelMutableSelect select) { + // Before traversing down the tree, try to interpret as qualified name. + String qname = asQualifiedName(expr); + if (qname != null) { + CelIdentDecl decl = env.tryLookupCelIdent(container, qname); + if (decl != null) { + if (select.testOnly()) { + env.reportError(expr.id(), getPosition(expr), "expression does not select a field"); + env.setType(expr, SimpleType.BOOL); + } else { + String refName = maybeDisambiguate(qname, decl.name()); + + if (namespacedDeclarations) { + // Rewrite the node to be a variable reference to the resolved fully-qualified + // variable name. + expr.setIdent(CelMutableIdent.create(refName)); + } + env.setType(expr, decl.type()); + env.setRef(expr, makeReference(refName, decl)); + } + return; + } + } + // Interpret as field selection, first traversing down the operand. + visit(select.operand()); + + CelType resultType = visitSelectField(expr, select.operand(), select.field(), false); + + if (select.testOnly()) { + resultType = SimpleType.BOOL; + } + env.setType(expr, resultType); + } + + private void visit(CelMutableExpr expr, CelMutableCall call) { + String functionName = call.function(); + if (Operator.OPTIONAL_SELECT.getFunction().equals(functionName)) { + visitOptionalCall(expr, call); + return; + } + // Traverse arguments. + for (CelMutableExpr arg : call.args()) { + visit(arg); + } + + int position = getPosition(expr); + OverloadResolution resolution; + + if (!call.target().isPresent()) { + // Regular static call with simple name. + CelFunctionDecl decl = env.lookupFunction(expr.id(), position, container, call.function()); + resolution = resolveOverload(expr.id(), position, decl, null, call.args()); + + if (!decl.name().equals(call.function())) { + if (namespacedDeclarations) { + // Overwrite the function name with its fully qualified resolved name. + expr.setCall(CelMutableCall.create(decl.name(), call.args())); + } + } + } else { + // Check whether the target is actually a qualified name for a static function. + String qualifiedName = asQualifiedName(call.target().get()); + CelFunctionDecl decl = + env.tryLookupCelFunction(container, qualifiedName + "." + call.function()); + if (decl != null) { + resolution = resolveOverload(expr.id(), position, decl, null, call.args()); + + if (namespacedDeclarations) { + // The function name is namespaced and so preserving the target operand would + // be an inaccurate representation of the desired evaluation behavior. + // Overwrite with fully-qualified resolved function name sans receiver target. + expr.setCall(CelMutableCall.create(decl.name(), call.args())); + } + } else { + // Regular instance call. + CelMutableExpr target = call.target().get(); + visit(target); + resolution = + resolveOverload( + expr.id(), + position, + env.lookupFunction(expr.id(), getPosition(expr), container, call.function()), + target, + call.args()); + } + } + + env.setType(expr, resolution.type()); + env.setRef(expr, resolution.reference()); + } + + private void visit(CelMutableExpr expr, CelMutableStruct struct) { + // Determine the type of the message. + CelType messageType = SimpleType.ERROR; + CelIdentDecl decl = + env.lookupIdent(expr.id(), getPosition(expr), container, struct.messageName()); + if (!struct.messageName().equals(decl.name())) { + struct.setMessageName(decl.name()); + } + + env.setRef(expr, CelReference.newBuilder().setName(decl.name()).build()); + CelType type = decl.type(); + if (!type.kind().equals(CelKind.ERROR)) { + if (!type.kind().equals(CelKind.TYPE)) { + // expected type of types + env.reportError(expr.id(), getPosition(expr), "'%s' is not a type", CelTypes.format(type)); + } else { + messageType = ((TypeType) type).type(); + if (!messageType.kind().equals(CelKind.STRUCT)) { + env.reportError( + expr.id(), + getPosition(expr), + "'%s' is not a message type", + CelTypes.format(messageType)); + messageType = SimpleType.ERROR; + } + } + } + + // When the type is well-known mark the expression with the CEL type rather than the proto type. + if (Env.isWellKnownType(messageType)) { + env.setType(expr, Env.getWellKnownType(messageType)); + } else { + env.setType(expr, messageType); + } + + // Check the field initializers. + List entriesList = struct.entries(); + for (CelMutableStruct.Entry entry : entriesList) { + CelMutableExpr value = entry.value(); + visit(value); + + CelType fieldType = + getFieldType(entry.id(), getPosition(entry), messageType, entry.fieldKey()).celType(); + CelType valueType = env.getType(value); + if (entry.optionalEntry()) { + if (valueType instanceof OptionalType) { + valueType = unwrapOptional(valueType); + } else { + assertIsAssignable( + value.id(), getPosition(value), valueType, OptionalType.create(valueType)); + } + } + if (!inferenceContext.isAssignable(fieldType, valueType)) { + env.reportError( + expr.id(), + getPosition(entry), + "expected type of field '%s' is '%s' but provided type is '%s'", + entry.fieldKey(), + CelTypes.format(fieldType), + CelTypes.format(valueType)); + } + } + } + + private void visit(CelMutableExpr expr, CelMutableMap map) { + CelType mapKeyType = null; + CelType mapValueType = null; + List entriesList = map.entries(); + for (CelMutableMap.Entry entry : entriesList) { + CelMutableExpr key = entry.key(); + visit(key); + + mapKeyType = joinTypes(key.id(), getPosition(key), mapKeyType, env.getType(key)); + + CelMutableExpr value = entry.value(); + visit(value); + + CelType valueType = env.getType(value); + if (entry.optionalEntry()) { + if (valueType instanceof OptionalType) { + valueType = unwrapOptional(valueType); + } else { + assertIsAssignable( + value.id(), getPosition(value), valueType, OptionalType.create(valueType)); + } + } + + mapValueType = joinTypes(value.id(), getPosition(value), mapValueType, valueType); + } + if (mapKeyType == null) { + // If the map is empty, assign free type variables to key and value type. + mapKeyType = inferenceContext.newTypeVar("key"); + mapValueType = inferenceContext.newTypeVar("value"); + } + env.setType(expr, MapType.create(mapKeyType, mapValueType)); + } + + private void visit(CelMutableExpr expr, CelMutableList list) { + CelType elemsType = null; + List elementsList = list.elements(); + HashSet optionalIndices = new HashSet<>(list.optionalIndices()); + for (int i = 0; i < elementsList.size(); i++) { + CelMutableExpr elem = elementsList.get(i); + visit(elem); + + CelType elemType = env.getType(elem); + if (optionalIndices.contains(i)) { + if (elemType instanceof OptionalType) { + elemType = unwrapOptional(elemType); + } else { + assertIsAssignable(elem.id(), getPosition(elem), elemType, OptionalType.create(elemType)); + } + } + + elemsType = joinTypes(elem.id(), getPosition(elem), elemsType, elemType); + } + if (elemsType == null) { + // If the list is empty, assign free type var to elem type. + elemsType = inferenceContext.newTypeVar("elem"); + } + env.setType(expr, ListType.create(elemsType)); + } + + private void visit(CelMutableExpr expr, CelMutableComprehension compre) { + visit(compre.iterRange()); + visit(compre.accuInit()); + CelType accuType = env.getType(compre.accuInit()); + CelType rangeType = inferenceContext.specialize(env.getType(compre.iterRange())); + CelType varType; + CelType varType2 = null; + switch (rangeType.kind()) { + case LIST: + varType = ((ListType) rangeType).elemType(); + if (!Strings.isNullOrEmpty(compre.iterVar2())) { + varType2 = varType; + varType = SimpleType.INT; + } + break; + case MAP: + // Ranges over the keys. + varType = ((MapType) rangeType).keyType(); + if (!Strings.isNullOrEmpty(compre.iterVar2())) { + varType2 = ((MapType) rangeType).valueType(); + } + break; + case DYN: + case ERROR: + varType = SimpleType.DYN; + varType2 = SimpleType.DYN; + break; + case TYPE_PARAM: + // Mark the range as DYN to avoid its free variable being associated with the wrong type + // based on an earlier or later use. The isAssignable call will ensure that type + // substitutions are updated for the type param. + inferenceContext.isAssignable(SimpleType.DYN, rangeType); + // Mark the variable type as DYN. + varType = SimpleType.DYN; + varType2 = SimpleType.DYN; + break; + default: + env.reportError( + expr.id(), + getPosition(compre.iterRange()), + "expression of type '%s' cannot be range of a comprehension " + + "(must be list, map, or dynamic)", + CelTypes.format(rangeType)); + varType = SimpleType.DYN; + varType2 = SimpleType.DYN; + break; + } + + // Declare accumulation variable on outer scope. + env.enterScope(); + env.add(CelIdentDecl.newIdentDeclaration(compre.accuVar(), accuType)); + // Declare iteration variable on inner scope. + env.enterScope(); + env.add(CelIdentDecl.newIdentDeclaration(compre.iterVar(), varType)); + if (!Strings.isNullOrEmpty(compre.iterVar2())) { + env.add(CelIdentDecl.newIdentDeclaration(compre.iterVar2(), varType2)); + } + visit(compre.loopCondition()); + assertType(compre.loopCondition(), SimpleType.BOOL); + visit(compre.loopStep()); + assertType(compre.loopStep(), accuType); + // Forget iteration variable, as result expression must only depend on accu. + env.exitScope(); + visit(compre.result()); + env.exitScope(); + + env.setType(expr, inferenceContext.specialize(env.getType(compre.result()))); + } + + private CelReference makeReference(String name, CelIdentDecl decl) { + CelReference.Builder ref = CelReference.newBuilder().setName(name); + if (decl.constant().isPresent()) { + ref.setValue(decl.constant().get()); + } + return ref.build(); + } + + /** + * Returns the reference name, prefixed with a leading dot only if disambiguation is needed. + * Disambiguation is needed when: the original name had a leading dot, and there's a local + * variable that would shadow the resolved name. + */ + private String maybeDisambiguate(String originalName, String resolvedName) { + if (!originalName.startsWith(".")) { + return resolvedName; + } + String simpleName = originalName.substring(1); + int dotIndex = simpleName.indexOf('.'); + String localName = dotIndex > 0 ? simpleName.substring(0, dotIndex) : simpleName; + if (env.tryLookupCelIdentFromLocalScopes(localName) != null) { + return "." + resolvedName; + } + return resolvedName; + } + + private OverloadResolution resolveOverload( + long callExprId, + int position, + @Nullable CelFunctionDecl function, + @Nullable CelMutableExpr target, + List args) { + if (function == null || function.equals(Env.ERROR_FUNCTION_DECL)) { + // Error reported, just return error value. + return OverloadResolution.of(CelReference.newBuilder().build(), SimpleType.ERROR); + } + List argTypes = new ArrayList<>(); + if (target != null) { + argTypes.add(env.getType(target)); + } + for (CelMutableExpr arg : args) { + argTypes.add(env.getType(arg)); + } + CelType resultType = null; // For most common result type. + String firstCandString = null; + CelReference.Builder refBuilder = CelReference.newBuilder(); + List excludedCands = new ArrayList<>(); + String expectedString = + TypeFormatter.formatFunction(inferenceContext.specialize(argTypes), target != null); + for (CelOverloadDecl overload : function.overloads()) { + boolean isInstance = overload.isInstanceFunction(); + if ((target == null && isInstance) || (target != null && !isInstance)) { + // not a compatible call style. + continue; + } + CelType overloadType = + CelTypes.createFunctionType(overload.resultType(), overload.parameterTypes()); + if (!overload.typeParameterNames().isEmpty()) { + // Instantiate overload's type with fresh type variables. + overloadType = inferenceContext.newInstance(overload.typeParameterNames(), overloadType); + } + ImmutableList candArgTypes = + overloadType.parameters().subList(1, overloadType.parameters().size()); + String candString = + TypeFormatter.formatFunction(inferenceContext.specialize(candArgTypes), target != null); + if (inferenceContext.isAssignable(argTypes, candArgTypes)) { + // Collect overload id. + refBuilder.addOverloadIds(overload.overloadId()); + if (resultType == null) { + // First matching overload, determines result type. + resultType = inferenceContext.specialize(overloadType.parameters().get(0)); + firstCandString = candString; + } else { + // More than one matching overload in non-strict mode, narrow result type to DYN unless + // the overload type matches the previous result type. + CelType fnResultType = inferenceContext.specialize(overloadType).parameters().get(0); + if (!Types.isDyn(resultType) && !resultType.equals(fnResultType)) { + // TODO: Consider joining result types of successful candidates when the + // types are assignable, but not the same. Note, type assignability checks here seem to + // mutate the type substitutions list in unexpected ways that result in errant results. + resultType = SimpleType.DYN; + } + if (compileTimeOverloadResolution) { + // In compile-time overload resolution mode report this situation as an error. + env.reportError( + callExprId, + position, + "found more than one matching overload for '%s' applied to '%s': %s and also %s", + function.name(), + expectedString, + firstCandString, + candString); + } + } + } else { + excludedCands.add(candString); + } + } + if (resultType == null) { + env.reportError( + callExprId, + position, + "found no matching overload for '%s' applied to '%s'%s", + function.name(), + expectedString, + excludedCands.isEmpty() + ? "" + : " (candidates: " + Joiner.on(',').join(excludedCands) + ")"); + resultType = SimpleType.ERROR; + } + return OverloadResolution.of(refBuilder.build(), resultType); + } + + // Return value from visit is not needed as the subtree is not rewritten here. + @SuppressWarnings("CheckReturnValue") + private CelType visitSelectField( + CelMutableExpr expr, CelMutableExpr operand, String field, boolean isOptional) { + CelType operandType = inferenceContext.specialize(env.getType(operand)); + CelType resultType = SimpleType.ERROR; + + if (operandType instanceof OptionalType) { + isOptional = true; + operandType = unwrapOptional(operandType); + } + + if (!Types.isDynOrError(operandType)) { + if (operandType.kind().equals(CelKind.STRUCT)) { + TypeProvider.FieldType fieldType = + getFieldType(expr.id(), getPosition(expr), operandType, field); + ProtoMessageType protoMessageType = resolveProtoMessageType(operandType); + if (protoMessageType != null && protoMessageType.isJsonName(field)) { + extensions.add(JSON_NAME_EXTENSION); + } + // Type of the field + resultType = fieldType.celType(); + } else if (operandType.kind().equals(CelKind.MAP)) { + resultType = ((MapType) operandType).valueType(); + } else if (operandType.kind().equals(CelKind.TYPE_PARAM)) { + // Mark the operand as type DYN to avoid cases where the free type variable might take on + // an incorrect type if used in multiple locations. + // + // The assignability test will update the type substitutions for the type parameter with the + // type DYN. This ensures that the operand type is appropriately flagged as DYN even though + // it has already been assigned a TypeParam type from an earlier call flow. + inferenceContext.isAssignable(SimpleType.DYN, operandType); + + // Mark the result type as DYN since no meaningful type inferences can be made from this + // field selection. + resultType = SimpleType.DYN; + } else { + env.reportError( + expr.id(), + getPosition(expr), + "type '%s' does not support field selection", + CelTypes.format(operandType)); + } + } else { + resultType = SimpleType.DYN; + } + + // If the target type was optional coming in, then the result must be optional going out. + if (isOptional) { + resultType = OptionalType.create(resultType); + } + return resultType; + } + + private @Nullable ProtoMessageType resolveProtoMessageType(CelType operandType) { + if (operandType instanceof ProtoMessageType) { + return (ProtoMessageType) operandType; + } + + if (operandType.kind().equals(CelKind.STRUCT)) { + // This is either a StructTypeReference or just a Struct. Attempt to search for + // ProtoMessageType that may exist in in the type provider. + TypeType typeDef = + typeProvider + .lookupCelType(operandType.name()) + .filter(t -> t instanceof TypeType) + .map(TypeType.class::cast) + .orElse(null); + if (typeDef == null || typeDef.parameters().size() != 1) { + return null; + } + + CelType maybeProtoMessageType = typeDef.parameters().get(0); + if (maybeProtoMessageType instanceof ProtoMessageType) { + return (ProtoMessageType) maybeProtoMessageType; + } + } + + return null; + } + + private void visitOptionalCall(CelMutableExpr expr, CelMutableCall call) { + CelMutableExpr operand = call.args().get(0); + CelMutableExpr field = call.args().get(1); + if (!field.getKind().equals(CelExpr.ExprKind.Kind.CONSTANT) + || !field.constant().getKind().equals(CelConstant.Kind.STRING_VALUE)) { + + env.reportError(expr.id(), getPosition(field), "unsupported optional field selection"); + return; + } + + visit(operand); + + CelType resultType = visitSelectField(expr, operand, field.constant().stringValue(), true); + env.setType(expr, resultType); + env.setRef(expr, CelReference.newBuilder().addOverloadIds("select_optional_field").build()); + } + + /** + * Attempt to interpret an expression as a qualified name. This traverses select and getIdent + * expression and returns the name they constitute, or null if the expression cannot be + * interpreted like this. + */ + private @Nullable String asQualifiedName(CelMutableExpr expr) { + switch (expr.getKind()) { + case IDENT: + return expr.ident().name(); + case SELECT: + String qname = asQualifiedName(expr.select().operand()); + if (qname != null) { + return qname + "." + expr.select().field(); + } + return null; + default: + return null; + } + } + + /** Returns the field type give a type instance and field name. */ + private TypeProvider.FieldType getFieldType( + long exprId, int position, CelType type, String fieldName) { + String typeName = type.name(); + if (typeProvider.lookupCelType(typeName).isPresent()) { + TypeProvider.FieldType fieldType = typeProvider.lookupFieldType(type, fieldName); + if (fieldType != null) { + return fieldType; + } + TypeProvider.ExtensionFieldType extensionFieldType = + typeProvider.lookupExtensionType(fieldName); + if (extensionFieldType != null) { + return extensionFieldType.fieldType(); + } + env.reportError(exprId, position, "undefined field '%s'", fieldName); + } else { + // Proto message was added as a variable to the environment but the descriptor was not + // provided + String errorMessage = + String.format("Message type resolution failure while referencing field '%s'.", fieldName); + if (type.kind().equals(CelKind.STRUCT)) { + errorMessage += + String.format( + " Ensure that the descriptor for type '%s' was added to the environment", typeName); + } + env.reportError(exprId, position, errorMessage, fieldName, typeName); + } + return ERROR; + } + + /** Checks compatibility of joined types, and returns the most general common type. */ + private CelType joinTypes(long exprId, int position, CelType previousType, CelType type) { + if (previousType == null) { + return type; + } + if (homogeneousLiterals) { + assertIsAssignable(exprId, position, type, previousType); + } else if (!inferenceContext.isAssignable(previousType, type)) { + return SimpleType.DYN; + } + return Types.mostGeneral(previousType, type); + } + + private void assertIsAssignable(long exprId, int position, CelType actual, CelType expected) { + if (!inferenceContext.isAssignable(expected, actual)) { + env.reportError( + exprId, + position, + "expected type '%s' but found '%s'", + CelTypes.format(expected), + CelTypes.format(actual)); + } + } + + private CelType unwrapOptional(CelType type) { + return type.parameters().get(0); + } + + private void assertType(CelMutableExpr expr, CelType type) { + assertIsAssignable(expr.id(), getPosition(expr), env.getType(expr), type); + } + + private int getPosition(CelMutableExpr expr) { + Integer pos = positionMap.get(expr.id()); + return pos == null ? 0 : pos; + } + + private int getPosition(CelMutableStruct.Entry entry) { + Integer pos = positionMap.get(entry.id()); + return pos == null ? 0 : pos; + } + + /** Helper object for holding an overload resolution result. */ + @AutoValue + protected abstract static class OverloadResolution { + + /** The {@code Reference} to the declaration name and overload id. */ + public abstract CelReference reference(); + + /** The {@code Type} of the result associated with the overload. */ + public abstract CelType type(); + + /** Construct a new {@code OverloadResolution} from a {@code reference} and {@code type}. */ + public static OverloadResolution of(CelReference reference, CelType type) { + return new AutoValue_ExprChecker_OverloadResolution(reference, type); + } + } + + /** Helper object to represent a {@link TypeProvider.FieldType} lookup failure. */ + private static final TypeProvider.FieldType ERROR = TypeProvider.FieldType.of(Types.ERROR); +} diff --git a/checker/src/main/java/dev/cel/checker/ExprVisitor.java b/checker/src/main/java/dev/cel/checker/ExprVisitor.java new file mode 100644 index 000000000..b5690634d --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/ExprVisitor.java @@ -0,0 +1,148 @@ +// Copyright 2023 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.checker; + +import dev.cel.expr.Constant; +import dev.cel.expr.Expr; +import dev.cel.expr.Expr.CreateStruct.Entry.KeyKindCase; +import dev.cel.common.annotations.Internal; + +/** + * CEL expression visitor implementation. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public abstract class ExprVisitor { + + /** + * ComprehensionArg specifies the arg ordinal values for comprehension arguments, where the + * ordinal of the enum maps to the ordinal of the argument in the comprehension expression. + */ + public enum ComprehensionArg { + ITER_RANGE, + ACCU_INIT, + LOOP_CONDIITON, + LOOP_STEP, + RESULT + } + + protected ExprVisitor() {} + + /** Visit the {@code expr} value, routing to overloads based on the kind of expression. */ + public void visit(Expr expr) { + switch (expr.getExprKindCase()) { + case CONST_EXPR: + visit(expr, expr.getConstExpr()); + break; + case IDENT_EXPR: + visit(expr, expr.getIdentExpr()); + break; + case SELECT_EXPR: + visit(expr, expr.getSelectExpr()); + break; + case CALL_EXPR: + visit(expr, expr.getCallExpr()); + break; + case LIST_EXPR: + visit(expr, expr.getListExpr()); + break; + case STRUCT_EXPR: + visit(expr, expr.getStructExpr()); + break; + case COMPREHENSION_EXPR: + visit(expr, expr.getComprehensionExpr()); + break; + default: + throw new IllegalArgumentException("unexpected expr kind"); + } + } + + /** Visit an {@code Expr.Ident} expression. */ + protected void visit(Expr expr, Expr.Ident ident) {} + + /** Visit a {@code Expr.Constant} expression. */ + protected void visit(Expr expr, Constant constant) {} + + /** Visit a {@code Expr.Select} expression. */ + protected void visit(Expr expr, Expr.Select select) { + visit(select.getOperand()); + } + + /** + * Visit a {@code Expr.Call} expression. + * + *

Arguments to the call are provided to the {@link #visitArg} function after they have been + * {@code visit}ed. + */ + protected void visit(Expr expr, Expr.Call call) { + if (call.hasTarget()) { + visit(call.getTarget()); + } + for (int i = 0; i < call.getArgsCount(); i++) { + Expr arg = call.getArgs(i); + // Visit the argument prior to calling {@code visitArg(expr, arg, i)} which may be used to + // assist with expression re-writing. + visit(arg); + visitArg(expr, arg, i); + } + } + + /** Visit a {@code Expr.CreateStruct} expression. */ + protected void visit(Expr expr, Expr.CreateStruct createStruct) { + for (Expr.CreateStruct.Entry entry : createStruct.getEntriesList()) { + if (entry.getKeyKindCase() == KeyKindCase.MAP_KEY) { + visit(entry.getMapKey()); + } + visit(entry.getValue()); + } + } + + /** Visit a {@code Expr.CreateList} expression. */ + protected void visit(Expr expr, Expr.CreateList createList) { + for (Expr elem : createList.getElementsList()) { + visit(elem); + } + } + + /** + * Visit a {@code Expr.Comprehension} expression. + * + *

Arguments to the comprehension are provided to the {@link #visitArg} function after they + * have been {@code visit}ed. + */ + protected void visit(Expr expr, Expr.Comprehension comprehension) { + visit(comprehension.getIterRange()); + visitArg(expr, comprehension.getIterRange(), ComprehensionArg.ITER_RANGE.ordinal()); + visit(comprehension.getAccuInit()); + visitArg(expr, comprehension.getAccuInit(), ComprehensionArg.ACCU_INIT.ordinal()); + visit(comprehension.getLoopCondition()); + visitArg(expr, comprehension.getLoopCondition(), ComprehensionArg.LOOP_CONDIITON.ordinal()); + visit(comprehension.getLoopStep()); + visitArg(expr, comprehension.getLoopStep(), ComprehensionArg.LOOP_STEP.ordinal()); + visit(comprehension.getResult()); + visitArg(expr, comprehension.getResult(), ComprehensionArg.RESULT.ordinal()); + } + + /** + * Visit the argument to an expression in the context of the calling expression. + * + *

For {@code Expr.Call} expressions, the arg num refers to the ordinal of the argument. + * + *

For {@code Expr.Comprehension} expressions, the arg number refers to the ordinal of the enum + * value as it appears in {@link ComprehensionArg}. + */ + protected void visitArg(Expr expr, Expr arg, int argNum) {} +} diff --git a/checker/src/main/java/dev/cel/checker/InferenceContext.java b/checker/src/main/java/dev/cel/checker/InferenceContext.java new file mode 100644 index 000000000..c254736ef --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/InferenceContext.java @@ -0,0 +1,110 @@ +// Copyright 2023 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.checker; + +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.common.annotations.Internal; +import dev.cel.common.types.CelType; +import dev.cel.common.types.TypeParamType; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * An object holding a context for type inference. + * + *

Consists of a type substitution and a generator for free type variables in the context, as + * well as methods to work with the context. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public class InferenceContext { + + private Map substitution = new HashMap<>(); + private int freeTypeVarCounter; + + /** Creates a fresh type variable in the given context. */ + public CelType newTypeVar(String prefix) { + // If the prefix ends with a digit, then add an extra % as separator between + // it and the counter to prevent the two from blending into each other since + // that can cause accidental name clashes. + String separator = + (!prefix.isEmpty() && Character.isDigit(prefix.charAt(prefix.length() - 1))) ? "%" : ""; + return TypeParamType.create("%" + prefix + separator + freeTypeVarCounter++); + } + + /** + * Returns an instance of the given type where all given type parameters are replaced by fresh + * type variables. + */ + public CelType newInstance(Iterable typeParams, CelType type) { + Map subs = new HashMap<>(); + for (String typeParam : typeParams) { + subs.put(TypeParamType.create(typeParam), newTypeVar(typeParam)); + } + return Types.substitute(subs, type, false); + } + + /** + * Checks whether type1 is assignable to type2 under refinement of the type substitution. Returns + * true on success, and false on failure. The substitution in the type context will not be + * modified on failure. + */ + @CanIgnoreReturnValue + public boolean isAssignable(CelType type1, CelType type2) { + Map newSubs = Types.isAssignable(substitution, type1, type2); + if (newSubs != null) { + substitution = newSubs; + return true; + } else { + return false; + } + } + + /** Same as {@link #isAssignable(CelType, CelType)} for lists of types. */ + public boolean isAssignable(List list1, List list2) { + Map newSubs = Types.isAssignable(substitution, list1, list2); + if (newSubs != null) { + substitution = newSubs; + return true; + } else { + return false; + } + } + + /** Specializes the given type using the substitution of this context. */ + public CelType specialize(CelType type) { + return Types.substitute(substitution, type, false); + } + + /** Specializes using given type list of types using the substitution of this context. */ + public List specialize(List types) { + List result = new ArrayList<>(); + for (CelType type : types) { + result.add(specialize(type)); + } + return result; + } + + /** + * Finalizes the given type by applying the current type substitution and mapping all remaining + * type parameters to DYN. + */ + public CelType finalize(CelType type) { + return Types.substitute(substitution, type, true); + } +} diff --git a/checker/src/main/java/dev/cel/checker/ProtoTypeMask.java b/checker/src/main/java/dev/cel/checker/ProtoTypeMask.java new file mode 100644 index 000000000..ec1c31840 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/ProtoTypeMask.java @@ -0,0 +1,137 @@ +// Copyright 2022 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.checker; + +import static com.google.common.base.Preconditions.checkArgument; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Splitter; +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.FieldMask; + +/** + * {@code ProtoTypeMask} describes the fraction of a protobuf type's object graph that should be + * visible within CEL expressions. The top-level fields of the type identified by the {@link + * #getTypeName} are treated as variable declarations. + */ +@AutoValue +@Immutable +public abstract class ProtoTypeMask { + + private static final Splitter PATH_SPLITTER = Splitter.on('.'); + + /** WILDCARD_FIELD indicates that all fields within the proto type are visible. */ + static final String WILDCARD_FIELD = "*"; + + /** HIDDEN_FIELD indicates that all fields within the proto type are not visible. */ + static final String HIDDEN_FIELD = "!"; + + private static final FieldMask HIDDEN_FIELD_MASK = + FieldMask.newBuilder().addPaths(HIDDEN_FIELD).build(); + + private static final FieldPath HIDDEN_FIELD_PATH = FieldPath.of(HIDDEN_FIELD); + private static final FieldMask WILDCARD_FIELD_MASK = + FieldMask.newBuilder().addPaths(WILDCARD_FIELD).build(); + private static final FieldPath WILDCARD_FIELD_PATH = FieldPath.of(WILDCARD_FIELD); + + abstract String getTypeName(); + + abstract ImmutableSet getFieldPathsExposed(); + + abstract boolean fieldsAreVariableDeclarations(); + + boolean areAllFieldPathsExposed() { + return getFieldPathsExposed().stream().allMatch(fp -> fp.equals(WILDCARD_FIELD_PATH)); + } + + boolean areAllFieldPathsHidden() { + return getFieldPathsExposed().stream().allMatch(fp -> fp.equals(HIDDEN_FIELD_PATH)); + } + + public ProtoTypeMask withFieldsAsVariableDeclarations() { + return new AutoValue_ProtoTypeMask(getTypeName(), getFieldPathsExposed(), true); + } + + /** + * Construct a new {@code ProtoTypeMask} with a {@code FieldMask} indicating which fields should + * be visible to CEL expressions. + * + *

All top-level fields from the combined set of {@code paths} in the field mask should be + * treated as variable identifiers bound to the protobuf field name and its associated field type. + * + *

A {@code FieldMask} contains one or more {@code paths} which contain identifier characters + * that have been dot delimited, e.g. resource.name, request.auth.claims. Here are a few things to + * keep in mind: + * + *

+ */ + public static ProtoTypeMask of(String typeName, FieldMask fieldMask) { + checkArgument(!Strings.isNullOrEmpty(typeName)); + if (fieldMask == null || fieldMask.getPathsCount() == 0) { + fieldMask = WILDCARD_FIELD_MASK; + } + ImmutableSet.Builder fieldPaths = ImmutableSet.builder(); + fieldMask.getPathsList().forEach(path -> fieldPaths.add(FieldPath.of(path))); + return new AutoValue_ProtoTypeMask(typeName, fieldPaths.build(), false); + } + + /** + * Construct a new {@code ProtoTypeMask} which exposes all fields in the given {@code typeName} + * for use within CEL expressions. + * + *

The {@code typeName} should be a fully-qualified path, e.g. {@code + * "google.rpc.context.AttributeContext"}. + * + *

All top-level fields in the given {@code typeName} should be treated as variable identifiers + * bound to the protobuf field name and the associated field type. + */ + public static ProtoTypeMask ofAllFields(String fullyQualifiedTypeName) { + return of(fullyQualifiedTypeName, WILDCARD_FIELD_MASK); + } + + /** + * Construct a new {@code ProtoTypeMask} which hides all fields in the given {@code typeName} for + * use within CEL expressions. + * + *

The {@code typeName} should be a fully-qualified path, e.g. {@code + * "google.rpc.context.AttributeContext"}. + */ + public static ProtoTypeMask ofAllFieldsHidden(String fullyQualifiedTypeName) { + return of(fullyQualifiedTypeName, HIDDEN_FIELD_MASK); + } + + /** + * FieldPath is the equivalent of a field selection represented within a {@link FieldMask#path}. + */ + @AutoValue + @Immutable + abstract static class FieldPath { + + abstract ImmutableList getFieldSelection(); + + static FieldPath of(String path) { + checkArgument(!Strings.isNullOrEmpty(path), "path must be non-null and not empty"); + return new AutoValue_ProtoTypeMask_FieldPath(ImmutableList.copyOf(PATH_SPLITTER.split(path))); + } + } +} diff --git a/checker/src/main/java/dev/cel/checker/ProtoTypeMaskTypeProvider.java b/checker/src/main/java/dev/cel/checker/ProtoTypeMaskTypeProvider.java new file mode 100644 index 000000000..025dfaf1a --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/ProtoTypeMaskTypeProvider.java @@ -0,0 +1,147 @@ +// Copyright 2022 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.checker; + +import static com.google.common.base.Preconditions.checkArgument; + +import com.google.common.collect.ImmutableCollection; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.ProtoMessageType; +import dev.cel.common.types.StructType; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Optional; +import java.util.Set; + +/** + * The {@code ProtoTypeMaskTypeProvider} binds a set of {@code ProtoTypeMask} instances to type + * definitions and ensures that only fields which have been explicitly listed by the set of {@code + * ProtoTypeMask} values is exposed within the CEL type system. + */ +@Immutable +public final class ProtoTypeMaskTypeProvider implements CelTypeProvider { + + // The set of visible fields by type is not exposed after it is configured. + @SuppressWarnings("Immutable") + private final ImmutableMap allTypes; + + private final ImmutableSet protoTypeMasks; + + ProtoTypeMaskTypeProvider( + CelTypeProvider delegateProvider, ImmutableSet protoTypeMasks) { + this.protoTypeMasks = protoTypeMasks; + this.allTypes = computeVisibleFieldsMap(delegateProvider, protoTypeMasks); + } + + @Override + public ImmutableCollection types() { + return allTypes.values(); + } + + @Override + public Optional findType(String typeName) { + return Optional.ofNullable(allTypes.get(typeName)); + } + + /** + * Compute the list of {@code Decl} values derived from the input set of {@code ProtoTypeMask} + * values. + * + *

All top-level fields in {@link ProtoTypeMask#getTypeName} definition which are also exposed + * via a {@code FieldMask} are converted into {@code Decl} values. + */ + ImmutableList computeDeclsFromProtoTypeMasks() { + ImmutableList.Builder decls = ImmutableList.builder(); + for (ProtoTypeMask typeMask : protoTypeMasks) { + if (!typeMask.fieldsAreVariableDeclarations()) { + continue; + } + Optional celType = findType(typeMask.getTypeName()); + if (!celType.isPresent() || celType.get().kind() != CelKind.STRUCT) { + continue; + } + StructType celStruct = (StructType) celType.get(); + // The fieldNames cannot be null based on the checking provided by the computeVisibleFieldsMap + for (StructType.Field field : celStruct.fields()) { + decls.add(CelIdentDecl.newIdentDeclaration(field.name(), field.type())); + } + } + return decls.build(); + } + + private static ImmutableMap computeVisibleFieldsMap( + CelTypeProvider delegateProvider, ImmutableSet protoTypeMasks) { + Map> fieldMap = new HashMap<>(); + for (ProtoTypeMask typeMask : protoTypeMasks) { + String typeName = typeMask.getTypeName(); + Optional rootType = delegateProvider.findType(typeName); + checkArgument(rootType.isPresent(), "message not registered: %s", typeName); + if (typeMask.areAllFieldPathsExposed()) { + continue; + } + if (typeMask.areAllFieldPathsHidden()) { + fieldMap.put(typeName, ImmutableSet.of()); + continue; + } + // Unroll the type(messageType) to just messageType. + CelType type = rootType.get(); + checkArgument(type instanceof ProtoMessageType, "type is not a protobuf: %s", type.name()); + for (ProtoTypeMask.FieldPath fieldPath : typeMask.getFieldPathsExposed()) { + CelType targetType = type; + for (String fieldName : fieldPath.getFieldSelection()) { + checkArgument( + targetType instanceof ProtoMessageType, + "could not select field %s from type %s", + fieldName, + targetType.name()); + ProtoMessageType messageType = (ProtoMessageType) targetType; + String messageTypeName = targetType.name(); + if (fieldName.equals(ProtoTypeMask.WILDCARD_FIELD)) { + break; + } + Optional fieldType = messageType.findField(fieldName); + checkArgument( + fieldType.isPresent(), + "message %s does not declare field: %s", + messageTypeName, + fieldName); + Set fields = + fieldMap.computeIfAbsent(messageTypeName, (unused) -> new HashSet<>()); + fields.add(fieldName); + targetType = fieldType.get().type(); + } + } + } + + ImmutableMap.Builder maskedTypes = ImmutableMap.builder(); + for (CelType type : delegateProvider.types()) { + if (fieldMap.containsKey(type.name())) { + ProtoMessageType messageType = (ProtoMessageType) type; + messageType = messageType.withVisibleFields(ImmutableSet.copyOf(fieldMap.get(type.name()))); + maskedTypes.put(type.name(), messageType); + } else { + maskedTypes.put(type.name(), type); + } + } + return maskedTypes.buildOrThrow(); + } +} diff --git a/checker/src/main/java/dev/cel/checker/TypeFormatter.java b/checker/src/main/java/dev/cel/checker/TypeFormatter.java new file mode 100644 index 000000000..3cdd1a511 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/TypeFormatter.java @@ -0,0 +1,71 @@ +// Copyright 2023 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.checker; + +import dev.cel.expr.Type; +import dev.cel.common.annotations.Internal; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypes; +import org.jspecify.annotations.Nullable; + +/** + * Class to format {@link Type} objects into {@code String} values. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class TypeFormatter { + + /** Format a function string from the {@code argTypes} and {@code isInstance} information */ + static String formatFunction(Iterable argTypes, boolean isInstance) { + return formatFunction(null, argTypes, isInstance); + } + + /** + * Format a function signature string from the input {@code argTypes} and {@code resultType}. + * + *

When {@code isInstance} is {@code true}, the {@code argTypes[0]} type is used as the + * receiver type. + * + *

When {@code resultType} is {@code null}, the function signature omits the result type. This + * is useful for computing overload signatures. + */ + static String formatFunction( + @Nullable CelType resultType, Iterable argTypes, boolean isInstance) { + return formatFunction(resultType, argTypes, isInstance, /* typeParamToDyn= */ false); + } + + /** + * Format a function signature string from the input {@code argTypes} and {@code resultType}. + * + *

When {@code isInstance} is {@code true}, the {@code argTypes[0]} type is used as the + * receiver type. + * + *

When {@code resultType} is {@code null}, the function signature omits the result type. This + * is useful for computing overload signatures. + * + *

When {@code typeParamToDyn} is {@code true}, parameterized type argument are represented as + * {@code Types.DYN} values. + */ + static String formatFunction( + @Nullable CelType resultType, + Iterable argTypes, + boolean isInstance, + boolean typeParamToDyn) { + return CelTypes.formatFunction(resultType, argTypes, isInstance, typeParamToDyn); + } + + private TypeFormatter() {} +} diff --git a/checker/src/main/java/dev/cel/checker/TypeInferencer.java b/checker/src/main/java/dev/cel/checker/TypeInferencer.java new file mode 100644 index 000000000..3ce747150 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/TypeInferencer.java @@ -0,0 +1,386 @@ +// Copyright 2022 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.checker; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Optional; + +/** + * The TypeInferencer provides methods aligned with type unification algorithms like Hindley-Milner. + * + *

The core functions are pretty simple conceptually: + * + *

    + *
  • {@code unify} - unify the type representations for two or more types + *
  • {@code isAssignable} - determine whether one set of types is assignable to another set. + *
  • {@code specialize} - perform type-substitution on the type filling in values stored in + * recorded substitutions. + *
+ * + *

The assignability check is most commonly used for determining whether a pair of arguments are + * compatible with one another. This is mostly used for function calls. The {@code unify}, however, + * is mostly used for literal construction where the resolved type must be the most accurate + * combination of the user-specified types (assuming they yield a supported type). + * + *

When either of the {@code isAssignable} or {@code unify} methods are called, each method will + * minimally return the set of type substitutions made during the call. These substituation maps may + * be recorded into the {@code TypeInferencer} so they may be used with future type resolutions. + * Whether to record the type substitutions depends greatly on the context in which the calls are + * made. + */ +@CheckReturnValue +final class TypeInferencer { + + private final Map substitutions; + private final ImmutableList unionTypes; + + // Consider making these constructors public but exposed via a visibility restriction + + /** + * Construct a new {@code TypeInferencer} with a list of {@code unionTypes}. + * + *

The {@code unionTypes} must be ordered by least to most general, with the last union type + * being a top-type (if so desired). + */ + TypeInferencer(ImmutableList unionTypes) { + this(unionTypes, ImmutableMap.of()); + } + + /** + * Construct a new {@code TypeInferencer} with a list of {@code unionTypes} and a set of {@code + * priorSubstitutions}. + * + *

The {@code unionTypes} must be ordered by least to most general, with the last union type + * being a top-type (if so desired). + * + *

The {@code priorSubstitutions} may be type substitutions that occurred within an earlier + * type inference, or simply a set of type mappings to preserve between checks. + */ + TypeInferencer(ImmutableList unionTypes, Map priorSubstitutions) { + this.unionTypes = unionTypes; + this.substitutions = new HashMap<>(); + this.substitutions.putAll(priorSubstitutions); + } + + // Helper interface to aide in type unification. + @FunctionalInterface + private interface TypeSelectionStrategy { + Optional selectType(CelType type1, CelType type2); + } + + /** + * Perform type substitution on the {@code type} using the recorded substitution set, replacing + * unresolved type params with the input {@code topType}. + */ + CelType finalize(CelType type, CelType topType) { + return type.kind().isTypeParam() + ? Optional.ofNullable(substitutions.get(type.name())).map(this::specialize).orElse(topType) + : finalizeParameters(type, topType); + } + + /** + * Perform type substitution on the {@code type} using the recorded substitution set, leaving + * unresolved type params intact. + */ + CelType specialize(CelType type) { + return type.kind().isTypeParam() + ? Optional.ofNullable(substitutions.get(type.name())).map(this::specialize).orElse(type) + : specializeParameters(type); + } + + /** Determine whether {@code type} is assignable to {@code desiredType}. */ + Optional unify(CelType type, CelType desiredType) { + // Check how this behaves with `type` values. + return unifier(substitutions).compute(type, desiredType); + } + + /** Unify a list of {@code types} together into a single {@code CelType}. */ + Optional unify(List types, CelType desiredType) { + CelType unifiedType = desiredType; + UnificationComputation unification = unifier(substitutions); + for (CelType type : types) { + Optional result = unification.compute(type, unifiedType); + if (!result.isPresent()) { + return Optional.empty(); + } + // If the desired type is a type param, then it would have had a substitution recorded + // in the UnificationComputation. + if (!desiredType.kind().isTypeParam()) { + unifiedType = result.get().unifiedType().get(); + } + } + if (unifiedType.kind().isTypeParam()) { + unifiedType = unification.substitutions.get(unifiedType.name()); + return Optional.of( + unificationResult(unifiedType, ImmutableMap.of(unifiedType.name(), unifiedType))); + } + return Optional.of(unificationResult(unifiedType)); + } + + /** Determine whether the {@code types} are assignable to the {@code targetTypes}. */ + Optional> isAssignable( + List types, List targetTypes) { + if (types.size() != targetTypes.size()) { + return Optional.empty(); + } + Map intermediateSubs = new HashMap<>(); + UnificationComputation unification = unifier(substitutions, this::mostGeneralType); + for (int i = 0; i < types.size(); i++) { + CelType type = types.get(i); + CelType desiredType = targetTypes.get(i); + Optional result = unification.compute(type, desiredType); + if (!result.isPresent()) { + return Optional.empty(); + } + intermediateSubs.putAll(result.get().substitutions()); + } + return Optional.of(ImmutableMap.copyOf(intermediateSubs)); + } + + /** + * Record a set of {@code newSubstitutions} in the {@code TypeInferencer}. + * + *

When there are duplicate substitutions for the same type param, the most general type param + * type is used as the substitution value. + */ + void recordSubstitutions(Map newSubstitutions) { + // It's possible that type merging is not desired in this circumstance, but the most general + // type should be used as long as it is properly identified earlier in evaluation. + substitutions.putAll(mergeSubstitutions(substitutions, newSubstitutions, this::mergeTypes)); + } + + private UnificationComputation unifier(Map substitutions) { + return unifier(substitutions, this::mergeTypes); + } + + private UnificationComputation unifier( + Map substitutions, TypeSelectionStrategy mergeStrategy) { + return new UnificationComputation(substitutions, mergeStrategy, this::mostGeneralType); + } + + // Strategy for determining which is the most general type without actually expanding or altering + // the type definition in the result. + private Optional mostGeneralType(CelType type1, CelType type2) { + // Error types should always be returned as errors. + if (type1.kind().isError() || type2.kind().isError()) { + return Optional.of(SimpleType.ERROR); + } + // If the types are assignable then return the second type, the later type. + if (type2.isAssignableFrom(type1)) { + return Optional.of(type2); + } + // If the types are assignable then return the second type. + if (type1.isAssignableFrom(type2)) { + return Optional.of(type1); + } + // Type parameters don't need to be unified since they will have been unified + // as part of the assignability computation. + return Optional.empty(); + } + + // Strategy for determining which is the most general type which may alter the type by promoting + // the types into the narrowest union type which can contain the referenced types. + private Optional mergeTypes(CelType type1, CelType type2) { + // Default to returning the general type if one is found. + Optional generalType = mostGeneralType(type1, type2); + if (generalType.isPresent()) { + return generalType; + } + + // Otherwise search the union types in order from narrowest to broadest to determine + // whether any of the union types can represent both values. + return unionTypes.stream() + .filter(ut -> ut.isAssignableFrom(type1) && ut.isAssignableFrom(type2)) + .findFirst(); + } + + private CelType finalizeParameters(CelType type, CelType topType) { + ImmutableList params = type.parameters(); + return type.withParameters( + params.stream().map(p -> finalize(p, topType)).collect(toImmutableList())); + } + + private CelType specializeParameters(CelType type) { + ImmutableList params = type.parameters(); + return type.withParameters(params.stream().map(this::specialize).collect(toImmutableList())); + } + + // Merge the prior and current substitutions based on the + private static ImmutableMap mergeSubstitutions( + Map prevSubstitutions, + Map nextSubstitutions, + TypeSelectionStrategy mergeTypes) { + Map updated = new HashMap<>(); + updated.putAll(prevSubstitutions); + for (Map.Entry subEntry : nextSubstitutions.entrySet()) { + CelType sub = subEntry.getValue(); + CelType existingSub = updated.get(subEntry.getKey()); + if (existingSub != null) { + sub = + mergeTypes + .selectType(existingSub, sub) + .orElseThrow(() -> new NoSuchElementException("No value present")); + } + updated.put(subEntry.getKey(), sub); + } + return ImmutableMap.copyOf(updated); + } + + private static UnificationResult unificationResult(CelType unifiedType) { + return unificationResult(unifiedType, ImmutableMap.of()); + } + + private static UnificationResult unificationResult( + CelType unifiedType, ImmutableMap substitutions) { + return new AutoValue_TypeInferencer_UnificationResult(Optional.of(unifiedType), substitutions); + } + + /** + * {@code UnificationResult} indicates the {@code unifiedType} as well as a map of substitutions + * performed during type unification. + */ + @AutoValue + abstract static class UnificationResult { + + abstract Optional unifiedType(); + + abstract ImmutableMap substitutions(); + } + + private static final class UnificationComputation { + + private final Map substitutions; + + private final TypeSelectionStrategy unifyTypes; + + private final TypeSelectionStrategy mostGeneralType; + + private UnificationComputation( + Map substitutions, + TypeSelectionStrategy unifyTypes, + TypeSelectionStrategy mostGeneralType) { + this.substitutions = new HashMap<>(); + this.substitutions.putAll(substitutions); + this.unifyTypes = unifyTypes; + this.mostGeneralType = mostGeneralType; + } + + private Optional compute(CelType type, CelType desiredType) { + // First attempt type substitution for type-params. + if (desiredType.kind().isTypeParam()) { + return computeTypeParam(type, desiredType); + } + if (type.kind().isTypeParam()) { + return computeTypeParam(desiredType, type); + } + + // Pair-wise compute assignability for type parameters embedded within nearly equivalent types + ImmutableMap parameterSubstitutions = ImmutableMap.of(); + if (type.kind() == desiredType.kind() + && type.name().equals(desiredType.name()) + && type.parameters().size() == desiredType.parameters().size()) { + ImmutableList.Builder unifiedParams = ImmutableList.builder(); + ImmutableList typeParameters = type.parameters(); + ImmutableList desiredTypeParameters = desiredType.parameters(); + for (int i = 0; i < typeParameters.size(); i++) { + Optional result = + compute(typeParameters.get(i), desiredTypeParameters.get(i)); + // The intermediate comptutation indicates that type cannot be unified. + if (!result.isPresent()) { + return Optional.empty(); + } + unifiedParams.add(result.get().unifiedType().get()); + parameterSubstitutions = + mergeSubstitutions(parameterSubstitutions, result.get().substitutions(), unifyTypes); + } + ImmutableList updatedParams = unifiedParams.build(); + type = type.withParameters(updatedParams); + desiredType = desiredType.withParameters(updatedParams); + } + + // When the type assignability has been computed, if the types are assignable, return the most + // general type according to the type selection strategy provided. If the types cannot be + // assigned, return the top-type if one has been provided. + ImmutableMap parameterSubstitutionSet = parameterSubstitutions; + Optional selectedType = mostGeneralType.selectType(type, desiredType); + return selectedType.map(typeVal -> unificationResult(typeVal, parameterSubstitutionSet)); + } + + private Optional computeTypeParam(CelType type, CelType typeParam) { + Optional typeParamSub = findSubstitution(typeParam.name()); + // Update the type param mapping, if possible, otherwise return not assignable. + if (typeParamSub.isPresent()) { + UnificationComputation unification = + new UnificationComputation(substitutions, unifyTypes, unifyTypes); + Optional result = unification.compute(type, typeParamSub.get()); + // This indicates that the prior type substitution was not compatible with the current type. + if (!result.isPresent()) { + return Optional.empty(); + } + Optional unifiedType = result.get().unifiedType(); + if (unifiedType.isPresent()) { + CelType typeVal = unifiedType.get(); + substitutions.put(typeParam.name(), typeVal); + return Optional.of( + unificationResult(typeVal, ImmutableMap.of(typeParam.name(), typeVal))); + } + } + // Before recording a substitution, make sure that the type parameter is not part of the + // target type's definition. + if (!referencedIn(typeParam.name(), type)) { + substitutions.put(typeParam.name(), type); + return Optional.of(unificationResult(type, ImmutableMap.of(typeParam.name(), type))); + } + return Optional.empty(); + } + + // This is the 'occurs' check for a type parameter name within a given type. This check will + // also search all 'parameters' of the 'targetType'. + private boolean referencedIn(String typeName, CelType targetType) { + // Checking whether the type param is referenced in the other type means that the type + // parameter appears somewhere within the parameterized types of the 'targetType' argument. + if ((targetType.kind().isTypeParam() && targetType.name().equals(typeName)) + || referencedIn(typeName, targetType.parameters())) { + return true; + } + // Also ensure that the typeName is not referenced within any substitutions for the + // 'targetType' either. + return targetType.kind().isTypeParam() + && findSubstitution(targetType.name()) + .filter(sub -> referencedIn(typeName, sub)) + .isPresent(); + } + + // This is the 'occurs' check which searches a list of types for the type parameter name. + private boolean referencedIn(String typeName, ImmutableList typeSet) { + return typeSet.stream().anyMatch(t -> referencedIn(typeName, t)); + } + + private Optional findSubstitution(String typeName) { + return Optional.ofNullable(substitutions.get(typeName)); + } + } +} diff --git a/checker/src/main/java/dev/cel/checker/TypeProvider.java b/checker/src/main/java/dev/cel/checker/TypeProvider.java new file mode 100644 index 000000000..2dd5261ab --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/TypeProvider.java @@ -0,0 +1,165 @@ +// Copyright 2023 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.checker; + +import dev.cel.expr.Type; +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import java.util.Optional; +import java.util.function.Function; +import org.jspecify.annotations.Nullable; + +/** + * The {@code TypeProvider} defines methods to lookup types and enums, and resolve field types. + * + * @deprecated Use {@code CelTypeProvider} instead. + */ +@Deprecated +public interface TypeProvider { + + /** Lookup the a {@link Type} given a qualified {@code typeName}. Returns null if not found. */ + @Nullable Type lookupType(String typeName); + + /** Lookup the a {@link CelType} given a qualified {@code typeName}. Returns null if not found. */ + default Optional lookupCelType(String typeName) { + Type type = lookupType(typeName); + return Optional.ofNullable(type).map(CelProtoTypes::typeToCelType); + } + + /** Lookup the {@code Integer} enum value given an {@code enumName}. Returns null if not found. */ + @Nullable Integer lookupEnumValue(String enumName); + + /** + * Lookup the {@code FieldType} for a {@code fieldName} within a {@code type}. Returns null if not + * found. + * + *

The {@code FieldType} return value will indicate the type of the field and whether presence + * check is supported via the ('has') macro. + */ + @Nullable FieldType lookupFieldType(Type type, String fieldName); + + /** + * Lookup the {@code FieldType} for a {@code fieldName} within a {@code type}. Returns null if not + * found. + * + *

The {@code FieldType} return value will indicate the type of the field and whether presence + * check is supported via the ('has') macro. + */ + default @Nullable FieldType lookupFieldType(CelType type, String fieldName) { + return lookupFieldType(CelProtoTypes.celTypeToType(type), fieldName); + } + + /** + * Returns the field names associated with the given {@code Type}. + * + *

If the type is not a message type, or the type is not found, the result is {@code null}. + */ + default @Nullable ImmutableSet lookupFieldNames(Type type) { + throw new UnsupportedOperationException("lookupFieldNames is not implemented"); + } + + /** + * Lookup the {@code FieldType} of the named extension (specified using its full path). Returns + * null if not found. + */ + default @Nullable ExtensionFieldType lookupExtensionType(String extensionName) { + return null; // Default implementation does not find any extensions. + } + + /** Result of a {@link TypeProvider#lookupFieldType} call. */ + @AutoValue + public abstract class FieldType { + + /** The {@link Type} of the field. */ + public abstract Type type(); + + public CelType celType() { + return CelProtoTypes.typeToCelType(type()); + } + + /** Create a new {@code FieldType} instance from the provided {@code type}. */ + public static FieldType of(Type type) { + return new AutoValue_TypeProvider_FieldType(type); + } + } + + /** Result of a {@link TypeProvider#lookupExtensionType} call. */ + @AutoValue + public abstract class ExtensionFieldType { + + /** The {@link FieldType} of the extension field. */ + public abstract FieldType fieldType(); + + /** The {@link Type} of the message being extended. */ + public abstract Type messageType(); + + public static ExtensionFieldType of(Type fieldType, Type messageType) { + return new AutoValue_TypeProvider_ExtensionFieldType(FieldType.of(fieldType), messageType); + } + } + + /** + * The {@code CombinedTypeProvider} takes one or more {@code TypeProvider} instances and attempts + * to look up a {@code Type} instance for a given {@code typeName} by calling each {@code + * TypeProvider} in the order that they are provided to the constructor. + */ + final class CombinedTypeProvider implements TypeProvider { + + private final ImmutableList typeProviders; + + public CombinedTypeProvider(Iterable typeProviders) { + this.typeProviders = ImmutableList.copyOf(typeProviders); + } + + @Override + public @Nullable Type lookupType(String typeName) { + return findFirstNonNull(typeProvider -> typeProvider.lookupType(typeName)); + } + + @Override + public @Nullable Integer lookupEnumValue(String enumName) { + return findFirstNonNull(typeProvider -> typeProvider.lookupEnumValue(enumName)); + } + + @Override + public @Nullable FieldType lookupFieldType(Type type, String fieldName) { + return findFirstNonNull(typeProvider -> typeProvider.lookupFieldType(type, fieldName)); + } + + @Override + public @Nullable ImmutableSet lookupFieldNames(Type type) { + // The expectation is that only one provider will contain a reference to the provided type. + return findFirstNonNull(typeProvider -> typeProvider.lookupFieldNames(type)); + } + + @Override + public @Nullable ExtensionFieldType lookupExtensionType(String extensionName) { + return findFirstNonNull(typeProvider -> typeProvider.lookupExtensionType(extensionName)); + } + + private @Nullable T findFirstNonNull(Function lookup) { + for (TypeProvider typeProvider : typeProviders) { + T result = lookup.apply(typeProvider); + if (result != null) { + return result; + } + } + return null; + } + } +} diff --git a/checker/src/main/java/dev/cel/checker/TypeProviderLegacyImpl.java b/checker/src/main/java/dev/cel/checker/TypeProviderLegacyImpl.java new file mode 100644 index 000000000..b2ac51d95 --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/TypeProviderLegacyImpl.java @@ -0,0 +1,121 @@ +// Copyright 2022 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.checker; + +import dev.cel.expr.Type; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.annotations.Internal; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.EnumType; +import dev.cel.common.types.ProtoMessageType; +import dev.cel.common.types.StructType; +import dev.cel.common.types.TypeType; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** + * The {@code TypeProviderLegacyImpl} acts as a bridge between the old and new type provider APIs + * + *

CEL Library Internals. Do Not Use. + */ +@CheckReturnValue +@Internal +final class TypeProviderLegacyImpl implements TypeProvider { + + private final CelTypeProvider celTypeProvider; + + TypeProviderLegacyImpl(CelTypeProvider celTypeProvider) { + this.celTypeProvider = celTypeProvider; + } + + @Override + public @Nullable Type lookupType(String typeName) { + return lookupCelType(typeName).map(CelProtoTypes::celTypeToType).orElse(null); + } + + @Override + public Optional lookupCelType(String typeName) { + return celTypeProvider.findType(typeName).map(TypeType::create); + } + + @Override + public @Nullable FieldType lookupFieldType(CelType type, String fieldName) { + String messageType = type.name(); + StructType structType = + (StructType) + celTypeProvider.findType(messageType).filter(t -> t instanceof StructType).orElse(null); + if (structType == null) { + return null; + } + + return structType + .findField(fieldName) + .map(f -> FieldType.of(CelProtoTypes.celTypeToType(f.type()))) + .orElse(null); + } + + @Override + public @Nullable FieldType lookupFieldType(Type type, String fieldName) { + return lookupFieldType(CelProtoTypes.typeToCelType(type), fieldName); + } + + @Override + public @Nullable ImmutableSet lookupFieldNames(Type type) { + String messageType = type.getMessageType(); + return celTypeProvider + .findType(messageType) + .filter(t -> t instanceof StructType) + .map(t -> ((StructType) t).fieldNames()) + .orElse(null); + } + + @Override + public @Nullable Integer lookupEnumValue(String enumName) { + int dotIndex = enumName.lastIndexOf("."); + if (dotIndex < 0 || dotIndex == enumName.length() - 1) { + return null; + } + String enumTypeName = enumName.substring(0, dotIndex); + String localEnumName = enumName.substring(dotIndex + 1); + return celTypeProvider + .findType(enumTypeName) + .filter(t -> t instanceof EnumType) + .flatMap(t -> ((EnumType) t).findNumberByName(localEnumName)) + .orElse(null); + } + + @Override + public @Nullable ExtensionFieldType lookupExtensionType(String extensionName) { + Optional extension = + celTypeProvider.types().stream() + .filter(t -> t instanceof ProtoMessageType) + .map(t -> (ProtoMessageType) t) + .map(t -> t.findExtension(extensionName)) + .filter(Optional::isPresent) + .map(Optional::get) + .findFirst(); + + return extension + .map( + et -> + ExtensionFieldType.of( + CelProtoTypes.celTypeToType(et.type()), + CelProtoTypes.celTypeToType(et.messageType()))) + .orElse(null); + } +} diff --git a/checker/src/main/java/dev/cel/checker/Types.java b/checker/src/main/java/dev/cel/checker/Types.java new file mode 100644 index 000000000..4cc502cdf --- /dev/null +++ b/checker/src/main/java/dev/cel/checker/Types.java @@ -0,0 +1,544 @@ +// Copyright 2023 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.checker; + +import dev.cel.expr.Type; +import dev.cel.expr.Type.PrimitiveType; +import dev.cel.expr.Type.TypeKindCase; +import dev.cel.expr.Type.WellKnownType; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.DescriptorProtos.FieldDescriptorProto; +import com.google.protobuf.Empty; +import com.google.protobuf.NullValue; +import dev.cel.common.annotations.Internal; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.NullableType; +import dev.cel.common.types.OpaqueType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeType; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import org.jspecify.annotations.Nullable; + +/** + * Utilities for dealing with the {@link Type} proto. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class Types { + + // Message type names with well-known type equivalents or special handling. + public static final String ANY_MESSAGE = "google.protobuf.Any"; + public static final String DURATION_MESSAGE = "google.protobuf.Duration"; + public static final String LIST_VALUE_MESSAGE = "google.protobuf.ListValue"; + public static final String STRUCT_MESSAGE = "google.protobuf.Struct"; + public static final String TIMESTAMP_MESSAGE = "google.protobuf.Timestamp"; + public static final String VALUE_MESSAGE = "google.protobuf.Value"; + + // Message names for wrapper types. + public static final String BOOL_WRAPPER_MESSAGE = "google.protobuf.BoolValue"; + public static final String BYTES_WRAPPER_MESSAGE = "google.protobuf.BytesValue"; + public static final String DOUBLE_WRAPPER_MESSAGE = "google.protobuf.DoubleValue"; + public static final String FLOAT_WRAPPER_MESSAGE = "google.protobuf.FloatValue"; + public static final String INT32_WRAPPER_MESSAGE = "google.protobuf.Int32Value"; + public static final String INT64_WRAPPER_MESSAGE = "google.protobuf.Int64Value"; + public static final String STRING_WRAPPER_MESSAGE = "google.protobuf.StringValue"; + public static final String UINT32_WRAPPER_MESSAGE = "google.protobuf.UInt32Value"; + public static final String UINT64_WRAPPER_MESSAGE = "google.protobuf.UInt64Value"; + + // Static types. + public static final Type ERROR = Type.newBuilder().setError(Empty.getDefaultInstance()).build(); + public static final Type DYN = Type.newBuilder().setDyn(Empty.getDefaultInstance()).build(); + public static final Type NULL_TYPE = Type.newBuilder().setNull(NullValue.NULL_VALUE).build(); + public static final Type BOOL = create(PrimitiveType.BOOL); + public static final Type BYTES = create(PrimitiveType.BYTES); + public static final Type STRING = create(PrimitiveType.STRING); + public static final Type DOUBLE = create(PrimitiveType.DOUBLE); + public static final Type UINT64 = create(PrimitiveType.UINT64); + public static final Type INT64 = create(PrimitiveType.INT64); + public static final Type ANY = create(WellKnownType.ANY); + public static final Type TIMESTAMP = create(WellKnownType.TIMESTAMP); + public static final Type DURATION = create(WellKnownType.DURATION); + + /** Map of well-known proto messages and their CEL {@code Type} equivalents. */ + public static final ImmutableMap WELL_KNOWN_TYPE_MAP = + ImmutableMap.builder() + .put(DOUBLE_WRAPPER_MESSAGE, Types.createWrapper(Types.DOUBLE)) + .put(FLOAT_WRAPPER_MESSAGE, Types.createWrapper(Types.DOUBLE)) + .put(INT64_WRAPPER_MESSAGE, Types.createWrapper(Types.INT64)) + .put(INT32_WRAPPER_MESSAGE, Types.createWrapper(Types.INT64)) + .put(UINT64_WRAPPER_MESSAGE, Types.createWrapper(Types.UINT64)) + .put(UINT32_WRAPPER_MESSAGE, Types.createWrapper(Types.UINT64)) + .put(BOOL_WRAPPER_MESSAGE, Types.createWrapper(Types.BOOL)) + .put(STRING_WRAPPER_MESSAGE, Types.createWrapper(Types.STRING)) + .put(BYTES_WRAPPER_MESSAGE, Types.createWrapper(Types.BYTES)) + .put(TIMESTAMP_MESSAGE, Types.TIMESTAMP) + .put(DURATION_MESSAGE, Types.DURATION) + .put(STRUCT_MESSAGE, Types.createMap(Types.STRING, Types.DYN)) + .put(VALUE_MESSAGE, Types.DYN) + .put(LIST_VALUE_MESSAGE, Types.createList(Types.DYN)) + .put(ANY_MESSAGE, Types.ANY) + .buildOrThrow(); + + /** Map of primitive proto types and their CEL {@code Type} equivalents. */ + public static final ImmutableMap PRIMITIVE_TYPE_MAP = + ImmutableMap.builder() + .put(FieldDescriptorProto.Type.TYPE_DOUBLE, Types.DOUBLE) + .put(FieldDescriptorProto.Type.TYPE_FLOAT, Types.DOUBLE) + .put(FieldDescriptorProto.Type.TYPE_INT32, Types.INT64) + .put(FieldDescriptorProto.Type.TYPE_INT64, Types.INT64) + .put(FieldDescriptorProto.Type.TYPE_SINT32, Types.INT64) + .put(FieldDescriptorProto.Type.TYPE_SINT64, Types.INT64) + .put(FieldDescriptorProto.Type.TYPE_SFIXED32, Types.INT64) + .put(FieldDescriptorProto.Type.TYPE_SFIXED64, Types.INT64) + .put(FieldDescriptorProto.Type.TYPE_UINT32, Types.UINT64) + .put(FieldDescriptorProto.Type.TYPE_UINT64, Types.UINT64) + .put(FieldDescriptorProto.Type.TYPE_FIXED32, Types.UINT64) + .put(FieldDescriptorProto.Type.TYPE_FIXED64, Types.UINT64) + .put(FieldDescriptorProto.Type.TYPE_BOOL, Types.BOOL) + .put(FieldDescriptorProto.Type.TYPE_STRING, Types.STRING) + .put(FieldDescriptorProto.Type.TYPE_BYTES, Types.BYTES) + .buildOrThrow(); + + /** Create a primitive {@code Type}. */ + public static Type create(PrimitiveType type) { + return Type.newBuilder().setPrimitive(type).build(); + } + + /** Create a well-known {@code Type}. */ + public static Type create(WellKnownType type) { + return Type.newBuilder().setWellKnown(type).build(); + } + + /** Create a type {@code Type}. */ + public static Type create(Type target) { + return Type.newBuilder().setType(target).build(); + } + + /** Create a list with {@code elemType}. */ + public static Type createList(Type elemType) { + return Type.newBuilder().setListType(Type.ListType.newBuilder().setElemType(elemType)).build(); + } + + /** Create a map with {@code keyType} and {@code valueType}. */ + public static Type createMap(Type keyType, Type valueType) { + return Type.newBuilder() + .setMapType(Type.MapType.newBuilder().setKeyType(keyType).setValueType(valueType)) + .build(); + } + + /** Create a message {@code Type} for {@code messageName}. */ + public static Type createMessage(String messageName) { + return Type.newBuilder().setMessageType(messageName).build(); + } + + /** Create a type param {@code Type}. */ + public static Type createTypeParam(String name) { + return Type.newBuilder().setTypeParam(name).build(); + } + + /** Create a wrapper type for the {@code primitive}. */ + public static Type createWrapper(PrimitiveType primitive) { + return Type.newBuilder().setWrapper(primitive).build(); + } + + /** Create a wrapper type where the input is a {@code Type} of primitive types. */ + public static Type createWrapper(Type type) { + Preconditions.checkArgument(type.getTypeKindCase() == TypeKindCase.PRIMITIVE); + return createWrapper(type.getPrimitive()); + } + + /** + * Tests whether the type has error or dyn kind. Both have the property to match any type. + * + * @deprecated Use {{@link #isDynOrError(CelType)}} instead. + */ + @Deprecated + public static boolean isDynOrError(Type type) { + return isDynOrError(CelProtoTypes.typeToCelType(type)); + } + + /** Tests whether the type has error or dyn kind. Both have the property to match any type. */ + public static boolean isDynOrError(CelType type) { + switch (type.kind()) { + case ERROR: + return true; + default: + return isDyn(type); + } + } + + public static boolean isDyn(CelType type) { + switch (type.kind()) { + case DYN: + case ANY: + return true; + default: + return false; + } + } + + /** Tests whether the {@code type} is a type param. */ + private static boolean isTypeParam(CelType type) { + return type.kind().equals(CelKind.TYPE_PARAM); + } + + /** Returns the more general of two types which are known to unify. */ + public static CelType mostGeneral(CelType type1, CelType type2) { + return isEqualOrLessSpecific(type1, type2) ? type1 : type2; + } + + /** + * Checks whether type1 is assignable to type2, based on the given substitution for type + * parameters. A new substitution is returned, or null if the check fails. The given substitution + * is not modified. + */ + public static @Nullable Map isAssignable( + Map subs, CelType type1, CelType type2) { + Map subsCopy = new HashMap<>(subs); + if (internalIsAssignable(subsCopy, type1, type2)) { + return subsCopy; + } + return null; + } + + /** + * Checks whether type1 is assignable to type2, based on the given substitution for type + * parameters. A new substitution is returned, or null if the check fails. The given substitution + * is not modified. + * + * @deprecated Use {@link #isAssignable(Map, CelType, CelType)} instead. + */ + @Deprecated + public static @Nullable Map isAssignable( + Map subs, Type type1, Type type2) { + HashMap subsCopy = + subs.entrySet().stream() + .collect( + Collectors.toMap( + k -> CelProtoTypes.typeToCelType(k.getKey()), + v -> CelProtoTypes.typeToCelType(v.getValue()), + (prev, next) -> next, + HashMap::new)); + + if (internalIsAssignable( + subsCopy, CelProtoTypes.typeToCelType(type1), CelProtoTypes.typeToCelType(type2))) { + return subsCopy.entrySet().stream() + .collect( + Collectors.toMap( + k -> CelProtoTypes.celTypeToType(k.getKey()), + v -> CelProtoTypes.celTypeToType(v.getValue()), + (prev, next) -> next, + HashMap::new)); + } + + return null; + } + + /** + * Same as {@link #isAssignable(Map, Type, Type)} but performs pairwise check on lists of types. + */ + public static @Nullable Map isAssignable( + Map subs, List list1, List list2) { + Map subsCopy = new HashMap<>(subs); + if (internalIsAssignable(subsCopy, list1, list2)) { + return subsCopy; + } + return null; + } + + private static boolean internalIsAssignable( + Map subs, CelType type1, CelType type2) { + // A type is always assignable to itself. + // Early terminate the call to avoid cases of infinite recursion. + if (type1.equals(type2)) { + return true; + } + // Process type parameters. + if (isTypeParam(type2)) { + if (subs.containsKey(type2)) { + CelType t2Sub = subs.get(type2); + // Continue regular process with the assignment for type2. + if (!internalIsAssignable(subs, type1, t2Sub)) { + return false; + } + CelType t2New = mostGeneral(type1, t2Sub); + if (notReferencedIn(subs, type2, t2New)) { + subs.put(type2, t2New); + } + return true; + } + if (notReferencedIn(subs, type2, type1)) { + subs.put(type2, type1); + return true; + } + } + if (isTypeParam(type1)) { + if (subs.containsKey(type1)) { + CelType t1Sub = subs.get(type1); + // Continue regular process with the assignment for type1. + if (!internalIsAssignable(subs, t1Sub, type2)) { + return false; + } + CelType t1New = mostGeneral(t1Sub, type2); + if (notReferencedIn(subs, type1, t1New)) { + subs.put(type1, t1New); + } + return true; + } + if (notReferencedIn(subs, type1, type2)) { + subs.put(type1, type2); + return true; + } + } + // Next check for wildcard types. + if (isDynOrError(type1) || isDynOrError(type2)) { + return true; + } + + // Preserve the nullness checks of the legacy type-checker. + if (type1.kind() == CelKind.NULL_TYPE) { + return isAssignableFromNull(type2); + } + if (type2.kind() == CelKind.NULL_TYPE) { + return isAssignableFromNull(type1); + } + + if (type1.kind() != type2.kind()) { + return false; + } + + switch (type1.kind()) { + case TYPE: + // A type is a type is a type, any additional parameterization of the type cannot affect + // method resolution or assignability. + return true; + case OPAQUE: + case LIST: + case MAP: + return internalIsCandidateAssignableToTarget(subs, type1, type2); + default: + return type2.isAssignableFrom(type1); + } + } + + private static boolean internalIsAssignable( + Map subs, List list1, List list2) { + if (list1.size() != list2.size()) { + return false; + } + int i = 0; + for (CelType type : list1) { + if (!internalIsAssignable(subs, type, list2.get(i++))) { + return false; + } + } + return true; + } + + private static boolean internalIsCandidateAssignableToTarget( + Map subs, CelType candidate, CelType target) { + return candidate.name().equals(target.name()) + && internalIsAssignable(subs, candidate.parameters(), target.parameters()); + } + + private static boolean isAssignableFromNull(CelType targetType) { + switch (targetType.kind()) { + case OPAQUE: + case STRUCT: + case DURATION: + case TIMESTAMP: + return true; + default: + return targetType.isAssignableFrom(SimpleType.NULL_TYPE); + } + } + + /** + * Check whether one type is equal or less specific than the other one. A type is less specific if + * it matches the other type using the DYN type. + * + * @deprecated Use {@link #isEqualOrLessSpecific(CelType, CelType)} instead. + */ + @Deprecated + public static boolean isEqualOrLessSpecific(Type type1, Type type2) { + return isEqualOrLessSpecific( + CelProtoTypes.typeToCelType(type1), CelProtoTypes.typeToCelType(type2)); + } + + /** + * Check whether one type is equal or less specific than the other one. A type is less specific if + * it matches the other type using the DYN type. + */ + public static boolean isEqualOrLessSpecific(CelType type1, CelType type2) { + // The first type is less specific. + if (isDyn(type1) || isTypeParam(type1)) { + return true; + } + // The first type is not less specific. + if (isDyn(type2) || isTypeParam(type2)) { + return false; + } + // Types must be of the same kind to be equal. + if (type1.kind() != type2.kind()) { + return false; + } + + // With limited exceptions for ANY and JSON values, the types must agree and be equivalent in + // order to return true. + switch (type1.kind()) { + case OPAQUE: + case LIST: + case MAP: + // Both types must have the same kind and have the same name in order to be equal or less + // specific. + if (!type1.kind().equals(type2.kind())) { + return false; + } + if (!type1.name().equals(type2.name())) { + return false; + } + return isEqualOrLessSpecific(type1.parameters(), type2.parameters()); + case TYPE: + // Type values must have equal or less specific internal types. + TypeType typeType1 = (TypeType) type1; + TypeType typeType2 = (TypeType) type2; + return isEqualOrLessSpecific(typeType1.type(), typeType2.type()); + + // Message, primitive, well-known, and wrapper type names must be equal to be equivalent. + default: + return type1.equals(type2); + } + } + + private static boolean isEqualOrLessSpecific(List types1, List types2) { + if (types1.size() != types2.size()) { + return false; + } + for (int i = 0; i < types1.size(); i++) { + if (!isEqualOrLessSpecific(types1.get(i), types2.get(i))) { + return false; + } + } + return true; + } + + /** + * Check whether the type doesn't appear directly or transitively within other type. This is a + * standard requirement for type unification, commonly referred to as the "occurs check". + */ + private static boolean notReferencedIn( + Map subs, CelType type, CelType withinType) { + if (type.equals(withinType)) { + return false; + } + + if (withinType instanceof NullableType) { + return notReferencedIn(subs, type, ((NullableType) withinType).targetType()); + } + + switch (withinType.kind()) { + case TYPE_PARAM: + return !subs.containsKey(withinType) || notReferencedIn(subs, type, subs.get(withinType)); + case OPAQUE: + for (CelType typeArg : withinType.parameters()) { + if (!notReferencedIn(subs, type, typeArg)) { + return false; + } + } + return true; + case LIST: + ListType listType = (ListType) withinType; + return notReferencedIn(subs, type, listType.elemType()); + case MAP: + MapType mapType = (MapType) withinType; + return notReferencedIn(subs, type, mapType.keyType()) + && notReferencedIn(subs, type, mapType.valueType()); + case TYPE: + TypeType typeType = (TypeType) withinType; + return notReferencedIn(subs, type, typeType.type()); + default: + return true; + } + } + + /** + * Apply substitution to given type, replacing all direct and indirect occurrences of bound type + * parameters. Unbound type parameters are replaced by DYN if typeParamToDyn is true. + * + * @deprecated Use {@link #substitute(Map, CelType, boolean)} instead. + */ + @Deprecated + public static Type substitute(Map subs, Type type, boolean typeParamToDyn) { + ImmutableMap.Builder subsMap = ImmutableMap.builder(); + for (Map.Entry sub : subs.entrySet()) { + subsMap.put( + CelProtoTypes.typeToCelType(sub.getKey()), CelProtoTypes.typeToCelType(sub.getValue())); + } + return CelProtoTypes.celTypeToType( + substitute(subsMap.buildOrThrow(), CelProtoTypes.typeToCelType(type), typeParamToDyn)); + } + + /** + * Apply substitution to given type, replacing all direct and indirect occurrences of bound type + * parameters. Unbound type parameters are replaced by DYN if typeParamToDyn is true. + */ + public static CelType substitute( + Map subs, CelType type, boolean typeParamToDyn) { + if (subs.containsKey(type)) { + return substitute(subs, subs.get(type), typeParamToDyn); + } + if (typeParamToDyn && isTypeParam(type)) { + return SimpleType.DYN; + } + switch (type.kind()) { + case OPAQUE: + ImmutableList.Builder parameterTypes = new ImmutableList.Builder<>(); + for (int i = 0; i < type.parameters().size(); i++) { + parameterTypes.add(substitute(subs, type.parameters().get(i), typeParamToDyn)); + } + + if (type instanceof OptionalType) { + return OptionalType.create(parameterTypes.build().get(0)); + } + return OpaqueType.create(type.name()).withParameters(parameterTypes.build()); + case LIST: + ListType listType = (ListType) type; + return ListType.create(substitute(subs, listType.elemType(), typeParamToDyn)); + case MAP: + MapType mapType = (MapType) type; + return MapType.create( + substitute(subs, mapType.keyType(), typeParamToDyn), + substitute(subs, mapType.valueType(), typeParamToDyn)); + case TYPE: + TypeType newType = (TypeType) type; + return TypeType.create(substitute(subs, newType.type(), typeParamToDyn)); + default: + return type; + } + } + + private Types() {} +} diff --git a/checker/src/test/java/dev/cel/checker/BUILD.bazel b/checker/src/test/java/dev/cel/checker/BUILD.bazel new file mode 100644 index 000000000..22b70210d --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/BUILD.bazel @@ -0,0 +1,72 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = [ + "//:license", + ], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*Test.java"]), + resources = ["//checker/src/test/resources:baselines"], + deps = [ + "//checker", + "//checker:cel_ident_decl", + "//checker:checker_builder", + "//checker:checker_legacy_environment", + "//checker:proto_expr_visitor", + "//checker:proto_type_mask", + "//checker:standard_decl", + "//checker:type_inferencer", + "//checker:type_provider_legacy_impl", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:mutable_ast", + "//common:operator", + "//common:options", + "//common:proto_ast", + "//common:source_location", + "//common/ast", + "//common/internal:env_visitor", + "//common/internal:errors", + "//common/resources/testdata/proto3:standalone_global_enum_java_proto", + "//common/types", + "//common/types:cel_proto_types", + "//common/types:json", + "//common/types:message_type_provider", + "//common/types:type_providers", + "//compiler", + "//compiler:compiler_builder", + # "//java/com/google/testing/testsize:annotations", + "//parser:macro", + "//testing:adorner", + "//testing:cel_baseline_test_case", + "//:auto_value", + "@maven//:junit_junit", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "//:java_truth", + "@maven//:com_google_truth_extensions_truth_proto_extension", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + "medium", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/checker/src/test/java/dev/cel/checker/CelCheckerLegacyImplTest.java b/checker/src/test/java/dev/cel/checker/CelCheckerLegacyImplTest.java new file mode 100644 index 000000000..92a70c2d6 --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/CelCheckerLegacyImplTest.java @@ -0,0 +1,151 @@ +// Copyright 2024 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.checker; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import dev.cel.checker.CelStandardDeclarations.StandardFunction; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelVarDecl; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelCheckerLegacyImplTest { + + @Test + public void toCheckerBuilder_isNewInstance() { + CelCheckerBuilder celCheckerBuilder = CelCompilerFactory.standardCelCheckerBuilder(); + CelCheckerLegacyImpl celChecker = (CelCheckerLegacyImpl) celCheckerBuilder.build(); + + CelCheckerLegacyImpl.Builder newCheckerBuilder = + (CelCheckerLegacyImpl.Builder) celChecker.toCheckerBuilder(); + + assertThat(newCheckerBuilder).isNotEqualTo(celCheckerBuilder); + } + + @Test + public void toCheckerBuilder_isImmutable() { + CelCheckerBuilder originalCheckerBuilder = CelCompilerFactory.standardCelCheckerBuilder(); + CelCheckerLegacyImpl celChecker = (CelCheckerLegacyImpl) originalCheckerBuilder.build(); + originalCheckerBuilder.addLibraries(new CelCheckerLibrary() {}); + + CelCheckerLegacyImpl.Builder newCheckerBuilder = + (CelCheckerLegacyImpl.Builder) celChecker.toCheckerBuilder(); + + assertThat(newCheckerBuilder.checkerLibraries().build()).isEmpty(); + } + + @Test + public void toCheckerBuilder_singularFields_copied() { + CelStandardDeclarations subsetDecls = + CelStandardDeclarations.newBuilder().includeFunctions(StandardFunction.BOOL).build(); + CelOptions celOptions = CelOptions.current().build(); + CelContainer celContainer = CelContainer.ofName("foo"); + CelType expectedResultType = SimpleType.BOOL; + CelTypeProvider customTypeProvider = + new CelTypeProvider() { + @Override + public ImmutableList types() { + return ImmutableList.of(); + } + + @Override + public Optional findType(String typeName) { + return Optional.empty(); + } + }; + CelCheckerBuilder celCheckerBuilder = + CelCompilerFactory.standardCelCheckerBuilder() + .setOptions(celOptions) + .setContainer(celContainer) + .setResultType(expectedResultType) + .setTypeProvider(customTypeProvider) + .setStandardEnvironmentEnabled(false) + .setStandardDeclarations(subsetDecls); + CelCheckerLegacyImpl celChecker = (CelCheckerLegacyImpl) celCheckerBuilder.build(); + + CelCheckerLegacyImpl.Builder newCheckerBuilder = + (CelCheckerLegacyImpl.Builder) celChecker.toCheckerBuilder(); + + assertThat(newCheckerBuilder.standardDeclarations()).isEqualTo(subsetDecls); + assertThat(newCheckerBuilder.options()).isEqualTo(celOptions); + assertThat(newCheckerBuilder.container()).isEqualTo(celContainer); + assertThat(newCheckerBuilder.celTypeProvider()).isEqualTo(customTypeProvider); + } + + @Test + public void toCheckerBuilder_collectionProperties_copied() { + CelCheckerBuilder celCheckerBuilder = + CelCompilerFactory.standardCelCheckerBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "test", CelOverloadDecl.newGlobalOverload("test_id", SimpleType.INT))) + .addVarDeclarations(CelVarDecl.newVarDeclaration("ident", SimpleType.INT)) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addFileTypes(TestAllTypes.getDescriptor().getFile()) + .addProtoTypeMasks( + ProtoTypeMask.ofAllFields("cel.expr.conformance.proto3.TestAllTypes")) + .addLibraries(new CelCheckerLibrary() {}); + CelCheckerLegacyImpl celChecker = (CelCheckerLegacyImpl) celCheckerBuilder.build(); + + CelCheckerLegacyImpl.Builder newCheckerBuilder = + (CelCheckerLegacyImpl.Builder) celChecker.toCheckerBuilder(); + + assertThat(newCheckerBuilder.functionDecls().build()).hasSize(1); + assertThat(newCheckerBuilder.identDecls().build()).hasSize(1); + assertThat(newCheckerBuilder.protoTypeMasks().build()).hasSize(1); + assertThat(newCheckerBuilder.fileTypes().build()) + .hasSize(1); // MessageTypes and FileTypes deduped into the same file descriptor + assertThat(newCheckerBuilder.checkerLibraries().build()).hasSize(1); + } + + @Test + public void toCheckerBuilder_collectionProperties_areImmutable() { + CelCheckerBuilder celCheckerBuilder = CelCompilerFactory.standardCelCheckerBuilder(); + CelCheckerLegacyImpl celChecker = (CelCheckerLegacyImpl) celCheckerBuilder.build(); + CelCheckerLegacyImpl.Builder newCheckerBuilder = + (CelCheckerLegacyImpl.Builder) celChecker.toCheckerBuilder(); + + // Mutate the original builder containing collections + celCheckerBuilder.addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "test", CelOverloadDecl.newGlobalOverload("test_id", SimpleType.INT))); + celCheckerBuilder.addVarDeclarations(CelVarDecl.newVarDeclaration("ident", SimpleType.INT)); + celCheckerBuilder.addMessageTypes(TestAllTypes.getDescriptor()); + celCheckerBuilder.addFileTypes(TestAllTypes.getDescriptor().getFile()); + celCheckerBuilder.addProtoTypeMasks( + ProtoTypeMask.ofAllFields("cel.expr.conformance.proto3.TestAllTypes")); + celCheckerBuilder.addLibraries(new CelCheckerLibrary() {}); + + assertThat(newCheckerBuilder.functionDecls().build()).isEmpty(); + assertThat(newCheckerBuilder.identDecls().build()).isEmpty(); + assertThat(newCheckerBuilder.protoTypeMasks().build()).isEmpty(); + assertThat(newCheckerBuilder.messageTypes().build()).isEmpty(); + assertThat(newCheckerBuilder.fileTypes().build()).isEmpty(); + assertThat(newCheckerBuilder.checkerLibraries().build()).isEmpty(); + } +} diff --git a/checker/src/test/java/dev/cel/checker/CelCompilerFactoryTest.java b/checker/src/test/java/dev/cel/checker/CelCompilerFactoryTest.java new file mode 100644 index 000000000..f5de164e2 --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/CelCompilerFactoryTest.java @@ -0,0 +1,50 @@ +// Copyright 2022 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.checker; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.ast.CelExpr; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelMacro; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelCompilerFactoryTest { + + @Test + public void standardCelCheckerBuilder() { + assertThat(CelCompilerFactory.standardCelCheckerBuilder().build()).isNotNull(); + } + + @Test + public void standardCelCompilerBuilder() { + assertThat(CelCompilerFactory.standardCelCompilerBuilder().build()).isNotNull(); + } + + @Test + public void addCustomMacros_success() { + assertThat( + CelCompilerFactory.standardCelCompilerBuilder() + .addMacros( + CelMacro.newReceiverMacro( + "dummy", 0, (a, b, c) -> Optional.of(CelExpr.newBuilder().build()))) + .build()) + .isNotNull(); + } +} diff --git a/checker/src/test/java/dev/cel/checker/CelCompilerImplTest.java b/checker/src/test/java/dev/cel/checker/CelCompilerImplTest.java new file mode 100644 index 000000000..b3abc4c6b --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/CelCompilerImplTest.java @@ -0,0 +1,45 @@ +// Copyright 2024 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.checker; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompilerBuilder; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.compiler.CelCompilerImpl; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelCompilerImplTest { + + @Test + public void toCompilerBuilder_isImmutable() { + CelCompilerBuilder celCompilerBuilder = CelCompilerFactory.standardCelCompilerBuilder(); + CelCompilerImpl celCompiler = (CelCompilerImpl) celCompilerBuilder.build(); + celCompilerBuilder.addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "test", CelOverloadDecl.newGlobalOverload("test_id", SimpleType.INT))); + + CelCompilerImpl.Builder newCompilerBuilder = + (CelCompilerImpl.Builder) celCompiler.toCompilerBuilder(); + + assertThat(newCompilerBuilder).isNotEqualTo(celCompilerBuilder); + } +} diff --git a/checker/src/test/java/dev/cel/checker/CelFunctionDeclTest.java b/checker/src/test/java/dev/cel/checker/CelFunctionDeclTest.java new file mode 100644 index 000000000..662761f41 --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/CelFunctionDeclTest.java @@ -0,0 +1,91 @@ +// Copyright 2022 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.checker; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; +import static dev.cel.common.CelOverloadDecl.newMemberOverload; + +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.types.SimpleType; +import java.util.Iterator; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelFunctionDeclTest { + + @Test + public void declareGlobalFunction_success() { + CelFunctionDecl functionDecl = + newFunctionDeclaration( + "testGlobalFunction", + newGlobalOverload("overloadId", SimpleType.BOOL, SimpleType.STRING, SimpleType.ANY)); + + assertThat(functionDecl.name()).isEqualTo("testGlobalFunction"); + assertThat(functionDecl.overloads()).hasSize(1); + CelOverloadDecl overloadDecl = functionDecl.overloads().iterator().next(); + assertThat(overloadDecl.overloadId()).isEqualTo("overloadId"); + assertThat(overloadDecl.isInstanceFunction()).isFalse(); + assertThat(overloadDecl.resultType()).isEqualTo(SimpleType.BOOL); + assertThat(overloadDecl.parameterTypes()).containsExactly(SimpleType.STRING, SimpleType.ANY); + } + + @Test + public void declareMemberFunction_success() { + CelFunctionDecl functionDecl = + newFunctionDeclaration( + "testMemberFunction", + newMemberOverload("overloadId", SimpleType.TIMESTAMP, SimpleType.INT, SimpleType.UINT)); + + assertThat(functionDecl.name()).isEqualTo("testMemberFunction"); + assertThat(functionDecl.overloads()).hasSize(1); + CelOverloadDecl overloadDecl = functionDecl.overloads().iterator().next(); + assertThat(overloadDecl.overloadId()).isEqualTo("overloadId"); + assertThat(overloadDecl.isInstanceFunction()).isTrue(); + assertThat(overloadDecl.resultType()).isEqualTo(SimpleType.TIMESTAMP); + assertThat(overloadDecl.parameterTypes()).containsExactly(SimpleType.INT, SimpleType.UINT); + } + + @Test + public void declareFunction_withBuilder_success() { + CelFunctionDecl.Builder functionDeclBuilder = + CelFunctionDecl.newBuilder() + .setName("testFunction") + .addOverloads( + newMemberOverload("memberOverloadId", SimpleType.INT, SimpleType.UINT), + newGlobalOverload("globalOverloadId", SimpleType.STRING, SimpleType.BOOL)); + CelFunctionDecl functionDecl = functionDeclBuilder.build(); + + assertThat(functionDecl.name()).isEqualTo("testFunction"); + assertThat(functionDecl.overloads()).hasSize(2); + + Iterator iterator = functionDecl.overloads().iterator(); + CelOverloadDecl memberOverloadDecl = iterator.next(); + assertThat(memberOverloadDecl.overloadId()).isEqualTo("memberOverloadId"); + assertThat(memberOverloadDecl.isInstanceFunction()).isTrue(); + assertThat(memberOverloadDecl.resultType()).isEqualTo(SimpleType.INT); + assertThat(memberOverloadDecl.parameterTypes()).containsExactly(SimpleType.UINT); + + CelOverloadDecl globalOverloadDecl = iterator.next(); + assertThat(globalOverloadDecl.overloadId()).isEqualTo("globalOverloadId"); + assertThat(globalOverloadDecl.isInstanceFunction()).isFalse(); + assertThat(globalOverloadDecl.resultType()).isEqualTo(SimpleType.STRING); + assertThat(globalOverloadDecl.parameterTypes()).containsExactly(SimpleType.BOOL); + } +} diff --git a/checker/src/test/java/dev/cel/checker/CelIdentDeclTest.java b/checker/src/test/java/dev/cel/checker/CelIdentDeclTest.java new file mode 100644 index 000000000..6dd221ae1 --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/CelIdentDeclTest.java @@ -0,0 +1,96 @@ +// Copyright 2023 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.checker; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; + +import dev.cel.expr.Constant; +import dev.cel.expr.Decl; +import dev.cel.expr.Decl.IdentDecl; +import dev.cel.expr.Type; +import dev.cel.expr.Type.PrimitiveType; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.types.SimpleType; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelIdentDeclTest { + + @Test + public void celIdentBuilder_success() { + CelIdentDecl stringIdent = + CelIdentDecl.newBuilder() + .setName("ident") + .setType(SimpleType.STRING) + .setDoc("doc") + .setConstant(CelConstant.ofValue("str")) + .build(); + + assertThat(stringIdent.name()).isEqualTo("ident"); + assertThat(stringIdent.type()).isEqualTo(SimpleType.STRING); + assertThat(stringIdent.doc()).isEqualTo("doc"); + assertThat(stringIdent.constant()).hasValue(CelConstant.ofValue("str")); + } + + @Test + public void celIdentBuilder_clearConstant() { + CelIdentDecl.Builder builder = + CelIdentDecl.newBuilder() + .setName("ident") + .setType(SimpleType.STRING) + .setConstant(CelConstant.ofValue("str")); + + builder.clearConstant(); + + assertThat(builder.build().constant()).isEmpty(); + } + + @Test + public void newIdentDeclaration_success() { + CelIdentDecl intIdent = CelIdentDecl.newIdentDeclaration("ident", SimpleType.INT); + + assertThat(intIdent.name()).isEqualTo("ident"); + assertThat(intIdent.type()).isEqualTo(SimpleType.INT); + assertThat(intIdent.doc()).isEmpty(); + assertThat(intIdent.constant()).isEmpty(); + } + + @Test + public void celIdentToDecl_success() { + CelIdentDecl stringIdent = + CelIdentDecl.newBuilder() + .setName("ident") + .setType(SimpleType.STRING) + .setDoc("doc") + .setConstant(CelConstant.ofValue("str")) + .build(); + + Decl decl = CelIdentDecl.celIdentToDecl(stringIdent); + + assertThat(decl) + .isEqualTo( + Decl.newBuilder() + .setName("ident") + .setIdent( + IdentDecl.newBuilder() + .setDoc("doc") + .setType(Type.newBuilder().setPrimitive(PrimitiveType.STRING)) + .setValue(Constant.newBuilder().setStringValue("str"))) + .build()); + } +} diff --git a/checker/src/test/java/dev/cel/checker/CelIssueTest.java b/checker/src/test/java/dev/cel/checker/CelIssueTest.java new file mode 100644 index 000000000..a430ab2db --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/CelIssueTest.java @@ -0,0 +1,100 @@ +// Copyright 2022 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.checker; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import dev.cel.common.CelIssue; +import dev.cel.common.CelIssue.Severity; +import dev.cel.common.CelSource; +import dev.cel.common.CelSourceLocation; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelIssueTest { + + @Test + public void formatError_withExprId() { + CelIssue celIssue = CelIssue.formatError(1L, CelSourceLocation.of(2, 3), "Error message"); + + assertThat(celIssue.getExprId()).isEqualTo(1L); + assertThat(celIssue.getSourceLocation().getLine()).isEqualTo(2); + assertThat(celIssue.getSourceLocation().getColumn()).isEqualTo(3); + assertThat(celIssue.getSeverity()).isEqualTo(Severity.ERROR); + assertThat(celIssue.getMessage()).isEqualTo("Error message"); + } + + @Test + public void toDisplayString_narrow() throws Exception { + CelSource source = + CelSource.newBuilder("a.b\n&&arg(missing, paren").setDescription("issues-test").build(); + ImmutableList issues = + ImmutableList.of( + CelIssue.formatError(1, 1, "No such field"), + CelIssue.formatError(2, 20, "Syntax error, missing paren")); + assertThat(CelIssue.toDisplayString(issues, source)) + .isEqualTo( + "ERROR: issues-test:1:2: No such field\n" + + " | a.b\n" + + " | .^\n" + + "ERROR: issues-test:2:21: Syntax error, missing paren\n" + + " | &&arg(missing, paren\n" + + " | ....................^"); + } + + @Test + public void toDisplayString_wideAndNarrow() throws Exception { + CelSource source = CelSource.newBuilder("δ½ ε₯½ε—\nζˆ‘b很ε₯½\n").setDescription("issues-test").build(); + ImmutableList issues = + ImmutableList.of(CelIssue.formatError(2, 3, "Unexpected character 'ε₯½'")); + assertThat(CelIssue.toDisplayString(issues, source)) + .isEqualTo("ERROR: issues-test:2:4: Unexpected character 'ε₯½'\n" + " | ζˆ‘b很ε₯½\n" + " | ．.．＾"); + } + + @Test + public void toDisplayString_emojis() throws Exception { + CelSource source = + CelSource.newBuilder(" '😁' in ['😁', 'πŸ˜‘', '😦'] && in.😁") + .setDescription("issues-test") + .build(); + ImmutableList issues = + ImmutableList.of( + CelIssue.formatError( + 1, + 32, + "Syntax error: extraneous input 'in' expecting {'[', '{', '(', '.', '-', '!'," + + " 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES," + + " IDENTIFIER}"), + CelIssue.formatError(1, 35, "Syntax error: token recognition error at: '😁'"), + CelIssue.formatError(1, 36, "Syntax error: missing IDENTIFIER at ''")); + + assertThat(CelIssue.toDisplayString(issues, source)) + .isEqualTo( + "ERROR: issues-test:1:33: Syntax error: extraneous input 'in' expecting {'[', '{'," + + " '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT," + + " STRING, BYTES, IDENTIFIER}\n" + + " | '😁' in ['😁', 'πŸ˜‘', '😦'] && in.😁\n" + + " | .......．.......．....．....．......^\n" + + "ERROR: issues-test:1:36: Syntax error: token recognition error at: '😁'\n" + + " | '😁' in ['😁', 'πŸ˜‘', '😦'] && in.😁\n" + + " | .......．.......．....．....．.........οΌΎ\n" + + "ERROR: issues-test:1:37: Syntax error: missing IDENTIFIER at ''\n" + + " | '😁' in ['😁', 'πŸ˜‘', '😦'] && in.😁\n" + + " | .......．.......．....．....．.........．^"); + } +} diff --git a/checker/src/test/java/dev/cel/checker/CelOverloadDeclTest.java b/checker/src/test/java/dev/cel/checker/CelOverloadDeclTest.java new file mode 100644 index 000000000..0dd7d83df --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/CelOverloadDeclTest.java @@ -0,0 +1,107 @@ +// Copyright 2022 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.checker; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; +import static dev.cel.common.CelOverloadDecl.newMemberOverload; + +import dev.cel.expr.Decl.FunctionDecl.Overload; +import com.google.common.collect.ImmutableList; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeParamType; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelOverloadDeclTest { + @Test + public void newGlobalFunction_success() { + CelOverloadDecl overloadDecl = + newGlobalOverload( + "overloadId", + TypeParamType.create("B"), + SimpleType.STRING, + SimpleType.ANY, + TypeParamType.create("A")); + + assertThat(overloadDecl.overloadId()).isEqualTo("overloadId"); + assertThat(overloadDecl.isInstanceFunction()).isFalse(); + assertThat(overloadDecl.resultType()).isEqualTo(TypeParamType.create("B")); + assertThat(overloadDecl.parameterTypes()) + .containsExactly(SimpleType.STRING, SimpleType.ANY, TypeParamType.create("A")); + assertThat(overloadDecl.typeParameterNames()).containsExactly("A", "B"); + } + + @Test + public void newMemberFunction_success() { + CelOverloadDecl overloadDecl = + newMemberOverload( + "overloadId", + TypeParamType.create("B"), + SimpleType.STRING, + SimpleType.ANY, + TypeParamType.create("A")); + + assertThat(overloadDecl.overloadId()).isEqualTo("overloadId"); + assertThat(overloadDecl.isInstanceFunction()).isTrue(); + assertThat(overloadDecl.resultType()).isEqualTo(TypeParamType.create("B")); + assertThat(overloadDecl.parameterTypes()) + .containsExactly(SimpleType.STRING, SimpleType.ANY, TypeParamType.create("A")); + assertThat(overloadDecl.typeParameterNames()).containsExactly("A", "B"); + } + + @Test + public void toProtoOverload_withTypeParams() { + CelOverloadDecl.Builder celOverloadDeclBuilder = + CelOverloadDecl.newBuilder() + .setOverloadId("overloadId") + .setResultType(TypeParamType.create("A")) + .addParameterTypes(SimpleType.STRING, SimpleType.DOUBLE, TypeParamType.create("B")) + .setIsInstanceFunction(true); + + CelOverloadDecl celOverloadDecl = celOverloadDeclBuilder.build(); + + Overload protoOverload = CelOverloadDecl.celOverloadToOverload(celOverloadDecl); + assertThat(protoOverload.getOverloadId()).isEqualTo("overloadId"); + assertThat(protoOverload.getIsInstanceFunction()).isTrue(); + assertThat(protoOverload.getResultType()).isEqualTo(CelProtoTypes.createTypeParam("A")); + assertThat(protoOverload.getParamsList()) + .containsExactly( + CelProtoTypes.STRING, CelProtoTypes.DOUBLE, CelProtoTypes.createTypeParam("B")); + assertThat(protoOverload.getTypeParamsList()).containsExactly("A", "B"); + } + + @Test + public void setParameterTypes_doesNotDedupe() { + CelOverloadDecl overloadDecl = + CelOverloadDecl.newBuilder() + .setParameterTypes( + ImmutableList.of( + SimpleType.STRING, SimpleType.STRING, SimpleType.STRING, SimpleType.INT)) + .setOverloadId("overload_id") + .setIsInstanceFunction(true) + .setResultType(SimpleType.DYN) + .build(); + + assertThat(overloadDecl.parameterTypes()) + .containsExactly(SimpleType.STRING, SimpleType.STRING, SimpleType.STRING, SimpleType.INT) + .inOrder(); + } +} diff --git a/checker/src/test/java/dev/cel/checker/CelProtoExprVisitorTest.java b/checker/src/test/java/dev/cel/checker/CelProtoExprVisitorTest.java new file mode 100644 index 000000000..3cab304ac --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/CelProtoExprVisitorTest.java @@ -0,0 +1,290 @@ +// Copyright 2022 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.checker; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; + +import dev.cel.expr.Constant; +import dev.cel.expr.Expr; +import com.google.auto.value.AutoValue; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.Operator; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.parser.CelStandardMacro; +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelProtoExprVisitorTest { + + @AutoValue + public abstract static class VisitedReference { + public abstract Optional constant(); + + public abstract Optional identifier(); + + public abstract Optional select(); + + public abstract Optional call(); + + public abstract Optional createStruct(); + + public abstract Optional createList(); + + public abstract Optional comprehension(); + + @AutoValue.Builder + public abstract static class Builder { + public abstract Builder setConstant(Constant value); + + public abstract Builder setIdentifier(Expr.Ident value); + + public abstract Builder setSelect(Expr.Select value); + + public abstract Builder setCall(Expr.Call value); + + public abstract Builder setCreateStruct(Expr.CreateStruct value); + + public abstract Builder setCreateList(Expr.CreateList value); + + public abstract Builder setComprehension(Expr.Comprehension value); + + public abstract VisitedReference build(); + } + + public static VisitedReference.Builder newBuilder() { + return new AutoValue_CelProtoExprVisitorTest_VisitedReference.Builder(); + } + } + + private static class CelExprVisitorTestImpl extends CelProtoExprVisitor { + private final VisitedReference.Builder visitedReference = VisitedReference.newBuilder(); + + @Override + protected void visit(Expr expr, Constant constant) { + visitedReference.setConstant(constant); + } + + @Override + protected void visit(Expr expr, Expr.Ident ident) { + visitedReference.setIdentifier(ident); + } + + @Override + protected void visit(Expr expr, Expr.Select select) { + visitedReference.setSelect(select); + super.visit(expr, select); + } + + @Override + protected void visit(Expr expr, Expr.Call call) { + visitedReference.setCall(call); + super.visit(expr, call); + } + + @Override + protected void visit(Expr expr, Expr.CreateStruct createStruct) { + visitedReference.setCreateStruct(createStruct); + super.visit(expr, createStruct); + } + + @Override + protected void visit(Expr expr, Expr.CreateList createList) { + visitedReference.setCreateList(createList); + super.visit(expr, createList); + } + + @Override + protected void visit(Expr expr, Expr.Comprehension comprehension) { + visitedReference.setComprehension(comprehension); + super.visit(expr, comprehension); + } + } + + private CelExprVisitorTestImpl exprVisitorImpl; + + @Before + public void setUp() { + exprVisitorImpl = new CelExprVisitorTestImpl(); + } + + @Test + public void visitConstant() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("'a'").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setConstant(Constant.newBuilder().setStringValue("a").build()) + .build()); + } + + @Test + public void visitIdentifier() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("ident", SimpleType.INT).build(); + CelAbstractSyntaxTree ast = celCompiler.compile("ident").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setIdentifier(Expr.Ident.newBuilder().setName("ident").build()) + .build()); + } + + @Test + public void visitSelect() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("TestAllTypes{}.single_int64").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setCreateStruct( + Expr.CreateStruct.newBuilder() + .setMessageName("cel.expr.conformance.proto3.TestAllTypes") + .build()) + .setSelect( + Expr.Select.newBuilder() + .setOperand( + Expr.newBuilder() + .setId(1) + .setStructExpr( + Expr.CreateStruct.newBuilder() + .setMessageName("cel.expr.conformance.proto3.TestAllTypes") + .build())) + .setField("single_int64") + .build()) + .build()); + } + + @Test + public void visitCall() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("size('a')").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + Constant stringVal = Constant.newBuilder().setStringValue("a").build(); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setConstant(stringVal) + .setCall( + Expr.Call.newBuilder() + .setFunction("size") + .addArgs(Expr.newBuilder().setId(2).setConstExpr(stringVal)) + .build()) + .build()); + } + + @Test + public void visitCreateStruct() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("TestAllTypes{}").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setCreateStruct( + Expr.CreateStruct.newBuilder() + .setMessageName("cel.expr.conformance.proto3.TestAllTypes") + .build()) + .build()); + } + + @Test + public void visitCreateList() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("[1, 1]").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + Constant integerVal = Constant.newBuilder().setInt64Value(1).build(); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setConstant(integerVal) + .setCreateList( + Expr.CreateList.newBuilder() + .addElements(Expr.newBuilder().setId(2).setConstExpr(integerVal)) + .addElements(Expr.newBuilder().setId(3).setConstExpr(integerVal)) + .build()) + .build()); + } + + @Test + public void visitComprehension() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.ALL) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("[1, 1].all(x, x == 1)").getAst(); + + exprVisitorImpl.visit(ast); + + Expr.Comprehension comprehension = + exprVisitorImpl.visitedReference.build().comprehension().get(); + assertThat(comprehension.getIterVar()).isEqualTo("x"); + assertThat(comprehension.getIterRange().getListExpr().getElementsList()) + .containsExactly( + Expr.newBuilder() + .setId(2) + .setConstExpr(Constant.newBuilder().setInt64Value(1).build()) + .build(), + Expr.newBuilder() + .setId(3) + .setConstExpr(Constant.newBuilder().setInt64Value(1).build()) + .build()); + assertThat(comprehension.getAccuInit().getConstExpr()) + .isEqualTo(Constant.newBuilder().setBoolValue(true).build()); + assertThat(comprehension.getLoopCondition().getCallExpr().getFunction()) + .isEqualTo(Operator.NOT_STRICTLY_FALSE.getFunction()); + assertThat(comprehension.getLoopStep().getCallExpr().getFunction()) + .isEqualTo(Operator.LOGICAL_AND.getFunction()); + assertThat(comprehension.getLoopStep().getCallExpr().getArgsCount()).isEqualTo(2); + } +} diff --git a/checker/src/test/java/dev/cel/checker/CelStandardDeclarationsTest.java b/checker/src/test/java/dev/cel/checker/CelStandardDeclarationsTest.java new file mode 100644 index 000000000..17a7212a1 --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/CelStandardDeclarationsTest.java @@ -0,0 +1,275 @@ +// Copyright 2024 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.checker; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static org.junit.Assert.assertThrows; + +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.checker.CelStandardDeclarations.StandardFunction; +import dev.cel.checker.CelStandardDeclarations.StandardFunction.Overload.Arithmetic; +import dev.cel.checker.CelStandardDeclarations.StandardIdentifier; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationException; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelStandardDeclarationsTest { + + @Test + @TestParameters("{includeFunction: true, excludeFunction: true, filterFunction: true}") + @TestParameters("{includeFunction: true, excludeFunction: true, filterFunction: false}") + @TestParameters("{includeFunction: true, excludeFunction: false, filterFunction: true}") + @TestParameters("{includeFunction: false, excludeFunction: true, filterFunction: true}") + public void standardDeclaration_moreThanOneFunctionFilterSet_throws( + boolean includeFunction, boolean excludeFunction, boolean filterFunction) { + CelStandardDeclarations.Builder builder = CelStandardDeclarations.newBuilder(); + if (includeFunction) { + builder.includeFunctions(StandardFunction.ADD); + } + if (excludeFunction) { + builder.excludeFunctions(StandardFunction.SUBTRACT); + } + if (filterFunction) { + builder.filterFunctions((func, over) -> true); + } + + IllegalArgumentException e = assertThrows(IllegalArgumentException.class, builder::build); + assertThat(e) + .hasMessageThat() + .contains( + "You may only populate one of the following builder methods: includeFunctions," + + " excludeFunctions or filterFunctions"); + } + + @Test + @TestParameters("{includeIdentifier: true, excludeIdentifier: true, filterIdentifier: true}") + @TestParameters("{includeIdentifier: true, excludeIdentifier: true, filterIdentifier: false}") + @TestParameters("{includeIdentifier: true, excludeIdentifier: false, filterIdentifier: true}") + @TestParameters("{includeIdentifier: false, excludeIdentifier: true, filterIdentifier: true}") + public void standardDeclaration_moreThanOneIdentifierFilterSet_throws( + boolean includeIdentifier, boolean excludeIdentifier, boolean filterIdentifier) { + CelStandardDeclarations.Builder builder = CelStandardDeclarations.newBuilder(); + if (includeIdentifier) { + builder.includeIdentifiers(StandardIdentifier.MAP); + } + if (excludeIdentifier) { + builder.excludeIdentifiers(StandardIdentifier.BOOL); + } + if (filterIdentifier) { + builder.filterIdentifiers((ident) -> true); + } + + IllegalArgumentException e = assertThrows(IllegalArgumentException.class, builder::build); + assertThat(e) + .hasMessageThat() + .contains( + "You may only populate one of the following builder methods: includeIdentifiers," + + " excludeIdentifiers or filterIdentifiers"); + } + + @Test + public void compiler_standardEnvironmentEnabled_throwsWhenOverridingDeclarations() { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardEnvironmentEnabled(true) + .setStandardDeclarations( + CelStandardDeclarations.newBuilder() + .includeFunctions(StandardFunction.ADD, StandardFunction.SUBTRACT) + .build()) + .build()); + + assertThat(e) + .hasMessageThat() + .contains( + "setStandardEnvironmentEnabled must be set to false to override standard" + + " declarations."); + } + + @Test + public void standardDeclarations_includeFunctions() { + CelStandardDeclarations celStandardDeclaration = + CelStandardDeclarations.newBuilder() + .includeFunctions(StandardFunction.ADD, StandardFunction.SUBTRACT) + .build(); + + assertThat(celStandardDeclaration.functionDecls()) + .containsExactly( + StandardFunction.ADD.functionDecl(), StandardFunction.SUBTRACT.functionDecl()); + } + + @Test + public void standardDeclarations_excludeFunctions() { + CelStandardDeclarations celStandardDeclaration = + CelStandardDeclarations.newBuilder() + .excludeFunctions(StandardFunction.ADD, StandardFunction.SUBTRACT) + .build(); + + assertThat(celStandardDeclaration.functionDecls()) + .doesNotContain(StandardFunction.ADD.functionDecl()); + assertThat(celStandardDeclaration.functionDecls()) + .doesNotContain(StandardFunction.SUBTRACT.functionDecl()); + } + + @Test + public void standardDeclarations_filterFunctions() { + CelStandardDeclarations celStandardDeclaration = + CelStandardDeclarations.newBuilder() + .filterFunctions( + (func, over) -> { + if (func.equals(StandardFunction.ADD) && over.equals(Arithmetic.ADD_INT64)) { + return true; + } + + if (func.equals(StandardFunction.SUBTRACT) + && over.equals(Arithmetic.SUBTRACT_INT64)) { + return true; + } + + return false; + }) + .build(); + + assertThat(celStandardDeclaration.functionDecls()) + .containsExactly( + newFunctionDeclaration( + StandardFunction.ADD.functionName(), Arithmetic.ADD_INT64.celOverloadDecl()), + newFunctionDeclaration( + StandardFunction.SUBTRACT.functionName(), + Arithmetic.SUBTRACT_INT64.celOverloadDecl())); + } + + @Test + public void standardDeclarations_includeIdentifiers() { + CelStandardDeclarations celStandardDeclaration = + CelStandardDeclarations.newBuilder() + .includeIdentifiers(StandardIdentifier.INT, StandardIdentifier.UINT) + .build(); + + assertThat(celStandardDeclaration.identifierDecls()) + .containsExactly(StandardIdentifier.INT.identDecl(), StandardIdentifier.UINT.identDecl()); + } + + @Test + public void standardDeclarations_excludeIdentifiers() { + CelStandardDeclarations celStandardDeclaration = + CelStandardDeclarations.newBuilder() + .excludeIdentifiers(StandardIdentifier.INT, StandardIdentifier.UINT) + .build(); + + assertThat(celStandardDeclaration.identifierDecls()) + .doesNotContain(StandardIdentifier.INT.identDecl()); + assertThat(celStandardDeclaration.identifierDecls()) + .doesNotContain(StandardIdentifier.UINT.identDecl()); + } + + @Test + public void standardDeclarations_filterIdentifiers() { + CelStandardDeclarations celStandardDeclaration = + CelStandardDeclarations.newBuilder() + .filterIdentifiers(ident -> ident.equals(StandardIdentifier.MAP)) + .build(); + + assertThat(celStandardDeclaration.identifierDecls()) + .containsExactly(StandardIdentifier.MAP.identDecl()); + } + + @Test + public void standardEnvironment_subsetEnvironment() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardEnvironmentEnabled(false) + .setStandardDeclarations( + CelStandardDeclarations.newBuilder() + .includeFunctions(StandardFunction.ADD, StandardFunction.SUBTRACT) + .build()) + .build(); + + assertThat(celCompiler.compile("1 + 2 - 3").getAst()).isNotNull(); + CelValidationException e = + assertThrows(CelValidationException.class, () -> celCompiler.compile("1 * 2 / 3").getAst()); + assertThat(e).hasMessageThat().contains("undeclared reference to '_*_'"); + assertThat(e).hasMessageThat().contains("undeclared reference to '_/_'"); + } + + @Test + @TestParameters("{expression: '1 > 2.0'}") + @TestParameters("{expression: '2.0 > 1'}") + @TestParameters("{expression: '1 > 2u'}") + @TestParameters("{expression: '2u > 1'}") + @TestParameters("{expression: '2u > 1.0'}") + @TestParameters("{expression: '1.0 > 2u'}") + @TestParameters("{expression: '1 >= 2.0'}") + @TestParameters("{expression: '2.0 >= 1'}") + @TestParameters("{expression: '1 >= 2u'}") + @TestParameters("{expression: '2u >= 1'}") + @TestParameters("{expression: '2u >= 1.0'}") + @TestParameters("{expression: '1.0 >= 2u'}") + @TestParameters("{expression: '1 < 2.0'}") + @TestParameters("{expression: '2.0 < 1'}") + @TestParameters("{expression: '1 < 2u'}") + @TestParameters("{expression: '2u < 1'}") + @TestParameters("{expression: '2u < 1.0'}") + @TestParameters("{expression: '1.0 < 2u'}") + @TestParameters("{expression: '1 <= 2.0'}") + @TestParameters("{expression: '2.0 <= 1'}") + @TestParameters("{expression: '1 <= 2u'}") + @TestParameters("{expression: '2u <= 1'}") + @TestParameters("{expression: '2u <= 1.0'}") + @TestParameters("{expression: '1.0 <= 2u'}") + public void heterogeneousEqualityDisabled_mixedTypeComparisons_throws(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(false).build()) + .build(); + + CelValidationException e = + assertThrows(CelValidationException.class, () -> celCompiler.compile(expression).getAst()); + assertThat(e).hasMessageThat().contains("found no matching overload for"); + } + + @Test + public void unsignedLongsDisabled_int64Identity_throws() { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableUnsignedLongs(false).build()) + .build(); + + CelValidationException e = + assertThrows(CelValidationException.class, () -> celCompiler.compile("int(1)").getAst()); + assertThat(e).hasMessageThat().contains("found no matching overload for"); + } + + @Test + public void timestampEpochDisabled_int64Identity_throws() { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableTimestampEpoch(false).build()) + .build(); + + CelValidationException e = + assertThrows( + CelValidationException.class, () -> celCompiler.compile("timestamp(10000)").getAst()); + assertThat(e).hasMessageThat().contains("found no matching overload for"); + } +} diff --git a/checker/src/test/java/dev/cel/checker/DescriptorTypeProviderTest.java b/checker/src/test/java/dev/cel/checker/DescriptorTypeProviderTest.java new file mode 100644 index 000000000..11366a68b --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/DescriptorTypeProviderTest.java @@ -0,0 +1,155 @@ +// Copyright 2023 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.checker; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.expr.Type; +import com.google.common.collect.ImmutableList; +import com.google.rpc.context.AttributeContext; +import dev.cel.checker.TypeProvider.CombinedTypeProvider; +import dev.cel.checker.TypeProvider.ExtensionFieldType; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import dev.cel.expr.conformance.proto2.TestAllTypesExtensions; +import java.util.Arrays; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class DescriptorTypeProviderTest { + + @Test + public void lookupFieldNames_nonMessageType() { + TypeProvider typeProvider = new DescriptorTypeProvider(); + assertThat(typeProvider.lookupFieldNames(CelProtoTypes.STRING)).isNull(); + } + + @Test + public void lookupFieldNames_undeclaredMessageType() { + TypeProvider typeProvider = new DescriptorTypeProvider(); + assertThat( + typeProvider.lookupFieldNames( + CelProtoTypes.createMessage("google.rpc.context.AttributeContext"))) + .isNull(); + } + + @Test + public void lookupFieldNames_groupTypeField() throws Exception { + Type proto2MessageType = + CelProtoTypes.createMessage("cel.expr.conformance.proto2.TestAllTypes"); + TypeProvider typeProvider = + new DescriptorTypeProvider( + ImmutableList.of( + TestAllTypes.getDescriptor().getFile(), TestAllTypesExtensions.getDescriptor())); + assertThat(typeProvider.lookupFieldType(proto2MessageType, "nestedgroup").type()) + .isEqualTo( + CelProtoTypes.createMessage("cel.expr.conformance.proto2.TestAllTypes.NestedGroup")); + } + + @Test + public void lookupFieldNames_combinedProvider() { + final TypeProvider typeProvider = + new DescriptorTypeProvider(Arrays.asList(AttributeContext.getDescriptor().getFile())); + TypeProvider partialTypeProvider = makePartialTypeProvider(typeProvider); + TypeProvider combinedTypeProvider = + new CombinedTypeProvider(Arrays.asList(typeProvider, partialTypeProvider)); + Type attrContextType = combinedTypeProvider.lookupType("google.rpc.context.AttributeContext"); + assertThat(attrContextType).isNotNull(); + assertThat(combinedTypeProvider.lookupFieldType(attrContextType.getType(), "resource")) + .isNotNull(); + assertThat(combinedTypeProvider.lookupFieldNames(attrContextType.getType())) + .containsExactly( + "resource", + "request", + "api", + "origin", + "response", + "destination", + "source", + "extensions"); + + Assert.assertThrows( + UnsupportedOperationException.class, + () -> + combinedTypeProvider.lookupFieldNames( + Type.newBuilder().setMessageType("google.type.Expr").build())); + } + + @Test + public void lookupExtensionType_combinedProvider() { + final TypeProvider configuredProvider = + new DescriptorTypeProvider( + ImmutableList.of( + TestAllTypes.getDescriptor().getFile(), TestAllTypesExtensions.getDescriptor())); + final TypeProvider partialProvider = + // The partial provider has no extension lookup. + makePartialTypeProvider(configuredProvider); + final TypeProvider typeProvider = + new CombinedTypeProvider(ImmutableList.of(partialProvider, configuredProvider)); + final Type messageType = + CelProtoTypes.createMessage("cel.expr.conformance.proto2.TestAllTypes"); + + assertThat(typeProvider.lookupExtensionType("non.existent")).isNull(); + + ExtensionFieldType nestedExt = + typeProvider.lookupExtensionType("cel.expr.conformance.proto2.nested_ext"); + assertThat(nestedExt).isNotNull(); + assertThat(nestedExt.fieldType().type()).isEqualTo(messageType); + assertThat(nestedExt.messageType()).isEqualTo(messageType); + + ExtensionFieldType int32Ext = + typeProvider.lookupExtensionType("cel.expr.conformance.proto2.int32_ext"); + assertThat(int32Ext).isNotNull(); + assertThat(int32Ext.fieldType().type()).isEqualTo(CelProtoTypes.INT64); + assertThat(int32Ext.messageType()).isEqualTo(messageType); + + ExtensionFieldType repeatedExt = + typeProvider.lookupExtensionType("cel.expr.conformance.proto2.repeated_test_all_types"); + assertThat(repeatedExt).isNotNull(); + assertThat(repeatedExt.fieldType().type()) + .isEqualTo( + CelProtoTypes.createList( + CelProtoTypes.createMessage("cel.expr.conformance.proto2.TestAllTypes"))); + assertThat(repeatedExt.messageType()).isEqualTo(messageType); + + // With leading dot '.'. + assertThat( + typeProvider.lookupExtensionType( + ".cel.expr.conformance.proto2.repeated_test_all_types")) + .isNotNull(); + } + + private static TypeProvider makePartialTypeProvider(TypeProvider typeProvider) { + return new TypeProvider() { + @Override + public Type lookupType(String typeName) { + return typeProvider.lookupType(typeName); + } + + @Override + public Integer lookupEnumValue(String enumName) { + return typeProvider.lookupEnumValue(enumName); + } + + @Override + public FieldType lookupFieldType(Type type, String fieldName) { + return typeProvider.lookupFieldType(type, fieldName); + } + }; + } +} diff --git a/checker/src/test/java/dev/cel/checker/ExprCheckerTest.java b/checker/src/test/java/dev/cel/checker/ExprCheckerTest.java new file mode 100644 index 000000000..846201d32 --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/ExprCheckerTest.java @@ -0,0 +1,1211 @@ +// Copyright 2023 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.checker; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.collect.ImmutableList.toImmutableList; +import static dev.cel.common.types.CelProtoTypes.format; + +import dev.cel.expr.CheckedExpr; +import dev.cel.expr.Decl; +import dev.cel.expr.Expr.CreateStruct.EntryOrBuilder; +import dev.cel.expr.ExprOrBuilder; +import dev.cel.expr.Reference; +import com.google.common.base.Joiner; +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableList; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +// import com.google.testing.testsize.MediumTest; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelMutableAst; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.common.CelVarDecl; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.internal.EnvVisitable; +import dev.cel.common.internal.EnvVisitor; +import dev.cel.common.internal.Errors; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.NullableType; +import dev.cel.common.types.OpaqueType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.types.TypeParamType; +import dev.cel.common.types.TypeType; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.parser.CelMacro; +import dev.cel.testing.CelAdorner; +import dev.cel.testing.CelBaselineTestCase; +import dev.cel.testing.CelDebug; +import dev.cel.testing.testdata.proto3.StandaloneGlobalEnum; +import java.util.Arrays; +import java.util.List; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** Tests for the CEL {@link ExprChecker}. */ +// @MediumTest +@RunWith(TestParameterInjector.class) +public class ExprCheckerTest extends CelBaselineTestCase { + + /** Helper to run a test for configured instance variables. */ + private void runTest() throws Exception { + CelAbstractSyntaxTree ast = + prepareTest( + Arrays.asList( + StandaloneGlobalEnum.getDescriptor().getFile(), + TestAllTypes.getDescriptor().getFile(), + dev.cel.expr.conformance.proto2.TestAllTypes.getDescriptor().getFile())); + if (ast != null) { + testOutput() + .println( + CelDebug.toAdornedDebugString( + CelProtoAbstractSyntaxTree.fromCelAst(ast).getExpr(), + new CheckedExprAdorner( + CelProtoAbstractSyntaxTree.fromCelAst(ast).toCheckedExpr()))); + } + testOutput().println(); + } + + @SuppressWarnings("CheckReturnValue") + private void runErroneousTest(CelAbstractSyntaxTree parsedAst) { + checkArgument(!parsedAst.isChecked()); + Errors errors = new Errors("", source); + Env env = Env.unconfigured(errors, TEST_OPTIONS); + ExprChecker.typecheck(env, container, parsedAst, Optional.absent()); + testOutput().println(errors.getAllErrorsAsString()); + testOutput().println(); + } + + // Standard + // ========= + + @Test + public void standardEnvDump() throws Exception { + source = "'redundant expression so the env is constructed and can be printed'"; + runTest(); + testOutput().println(); + testOutput().println("Standard environment:"); + + ((EnvVisitable) celCompiler) + .accept( + new EnvVisitor() { + @Override + public void visitDecl(String name, List decls) { + // TODO: Remove proto to native type adaptation after changing + // interface + for (Decl decl : decls) { + if (decl.hasFunction()) { + CelFunctionDecl celFunctionDecl = + CelFunctionDecl.newFunctionDeclaration( + decl.getName(), + decl.getFunction().getOverloadsList().stream() + .map(CelOverloadDecl::overloadToCelOverload) + .collect(toImmutableList())); + testOutput().println(formatFunctionDecl(celFunctionDecl)); + } else if (decl.hasIdent()) { + CelVarDecl celVarDecl = + CelVarDecl.newVarDeclaration( + decl.getName(), CelProtoTypes.typeToCelType(decl.getIdent().getType())); + testOutput().println(formatVarDecl(celVarDecl)); + } else { + throw new IllegalArgumentException("Invalid declaration: " + decl); + } + } + } + + @Override + public void visitMacro(CelMacro macro) {} + }); + } + + // Operators + // ========= + + @Test + public void operatorsBool() throws Exception { + source = "false && !true || false ? 2 : 3"; + runTest(); + } + + @Test + public void operatorsInt64() throws Exception { + source = "1 + 2 * 3 - 1 / 2 == 6 % 1"; + runTest(); + } + + @Test + public void operatorsUInt64() throws Exception { + source = "1u + 2u * 3u - 1u / 2u == 6u % 1u"; + runTest(); + } + + @Test + public void operatorsDouble() throws Exception { + source = "1.0 + 2.0 * 3.0 - 1.0 / 2.20202 != 66.6"; + runTest(); + } + + @Test + public void operatorsString() throws Exception { + source = "\"abc\" + \"def\""; + runTest(); + } + + @Test + public void operatorsBytes() throws Exception { + source = "b\"abc\" + b\"def\""; + runTest(); + } + + @Test + public void operatorsConditional() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "false ? x.single_timestamp : null"; + runTest(); + } + + // Name References + // =============== + + @Test + public void referenceTypeRelative() throws Exception { + source = "proto3.TestAllTypes"; + container = CelContainer.ofName("cel.expr.conformance.TestAllTypes"); + runTest(); + } + + @Test + public void referenceTypeAbsolute() throws Exception { + source = ".cel.expr.conformance.proto3.TestAllTypes"; + runTest(); + + declareVariable("app.config", SimpleType.INT); + source = "[0].exists(app, .app.config == 1)"; + runTest(); + } + + @Test + public void referenceValue() throws Exception { + declareVariable( + "container.x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "x"; + container = CelContainer.ofName("container"); + runTest(); + } + + @Test + public void referenceUndefinedError() throws Exception { + source = "1 + x"; + runTest(); + } + + // Messages + // ======== + + @Test + public void anyMessage() throws Exception { + declareVariable("x", SimpleType.ANY); + declareVariable("y", NullableType.create(SimpleType.INT)); + source = + "x == google.protobuf.Any{" + + "type_url:'types.googleapis.com/cel.expr.conformance.proto3.TestAllTypes'}" + + " && x.single_nested_message.bb == 43 || x ==" + + " cel.expr.conformance.proto3.TestAllTypes{} || y < x|| x >= x"; + runTest(); + } + + @Test + public void messageFieldSelect() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = + "x.single_nested_message.bb == 43 && has(x.single_nested_message) && has(x.single_int32)" + + " && has(x.repeated_int32) && has(x.map_int64_nested_type)"; + runTest(); + } + + @Test + public void containers() throws Exception { + container = + CelContainer.newBuilder() + .setName("dev.cel.testing.testdata.proto3.StandaloneGlobalEnum") + .addAlias("p3_alias", "cel.expr.conformance.proto3") + .addAlias("foo_bar_alias", "foo.bar") + .addAlias("foo_bar_baz_alias", "foo.bar.baz") + .addAbbreviations("cel.expr.conformance.proto2", "cel.expr.conformance.proto3") + .build(); + source = "p3_alias.TestAllTypes{}"; + runTest(); + + source = "proto2.TestAllTypes{}"; + runTest(); + + source = "proto3.TestAllTypes{}"; + runTest(); + + source = "SGAR"; // From StandaloneGlobalEnum + runTest(); + + declareVariable("foo.bar", SimpleType.STRING); + declareFunction( + "baz", + memberOverload( + "foo_bar_baz_overload", ImmutableList.of(SimpleType.STRING), SimpleType.DYN)); + // Member call of "baz()" on "foo.bar" identifier + source = "foo_bar_alias.baz()"; + runTest(); + + declareFunction( + "foo.bar.baz.qux", + globalOverload("foo_bar_baz_qux_overload", ImmutableList.of(), SimpleType.DYN)); + // Global call of "foo.bar.baz.qux" as a fully qualified name + source = "foo_bar_baz_alias.qux()"; + runTest(); + } + + @Test + public void messageCreationError() throws Exception { + declareVariable("x", SimpleType.INT); + source = "x{foo: 1}"; + runTest(); + + declareVariable("y", TypeType.create(SimpleType.INT)); + source = "y{foo: 1}"; + runTest(); + + declareVariable("z", TypeType.create(StructTypeReference.create("msg_without_descriptor"))); + source = "z{foo: 1}"; + runTest(); + } + + @Test + public void messageFieldSelectError() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "x.single_nested_message.undefined == x.undefined"; + runTest(); + } + + // Lists + // ===== + + @Test + public void listOperators() throws Exception { + declareVariable( + "x", + ListType.create(StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"))); + source = "(x + x)[1].single_int32 == size(x)"; + runTest(); + + source = "x.size() == size(x)"; + runTest(); + } + + @Test + public void listRepeatedOperators() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "x.repeated_int64[x.single_int32] == 23"; + runTest(); + } + + @Test + public void listIndexTypeError() throws Exception { + declareVariable( + "x", + ListType.create(StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"))); + source = "x[1u]"; + runTest(); + } + + @Test + public void identError() throws Exception { + source = "undeclared_ident"; + runTest(); + } + + @Test + public void listElemTypeError() throws Exception { + declareVariable( + "x", + ListType.create(StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"))); + declareVariable("y", ListType.create(SimpleType.INT)); + source = "x + y"; + runTest(); + } + + // Maps + // ==== + + @Test + public void mapOperators() throws Exception { + declareVariable( + "x", + MapType.create( + SimpleType.STRING, + StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"))); + source = "x[\"a\"].single_int32 == 23"; + runTest(); + + source = "x.size() == size(x)"; + runTest(); + } + + @Test + public void mapIndexTypeError() throws Exception { + declareVariable( + "x", + MapType.create( + SimpleType.STRING, + StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"))); + source = "x[2].single_int32 == 23"; + runTest(); + } + + @Test + public void mapEmpty() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "size(x.map_int64_nested_type) == 0"; + runTest(); + } + + // Wrappers + // ======== + + @Test + public void wrapper() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "x.single_int64_wrapper + 1 != 23"; + runTest(); + } + + @Test + public void equalsWrapper() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = + "x.single_int64_wrapper == 1 && " + + "x.single_int32_wrapper != 2 && " + + "x.single_double_wrapper != 2.0 && " + + "x.single_float_wrapper == 1.0 && " + + "x.single_uint32_wrapper == 1u && " + + "x.single_uint64_wrapper != 42u"; + runTest(); + } + + // Nullable + // ======== + + @Test + public void nullableWrapper() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "x.single_int64_wrapper == null"; + runTest(); + } + + @Test + public void nullableMessage() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "x.single_nested_message != null"; + runTest(); + + container = CelContainer.ofName("cel.expr.conformance.proto3.TestAllTypesProto"); + source = "null == TestAllTypes{} || TestAllTypes{} == null"; + runTest(); + } + + @Test + public void nullNull() throws Exception { + source = "null == null && null != null"; + runTest(); + } + + @Test + public void nullablePrimitiveError() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "x.single_int64 != null"; + runTest(); + } + + // Dynamic Types + // ============= + + @Test + public void dynOperators() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "x.single_value + 1 / x.single_struct.y == 23"; + runTest(); + } + + @Test + public void dynOperatorsAtRuntime() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + source = "x.single_value[23] + x.single_struct['y']"; + runTest(); + } + + @Test + public void flexibleTypeAdaption() throws Exception { + source = "size([] + [1])"; + runTest(); + + source = "[1] + [dyn('string')]"; + runTest(); + + source = "[dyn('string')] + [1]"; + runTest(); + + source = "([[[1]], [[2]], [[3]]][0][0] + [2, 3, {'four': {'five': 'six'}}])[3]"; + runTest(); + + declareVariable("a", TypeParamType.create("T")); + source = "a.b + 1 == a[0]"; + runTest(); + + CelType keyParam = TypeParamType.create("A"); + CelType valParam = TypeParamType.create("B"); + CelType mapType = MapType.create(keyParam, valParam); + declareFunction( + "merge", globalOverload("merge_maps", ImmutableList.of(mapType, mapType), mapType)); + source = "merge({'hello': dyn(1)}, {'world': 2.0})"; + runTest(); + + source = "1 in dyn([1, 2, 3])"; + runTest(); + } + + @Test + public void userFunctionOverlappingOverloadsError() throws Exception { + declareFunction( + "func", + memberOverload("overlapping_overload_1", ImmutableList.of(SimpleType.INT), SimpleType.INT), + memberOverload("overlapping_overload_2", ImmutableList.of(SimpleType.INT), SimpleType.INT)); + source = "func(1)"; + runTest(); + } + + // Json Types + // ========== + + @Test + public void jsonType() throws Exception { + declareVariable("x", StructTypeReference.create("google.protobuf.Struct")); + declareVariable("y", StructTypeReference.create("google.protobuf.ListValue")); + declareVariable("z", StructTypeReference.create("google.protobuf.Value")); + source = + "x[\"claims\"][\"groups\"][0].name == \"dummy\" " + + "&& x.claims[\"exp\"] == y[1].time " + + "&& x.claims.structured == {'key': z} " + + "&& z == 1.0"; + runTest(); + } + + @Test + public void jsonTypeNullConstruction() throws Exception { + // Ok + source = "google.protobuf.Value{null_value: google.protobuf.NullValue.NULL_VALUE}"; + runTest(); + + // Error + source = "google.protobuf.Value{null_value: null}"; + runTest(); + + // Ok + source = "cel.expr.conformance.proto3.TestAllTypes{single_value: null}"; + runTest(); + + // Ok but not expected (int coerced to double/json number 0.0) + source = + "cel.expr.conformance.proto3.TestAllTypes{single_value:" + + " google.protobuf.NullValue.NULL_VALUE}"; + runTest(); + + // Error + source = "cel.expr.conformance.proto3.TestAllTypes{null_value: null}"; + runTest(); + + // Ok + source = + "cel.expr.conformance.proto3.TestAllTypes{null_value:" + + " google.protobuf.NullValue.NULL_VALUE}"; + runTest(); + } + + @Test + public void jsonTypeNullAccess() throws Exception { + source = "google.protobuf.Value{null_value: google.protobuf.NullValue.NULL_VALUE} == null"; + runTest(); + + source = "cel.expr.conformance.proto3.TestAllTypes{single_value: null}.single_value == null"; + runTest(); + + source = + "cel.expr.conformance.proto3.TestAllTypes{single_value:" + + " google.protobuf.NullValue.NULL_VALUE}.single_value == null"; + runTest(); + + // Error + source = + "cel.expr.conformance.proto3.TestAllTypes{null_value:" + + " google.protobuf.NullValue.NULL_VALUE}.null_value == null"; + runTest(); + + // Ok + source = + "cel.expr.conformance.proto3.TestAllTypes{null_value:" + + " google.protobuf.NullValue.NULL_VALUE}.null_value == 0"; + runTest(); + + // Error + source = "google.protobuf.NullValue.NULL_VALUE == null"; + runTest(); + + // Ok + source = "google.protobuf.NullValue.NULL_VALUE == 0"; + runTest(); + } + + // Call Style and User Functions + // ============================= + + @Test + public void callStyle() throws Exception { + CelType param = TypeParamType.create("A"); + // Note, the size() function here is added in a separate scope from the standard declaration + // set, but the environment ensures that the standard and custom overloads are returned together + // during function resolution time. + declareFunction( + "size", + memberOverload("my_size", ImmutableList.of(ListType.create(param)), SimpleType.INT)); + declareVariable("x", ListType.create(SimpleType.INT)); + source = "size(x) == x.size()"; + runTest(); + } + + @Test + public void userFunction() throws Exception { + declareFunction( + "myfun", + memberOverload( + "myfun_instance", + ImmutableList.of(SimpleType.INT, SimpleType.BOOL, SimpleType.UINT), + SimpleType.INT), + globalOverload( + "myfun_static", + ImmutableList.of(SimpleType.INT, SimpleType.BOOL, SimpleType.UINT), + SimpleType.INT)); + source = "myfun(1, true, 3u) + 1.myfun(false, 3u).myfun(true, 42u)"; + runTest(); + } + + @Test + public void namespacedFunctions() throws Exception { + declareFunction( + "ns.func", + globalOverload("ns_func_overload", ImmutableList.of(SimpleType.STRING), SimpleType.INT)); + source = "ns.func('hello')"; + runTest(); + + declareFunction( + "member", + memberOverload( + "ns_member_overload", + ImmutableList.of(SimpleType.INT, SimpleType.INT), + SimpleType.INT)); + + source = "ns.func('hello').member(ns.func('test'))"; + runTest(); + + source = "{ns.func('test'): 2}"; + runTest(); + + source = "{2: ns.func('test')}"; + runTest(); + + source = "[ns.func('test'), 2]"; + runTest(); + + source = "[ns.func('test')].map(x, x * 2)"; + runTest(); + + source = "[1, 2].map(x, x * ns.func('test'))"; + runTest(); + + container = CelContainer.ofName("ns"); + source = "func('hello')"; + runTest(); + + source = "func('hello').member(func('test'))"; + runTest(); + } + + @Test + public void namespacedVariables() throws Exception { + container = CelContainer.ofName("ns"); + declareVariable("ns.x", SimpleType.INT); + source = "x"; + runTest(); + + container = CelContainer.ofName("cel.expr.conformance.proto3"); + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("cel.expr.conformance.proto3.msgVar", messageType); + source = "msgVar.single_int32"; + runTest(); + } + + @Test + public void userFunctionMultipleOverloadsWithSanitization() throws Exception { + CelType structType = StructTypeReference.create("google.protobuf.Struct"); + declareVariable("s", structType); + declareFunction( + "myfun", + globalOverload("myfun_int", ImmutableList.of(SimpleType.INT), SimpleType.INT), + globalOverload("myfun_struct", ImmutableList.of(structType), SimpleType.INT)); + source = "myfun(1) + myfun(s)"; + runTest(); + } + + @Test + public void userFunctionOverlaps() throws Exception { + CelType param = TypeParamType.create("TEST"); + // Note, the size() function here shadows the definition of the size() function in the standard + // declaration set. The type param name is chosen as 'TEST' to make sure not to conflict with + // the standard environment type param name for the same overload signature. + declareFunction( + "size", + globalOverload("my_size", ImmutableList.of(ListType.create(param)), SimpleType.UINT)); + declareVariable("x", ListType.create(SimpleType.INT)); + source = "size(x) == 1u"; + runTest(); + } + + @Test + public void userFunctionAddsOverload() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + declareFunction( + "size", globalOverload("size_message", ImmutableList.of(messageType), SimpleType.INT)); + source = "size(x) > 4"; + runTest(); + } + + @Test + public void userFunctionAddsMacroError() throws Exception { + declareFunction( + "has", globalOverload("has_id", ImmutableList.of(SimpleType.DYN), SimpleType.DYN)); + source = "false"; + runTest(); + } + + // Proto2 + // ====== + + @Test + public void proto2PrimitiveField() throws Exception { + declareVariable("x", StructTypeReference.create("cel.expr.conformance.proto2.TestAllTypes")); + source = "x.single_fixed32 != 0u && x.single_fixed64 > 1u && x.single_int32 != null"; + runTest(); + source = "x.nestedgroup.single_name == ''"; + runTest(); + } + + // Aggregates + // ========== + + @Test + public void aggregateMessage() throws Exception { + container = CelContainer.ofName("cel.expr.conformance.proto3"); + source = "TestAllTypes{single_int32: 1, single_int64: 2}"; + runTest(); + } + + @Test + public void aggregateMessageFieldUndefinedError() throws Exception { + container = CelContainer.ofName("cel.expr.conformance.proto3"); + source = "TestAllTypes{single_int32: 1, undefined: 2}"; + runTest(); + } + + @Test + public void aggregateMessageFieldTypeError() throws Exception { + container = CelContainer.ofName("cel.expr.conformance.proto3"); + source = "TestAllTypes{single_int32: 1u}"; + runTest(); + } + + @Test + public void aggregateList() throws Exception { + source = "[] + [1,2,3,] + [4]"; + runTest(); + } + + @Test + public void aggregateListDyn() throws Exception { + source = "[1, 2u]"; + expectedType = ListType.create(SimpleType.DYN); + runTest(); + } + + @Test + public void aggregateMap() throws Exception { + source = "{1:2u, 2:3u}"; + runTest(); + } + + @Test + public void aggregateMapDyn() throws Exception { + source = "{1:2u, 2u:3}"; + expectedType = MapType.create(SimpleType.DYN, SimpleType.DYN); + runTest(); + } + + @Test + public void aggregateMapDynValue() throws Exception { + source = "{1:2u, 2:3}"; + expectedType = MapType.create(SimpleType.INT, SimpleType.DYN); + runTest(); + } + + @Test + public void aggregateMapDynKey() throws Exception { + source = "{1:2, 2u:3}"; + expectedType = MapType.create(SimpleType.DYN, SimpleType.INT); + runTest(); + } + + @Test + public void aggregateMapFieldSelection() throws Exception { + source = "{\"a\":1, \"b\":2}.a"; + runTest(); + } + + // Expected and Unexpected Types + // ============================= + + @Test + public void expectedAggregateList() throws Exception { + source = "[] + [1,2,3,] + [4]"; + expectedType = ListType.create(SimpleType.INT); + runTest(); + } + + @Test + public void unexpectedAggregateMapError() throws Exception { + source = "{1:2u, 2:3u}"; + expectedType = MapType.create(SimpleType.INT, SimpleType.BOOL); + runTest(); + } + + // Type Denotations + // ================ + + @Test + public void types() throws Exception { + source = "list == type([1]) && map == type({1:2u})"; + runTest(); + source = "{}.map(c,[c,type(c)])"; + runTest(); + } + + // Enum Values + // =========== + + @Test + public void enumValues() throws Exception { + container = CelContainer.ofName("cel.expr.conformance.proto3"); + source = "TestAllTypes.NestedEnum.BAR != 99"; + runTest(); + } + + @Test + public void nestedEnums() throws Exception { + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + container = CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage()); + source = "x.single_nested_enum == TestAllTypes.NestedEnum.BAR"; + runTest(); + + declareVariable("single_nested_enum", SimpleType.INT); + source = "single_nested_enum == TestAllTypes.NestedEnum.BAR"; + runTest(); + + source = + "TestAllTypes{single_nested_enum : TestAllTypes.NestedEnum.BAR}.single_nested_enum == 1"; + runTest(); + } + + @Test + public void globalEnumValues() throws Exception { + container = CelContainer.ofName("cel.expr.conformance.proto3"); + source = "GlobalEnum.GAZ == 2"; + runTest(); + } + + // Global Enum Values in separate file. + // =========== + + @Test + public void globalStandaloneEnumValues() throws Exception { + container = CelContainer.ofName("dev.cel.testing.testdata.proto3"); + source = "StandaloneGlobalEnum.SGAZ == 2"; + + FileDescriptorSet.Builder descriptorBuilder = FileDescriptorSet.newBuilder(); + descriptorBuilder.addFile(StandaloneGlobalEnum.getDescriptor().getFile().toProto()); + CelAbstractSyntaxTree ast = prepareTest(descriptorBuilder.build()); + if (ast != null) { + testOutput() + .println( + CelDebug.toAdornedDebugString( + CelProtoAbstractSyntaxTree.fromCelAst(ast).getExpr(), + new CheckedExprAdorner( + CelProtoAbstractSyntaxTree.fromCelAst(ast).toCheckedExpr()))); + } + } + + // Conversions + // =========== + + @Test + public void conversions() throws Exception { + source = "int(1u) + int(uint(\"1\"))"; + runTest(); + } + + // Comprehensions + // ============== + + @Test + public void quantifiers() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = + "x.repeated_int64.all(e, e > 0) " + + "&& x.repeated_int64.exists(e, e < 0) " + + "&& x.repeated_int64.exists_one(e, e == 0)"; + runTest(); + } + + @Test + public void twoVarComprehensions_allMacro() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = + "x.map_string_string.all(i, v, i < v) " + + "&& x.repeated_int64.all(i, v, i < v) " + + "&& [1, 2, 3, 4].all(i, v, i < 5 && v > 0) " + + "&& {'a': 1, 'b': 2}.all(k, v, k.startsWith('a') && v == 1)"; + runTest(); + } + + @Test + public void twoVarComprehensions_existsMacro() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = + "x.map_string_string.exists(i, v, i < v) " + + "&& x.repeated_int64.exists(i, v, i < v) " + + "&& [1, 2, 3, 4].exists(i, v, i < 5 && v > 0) " + + "&& {'a': 1, 'b': 2}.exists(k, v, k.startsWith('a') && v == 1)"; + runTest(); + } + + @Test + public void twoVarComprehensions_existsOneMacro() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = + "x.map_string_string.exists_one(i, v, i < v) " + + "&& x.repeated_int64.exists_one(i, v, i < v) " + + "&& [1, 2, 3, 4].exists_one(i, v, i < 5 && v > 0) " + + "&& {'a': 1, 'b': 2}.exists_one(k, v, k.startsWith('a') && v == 1)"; + runTest(); + } + + @Test + public void twoVarComprehensions_transformListMacro() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = + "[1, 2, 3].transformList(i, v, i > 0 && v < 3, (i * v) + v) == [4] " + + "&& [1, 2, 3].transformList(i, v, i % 2 == 0, (i * v) + v) == [1,9] " + + "&& [1, 2, 3].transformList(i, v, (i * v) + v) == [1,4,9]"; + runTest(); + } + + @Test + public void twoVarComprehensions_incorrectIterVars() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = "x.map_string_string.all(i + 1, v, i < v) && x.repeated_int64.all(i, v + 1, i < v)"; + runTest(); + } + + @Test + public void twoVarComprehensions_duplicateIterVars() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = "x.repeated_int64.exists(i, i, i < v)"; + runTest(); + } + + @Test + public void twoVarComprehensions_incorrectNumberOfArgs() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = + "[1, 2, 3, 4].exists_one(i, v, i < v, v)" + + "&& x.map_string_string.transformList(i, i < v) " + + "&& [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4]"; + runTest(); + } + + @Test + public void quantifiersErrors() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = "x.all(e, 0)"; + runTest(); + } + + @Test + public void mapExpr() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = "x.repeated_int64.map(x, double(x))"; + runTest(); + + source = "[].map(x, [].map(y, x in y && y in x))"; + runTest(); + + source = "[{}.map(c,c,c)]+[{}.map(c,c,c)]"; + runTest(); + } + + @Test + public void mapFilterExpr() throws Exception { + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("x", messageType); + source = "x.repeated_int64.map(x, x > 0, double(x))"; + runTest(); + + declareVariable("lists", SimpleType.DYN); + source = "lists.filter(x, x > 1.5)"; + runTest(); + + declareVariable("args", MapType.create(SimpleType.STRING, SimpleType.DYN)); + source = "args.user[\"myextension\"].customAttributes.filter(x, x.name == \"hobbies\")"; + runTest(); + } + + // Abstract Types + // ============== + + @Test + public void abstractTypeParameterLess() throws Exception { + CelType abstractType = OpaqueType.create("abs"); + // Declare the identifier 'abs' to bind to the abstract type. + declareVariable("abs", TypeType.create(abstractType)); + // Declare a function to create a new value of abstract type. + declareFunction("make_abs", globalOverload("make_abs", ImmutableList.of(), abstractType)); + // Declare a function to consume value of abstract type. + declareFunction( + "as_bool", memberOverload("as_bool", ImmutableList.of(abstractType), SimpleType.BOOL)); + + source = "type(make_abs()) == abs && make_abs().as_bool()"; + runTest(); + } + + @Test + public void abstractTypeParameterized() throws Exception { + CelType typeParam = TypeParamType.create("T"); + CelType abstractType = OpaqueType.create("vector", typeParam); + TypeType typeOfTypeParam = TypeType.create(typeParam); + TypeType typeOfAbstractType = TypeType.create(abstractType); + + declareFunction( + "vector", + // Declare the function 'vector' to create the abstract type. + globalOverload("vector_type", ImmutableList.of(typeOfTypeParam), typeOfAbstractType), + // Declare a function to create a new value of abstract type based on a list. + globalOverload("vector_list", ImmutableList.of(ListType.create(typeParam)), abstractType)); + + // Declare a function to consume value of abstract type. + declareFunction( + "at", + memberOverload("vector_at_int", ImmutableList.of(abstractType, SimpleType.INT), typeParam)); + + // The parameterization of 'vector(dyn)' is erased at runtime and so is checked as a 'vector', + // but no further. + source = "type(vector([1])) == vector(dyn) && vector([1]).at(0) == 1"; + runTest(); + } + + @Test + public void abstractTypeParameterizedInListLiteral() throws Exception { + CelType typeParam = TypeParamType.create("T"); + CelType abstractType = OpaqueType.create("vector", typeParam); + TypeType typeOfAbstractType = TypeType.create(abstractType); + TypeType typeOfTypeParam = TypeType.create(typeParam); + + declareFunction( + "vector", + // Declare the function 'vector' to create the abstract type. + globalOverload("vector_type", ImmutableList.of(typeOfTypeParam), typeOfAbstractType), + // Declare a function to create a new value of abstract type based on a list. + globalOverload("vector_list", ImmutableList.of(ListType.create(typeParam)), abstractType)); + + source = "size([vector([1, 2]), vector([2u, -1])]) == 2"; + runTest(); + } + + @Test + public void abstractTypeParameterizedError() throws Exception { + CelType typeParam = TypeParamType.create("T"); + CelType abstractType = OpaqueType.create("vector", typeParam); + TypeType typeOfAbstractType = TypeType.create(abstractType); + TypeType typeOfTypeParam = TypeType.create(typeParam); + + declareFunction( + "vector", + // Declare the function 'vector' to create the abstract type. + globalOverload("vector_type", ImmutableList.of(typeOfTypeParam), typeOfAbstractType), + // Declare a function to create a new value of abstract type based on a list. + globalOverload("vector_list", ImmutableList.of(ListType.create(typeParam)), abstractType)); + declareFunction( + "add", + globalOverload( + "add_vector_type", + ImmutableList.of(typeOfAbstractType, typeOfAbstractType), + typeOfAbstractType)); + source = "add(vector([1, 2]), vector([2u, -1])) == vector([1, 2, 2u, -1])"; + runTest(); + } + + // Optionals + @Test + public void optionals() throws Exception { + declareVariable("a", MapType.create(SimpleType.STRING, SimpleType.STRING)); + source = "a.?b"; + runTest(); + + clearAllDeclarations(); + declareVariable("x", OptionalType.create(MapType.create(SimpleType.STRING, SimpleType.STRING))); + source = "x.y"; + runTest(); + + source = "{?'nested': x.b}"; + runTest(); + + clearAllDeclarations(); + declareVariable("d", OptionalType.create(SimpleType.DYN)); + source = "d.dynamic"; + runTest(); + + source = "has(d.dynamic)"; + runTest(); + + clearAllDeclarations(); + declareVariable("e", OptionalType.create(MapType.create(SimpleType.STRING, SimpleType.DYN))); + source = "has(e.?b.c)"; + runTest(); + + clearAllDeclarations(); + source = "{?'key': {'a': 'b'}.?value}"; + runTest(); + + source = "{?'key': {'a': 'b'}.?value}.key"; + runTest(); + + container = CelContainer.ofName("cel.expr.conformance.proto3"); + source = "TestAllTypes{?single_int32: {}.?i}"; + runTest(); + + container = CelContainer.ofName(""); + declareVariable("a", OptionalType.create(SimpleType.STRING)); + declareVariable("b", OptionalType.create(SimpleType.STRING)); + source = "[?a, ?b, 'world']"; + runTest(); + + source = "[?a, ?b, 2]"; + runTest(); + + source = "{?'str':a, 2:3}"; + runTest(); + } + + @Test + public void optionalErrors() throws Exception { + source = "{?'key': 'hi'}"; + runTest(); + + source = "[?'value']"; + runTest(); + + container = CelContainer.ofName("cel.expr.conformance.proto3"); + source = "TestAllTypes{?single_int32: 1}"; + runTest(); + + source = "a.?b"; + declareVariable("a", MapType.create(SimpleType.STRING, SimpleType.STRING)); + prepareCompiler(new ProtoMessageTypeProvider()); + CelAbstractSyntaxTree parsedAst = celCompiler.parse(source).getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(parsedAst); + mutableAst.expr().call().args().get(1).setConstant(CelConstant.ofValue(true)); + + runErroneousTest(mutableAst.toParsedAst()); + } + + private static class CheckedExprAdorner implements CelAdorner { + + private final CheckedExpr checkedExpr; + + private CheckedExprAdorner(CheckedExpr checkedExpr) { + this.checkedExpr = checkedExpr; + } + + @Override + public String adorn(ExprOrBuilder expr) { + return adorn(expr.getId()); + } + + @Override + public String adorn(EntryOrBuilder entry) { + return adorn(entry.getId()); + } + + private String adorn(long exprId) { + String adorned = ""; + if (checkedExpr.containsTypeMap(exprId)) { + adorned = String.format("~%s", format(checkedExpr.getTypeMapOrThrow(exprId))); + } + if (checkedExpr.containsReferenceMap(exprId)) { + adorned = + String.format("%s^%s", adorned, print(checkedExpr.getReferenceMapOrThrow(exprId))); + } + return adorned; + } + + private String print(Reference reference) { + if (reference.getOverloadIdCount() > 0) { + return Joiner.on("|").join(reference.getOverloadIdList()); + } + return reference.getName(); + } + } +} diff --git a/checker/src/test/java/dev/cel/checker/ProtoTypeMaskTest.java b/checker/src/test/java/dev/cel/checker/ProtoTypeMaskTest.java new file mode 100644 index 000000000..89241652c --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/ProtoTypeMaskTest.java @@ -0,0 +1,112 @@ +// Copyright 2022 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.checker; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.protobuf.FieldMask; +import dev.cel.checker.ProtoTypeMask.FieldPath; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class ProtoTypeMaskTest { + + @Test + public void ofType() { + ProtoTypeMask typeExpr = ProtoTypeMask.ofAllFields("google.type.Expr"); + assertThat(typeExpr.getTypeName()).isEqualTo("google.type.Expr"); + assertThat(typeExpr.areAllFieldPathsExposed()).isTrue(); + assertThat(typeExpr.getFieldPathsExposed()) + .containsExactly(FieldPath.of(ProtoTypeMask.WILDCARD_FIELD)); + } + + @Test + public void ofType_emptyType() { + assertThrows(IllegalArgumentException.class, () -> ProtoTypeMask.ofAllFields("")); + } + + @Test + public void ofType_nullType() { + assertThrows(IllegalArgumentException.class, () -> ProtoTypeMask.ofAllFields(null)); + } + + @Test + public void ofTypeWithFieldMask() { + ProtoTypeMask typeExpr = + ProtoTypeMask.of( + "google.type.Expr", + FieldMask.newBuilder().addPaths("expression").addPaths("description").build()); + assertThat(typeExpr.getTypeName()).isEqualTo("google.type.Expr"); + assertThat(typeExpr.areAllFieldPathsExposed()).isFalse(); + assertThat(typeExpr.getFieldPathsExposed()) + .containsExactly(FieldPath.of("expression"), FieldPath.of("description")); + } + + @Test + public void ofTypeWithFieldMask_complexMask() { + ProtoTypeMask typeExpr = + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder().addPaths("resource.name").build()); + assertThat(typeExpr.areAllFieldPathsExposed()).isFalse(); + assertThat(typeExpr.getFieldPathsExposed()).containsExactly(FieldPath.of("resource.name")); + } + + @Test + public void ofTypeWithFieldMask_emptyMask() { + assertThat(ProtoTypeMask.of("test", FieldMask.getDefaultInstance()).areAllFieldPathsExposed()) + .isTrue(); + } + + @Test + public void ofTypeWithFieldMask_nullMask() { + assertThat(ProtoTypeMask.of("test", null).areAllFieldPathsExposed()).isTrue(); + } + + @Test + public void ofTypeWithFieldMask_invalidMask() { + assertThrows( + IllegalArgumentException.class, + () -> ProtoTypeMask.of("test", FieldMask.newBuilder().addPaths("").build())); + } + + @Test + public void ofAllFieldsHidden() { + ProtoTypeMask typeExpr = ProtoTypeMask.ofAllFieldsHidden("google.rpc.context.AttributeContext"); + assertThat(typeExpr.areAllFieldPathsExposed()).isFalse(); + assertThat(typeExpr.getFieldPathsExposed()) + .containsExactly(FieldPath.of(ProtoTypeMask.HIDDEN_FIELD)); + } + + @Test + public void withFieldsAsVariableDeclarations() { + assertThat(ProtoTypeMask.ofAllFields("google.type.Expr").fieldsAreVariableDeclarations()) + .isFalse(); + assertThat( + ProtoTypeMask.ofAllFields("google.type.Expr") + .withFieldsAsVariableDeclarations() + .fieldsAreVariableDeclarations()) + .isTrue(); + } + + @Test + public void fieldPathOf() { + assertThat(FieldPath.of("resource.name").getFieldSelection()) + .containsExactly("resource", "name"); + } +} diff --git a/checker/src/test/java/dev/cel/checker/ProtoTypeMaskTypeProviderTest.java b/checker/src/test/java/dev/cel/checker/ProtoTypeMaskTypeProviderTest.java new file mode 100644 index 000000000..b4b52bd26 --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/ProtoTypeMaskTypeProviderTest.java @@ -0,0 +1,311 @@ +// Copyright 2022 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.checker; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.FieldMask; +import com.google.rpc.context.AttributeContext; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.MapType; +import dev.cel.common.types.ProtoMessageType; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructType.Field; +import java.util.Arrays; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class ProtoTypeMaskTypeProviderTest { + + private static final String ATTRIBUTE_CONTEXT_TYPE = "google.rpc.context.AttributeContext"; + private static final String RESOURCE_TYPE = "google.rpc.context.AttributeContext.Resource"; + private static final String REQUEST_TYPE = "google.rpc.context.AttributeContext.Request"; + private static final String AUTH_TYPE = "google.rpc.context.AttributeContext.Auth"; + + @Test + public void protoTypeMaskProvider_badFieldMask() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(Arrays.asList(AttributeContext.getDescriptor())); + assertThrows( + IllegalArgumentException.class, + () -> + new ProtoTypeMaskTypeProvider( + celTypeProvider, + ImmutableSet.of( + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder().addPaths("missing").build())))); + } + + @Test + public void lookupFieldNames_undeclaredMessageType() { + CelTypeProvider celTypeProvider = new ProtoMessageTypeProvider(); + ProtoTypeMaskTypeProvider protoTypeMaskProvider = + new ProtoTypeMaskTypeProvider(celTypeProvider, ImmutableSet.of()); + assertThat(protoTypeMaskProvider.findType(ATTRIBUTE_CONTEXT_TYPE)).isEmpty(); + } + + @Test + public void lookupFieldNames_noProtoDecls() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(ImmutableSet.of(AttributeContext.getDescriptor())); + ProtoTypeMaskTypeProvider protoTypeMaskProvider = + new ProtoTypeMaskTypeProvider(celTypeProvider, ImmutableSet.of()); + ProtoMessageType protoType = assertTypeFound(protoTypeMaskProvider, ATTRIBUTE_CONTEXT_TYPE); + assertThat(protoType.fields().stream().map(Field::name).collect(toImmutableList())) + .containsExactly( + "resource", + "request", + "response", + "origin", + "source", + "destination", + "extensions", + "api"); + + ProtoMessageType origProtoType = assertTypeFound(celTypeProvider, ATTRIBUTE_CONTEXT_TYPE); + assertThat(protoType).isSameInstanceAs(origProtoType); + } + + @Test + public void lookupFieldNames_allFieldsHidden() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(ImmutableSet.of(AttributeContext.getDescriptor())); + ProtoTypeMaskTypeProvider protoTypeMaskProvider = + new ProtoTypeMaskTypeProvider( + celTypeProvider, + ImmutableSet.of(ProtoTypeMask.ofAllFieldsHidden(ATTRIBUTE_CONTEXT_TYPE))); + + ProtoMessageType protoType = assertTypeFound(protoTypeMaskProvider, ATTRIBUTE_CONTEXT_TYPE); + assertThat(protoType.fieldNames()).isEmpty(); + ProtoMessageType origProtoType = assertTypeFound(celTypeProvider, ATTRIBUTE_CONTEXT_TYPE); + assertThat(protoType).isNotSameInstanceAs(origProtoType); + } + + @Test + public void protoTypeMaskProvider_hiddenFieldSentinelCharOnSubPath_throws() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(ImmutableSet.of(AttributeContext.getDescriptor())); + + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> + new ProtoTypeMaskTypeProvider( + celTypeProvider, + ImmutableSet.of( + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder().addPaths("resource.!").build())))); + assertThat(e) + .hasMessageThat() + .contains("message google.rpc.context.AttributeContext.Resource does not declare field: !"); + } + + @Test + public void lookupFieldNames_fullProtoDecl() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(ImmutableSet.of(AttributeContext.getDescriptor())); + ProtoTypeMaskTypeProvider protoTypeMaskProvider = + new ProtoTypeMaskTypeProvider( + celTypeProvider, ImmutableSet.of(ProtoTypeMask.ofAllFields(ATTRIBUTE_CONTEXT_TYPE))); + ProtoMessageType protoType = assertTypeFound(protoTypeMaskProvider, ATTRIBUTE_CONTEXT_TYPE); + assertTypeHasFields( + protoType, + ImmutableSet.of( + "resource", + "request", + "response", + "origin", + "source", + "destination", + "extensions", + "api")); + ProtoMessageType origProtoType = assertTypeFound(celTypeProvider, ATTRIBUTE_CONTEXT_TYPE); + assertThat(protoType).isSameInstanceAs(origProtoType); + } + + @Test + public void lookupFieldNames_partialProtoDecl() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(ImmutableSet.of(AttributeContext.getDescriptor())); + ProtoTypeMaskTypeProvider protoTypeMaskProvider = + new ProtoTypeMaskTypeProvider( + celTypeProvider, + ImmutableSet.of( + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder() + .addPaths("resource.name") + .addPaths("resource.type") + .build()))); + ProtoMessageType maskedType = assertTypeFound(protoTypeMaskProvider, ATTRIBUTE_CONTEXT_TYPE); + assertTypeHasFields(maskedType, ImmutableSet.of("resource")); + + ProtoMessageType fullType = assertTypeFound(celTypeProvider, ATTRIBUTE_CONTEXT_TYPE); + assertTypeHasFields( + fullType, + ImmutableSet.of( + "resource", + "request", + "response", + "origin", + "source", + "destination", + "extensions", + "api")); + + maskedType = assertTypeFound(protoTypeMaskProvider, RESOURCE_TYPE); + assertTypeHasFields(maskedType, ImmutableSet.of("name", "type")); + + fullType = assertTypeFound(celTypeProvider, RESOURCE_TYPE); + assertTypeHasFields( + fullType, + ImmutableSet.of( + "type", + "display_name", + "labels", + "name", + "annotations", + "etag", + "location", + "create_time", + "service", + "uid", + "update_time", + "delete_time")); + } + + @Test + public void computeDecls() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(Arrays.asList(AttributeContext.getDescriptor())); + ProtoTypeMaskTypeProvider protoTypeMaskProvider = + new ProtoTypeMaskTypeProvider( + celTypeProvider, + ImmutableSet.of( + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder() + .addPaths("resource.name") + .addPaths("resource.type") + .addPaths("request.path") + .build()) + .withFieldsAsVariableDeclarations())); + + ProtoMessageType resourceType = + (ProtoMessageType) celTypeProvider.findType(RESOURCE_TYPE).get(); + ProtoMessageType requestType = (ProtoMessageType) celTypeProvider.findType(REQUEST_TYPE).get(); + assertThat(protoTypeMaskProvider.computeDeclsFromProtoTypeMasks()) + .containsExactly( + CelIdentDecl.newBuilder().setName("resource").setType(resourceType).build(), + CelIdentDecl.newBuilder().setName("request").setType(requestType).build()); + } + + @Test + public void lookupFieldType() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(ImmutableSet.of(AttributeContext.getDescriptor())); + ProtoTypeMaskTypeProvider protoTypeMaskProvider = + new ProtoTypeMaskTypeProvider( + celTypeProvider, + ImmutableSet.of( + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder() + .addPaths("resource.name") + .addPaths("resource.type") + .addPaths("request.path") + .addPaths("request.auth.*") + .build()))); + ProtoMessageType ctxType = assertTypeFound(protoTypeMaskProvider, ATTRIBUTE_CONTEXT_TYPE); + assertThat(ctxType.findField("resource")).isPresent(); + assertTypeHasFieldWithType(ctxType, "resource", RESOURCE_TYPE); + assertTypeHasFieldWithType(ctxType, "request", REQUEST_TYPE); + + ProtoMessageType resourceType = (ProtoMessageType) ctxType.findField("resource").get().type(); + assertTypeHasFieldWithType(resourceType, "name", "string"); + assertTypeHasFieldWithType(resourceType, "type", "string"); + + ProtoMessageType requestType = (ProtoMessageType) ctxType.findField("request").get().type(); + assertTypeHasFieldWithType(requestType, "path", "string"); + assertTypeHasFieldWithType(requestType, "auth", AUTH_TYPE); + + ProtoMessageType authType = (ProtoMessageType) requestType.findField("auth").get().type(); + assertTypeHasFieldWithType(authType, "principal", "string"); + assertTypeHasFieldWithType(authType, "claims", "map"); + + assertThat(authType.findField("claims").get().type()) + .isEqualTo(MapType.create(SimpleType.STRING, SimpleType.DYN)); + } + + @Test + public void lookupFieldType_notExposedField() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(ImmutableSet.of(AttributeContext.getDescriptor())); + ProtoTypeMaskTypeProvider protoTypeMaskProvider = + new ProtoTypeMaskTypeProvider( + celTypeProvider, + ImmutableSet.of( + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder().addPaths("resource.name").build()))); + ProtoMessageType resourceType = assertTypeFound(protoTypeMaskProvider, RESOURCE_TYPE); + assertThat(resourceType.findField("type")).isEmpty(); + } + + @Test + public void lookupType_notExposed() { + CelTypeProvider celTypeProvider = + new ProtoMessageTypeProvider(ImmutableSet.of(AttributeContext.getDescriptor())); + ProtoTypeMaskTypeProvider protoTypeMaskProvider = + new ProtoTypeMaskTypeProvider( + celTypeProvider, + ImmutableSet.of( + ProtoTypeMask.of( + "google.rpc.context.AttributeContext", + FieldMask.newBuilder().addPaths("resource.name").build()))); + assertThat(protoTypeMaskProvider.findType(REQUEST_TYPE)).isPresent(); + } + + private ProtoMessageType assertTypeFound(CelTypeProvider celTypeProvider, String typeName) { + Optional foundType = celTypeProvider.findType(typeName); + assertThat(foundType).isPresent(); + CelType celType = foundType.get(); + assertThat(celType).isInstanceOf(ProtoMessageType.class); + return (ProtoMessageType) celType; + } + + private void assertTypeHasFields(ProtoMessageType protoType, ImmutableSet fields) { + ImmutableSet typeFieldNames = + protoType.fields().stream().map(Field::name).collect(toImmutableSet()); + assertThat(typeFieldNames).containsExactlyElementsIn(fields); + } + + private void assertTypeHasFieldWithType( + ProtoMessageType protoType, String fieldName, String typeName) { + assertThat(protoType.findField(fieldName)).isPresent(); + assertThat(protoType.findField(fieldName).get().type().name()).isEqualTo(typeName); + } +} diff --git a/checker/src/test/java/dev/cel/checker/TypeInferencerTest.java b/checker/src/test/java/dev/cel/checker/TypeInferencerTest.java new file mode 100644 index 000000000..ee167def7 --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/TypeInferencerTest.java @@ -0,0 +1,412 @@ +// Copyright 2022 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.checker; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import dev.cel.checker.TypeInferencer.UnificationResult; +import dev.cel.common.types.CelType; +import dev.cel.common.types.JsonType; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.NullableType; +import dev.cel.common.types.OpaqueType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructType; +import dev.cel.common.types.TypeParamType; +import dev.cel.common.types.TypeType; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class TypeInferencerTest { + + private static final ImmutableList UNION_TYPES = + ImmutableList.of( + NullableType.create(SimpleType.BOOL), + NullableType.create(SimpleType.BYTES), + NullableType.create(SimpleType.DOUBLE), + NullableType.create(SimpleType.INT), + NullableType.create(SimpleType.STRING), + NullableType.create(SimpleType.UINT), + JsonType.JSON, + SimpleType.DYN); + + private TypeInferencer inferencer; + private TypeVarGenerator typeVarGenerator; + + @Before + public void setUp() { + typeVarGenerator = new TypeVarGenerator(); + inferencer = new TypeInferencer(UNION_TYPES); + } + + @Test + public void unify_success_parameterizedMap() { + MapType mapParam = MapType.create(TypeParamType.create("K"), TypeParamType.create("V")); + MapType mapInst = MapType.create(SimpleType.STRING, ListType.create(TypeParamType.create("V"))); + MapType mapParamFresh = (MapType) mapParam.withFreshTypeParamVariables(typeVarGenerator); + Optional result = inferencer.unify(mapInst, mapParamFresh); + assertThat(result).isPresent(); + assertThat(result.get().substitutions()) + .containsExactly( + mapParamFresh.keyType().name(), + SimpleType.STRING, + mapParamFresh.valueType().name(), + ListType.create(TypeParamType.create("V"))); + inferencer.recordSubstitutions(result.get().substitutions()); + assertThat(inferencer.specialize(mapParamFresh)).isEqualTo(mapInst); + } + + @Test + public void unify_success_parameterizedMapReversedArgs() { + MapType mapParam = MapType.create(TypeParamType.create("K"), TypeParamType.create("V")); + MapType mapInst = MapType.create(SimpleType.STRING, ListType.create(TypeParamType.create("V"))); + MapType mapParamFresh = (MapType) mapParam.withFreshTypeParamVariables(typeVarGenerator); + Optional result = inferencer.unify(mapParamFresh, mapInst); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(mapInst); + assertThat(result.get().substitutions()) + .containsExactly( + mapParamFresh.keyType().name(), + SimpleType.STRING, + mapParamFresh.valueType().name(), + ListType.create(TypeParamType.create("V"))); + inferencer.recordSubstitutions(result.get().substitutions()); + assertThat(inferencer.specialize(mapParamFresh)).isEqualTo(mapInst); + } + + @Test + public void unify_success_jsonEqualsDoubleOneByOne() { + TypeParamType equalsArg = TypeParamType.create("T"); + CelType equalsArgFresh = equalsArg.withFreshTypeParamVariables(typeVarGenerator); + Optional firstArg = inferencer.unify(JsonType.JSON, equalsArgFresh); + assertThat(firstArg).isPresent(); + assertThat(firstArg.get().unifiedType()).hasValue(JsonType.JSON); + inferencer.recordSubstitutions(firstArg.get().substitutions()); + Optional secondArg = inferencer.unify(SimpleType.DOUBLE, equalsArgFresh); + assertThat(secondArg).isPresent(); + assertThat(secondArg.get().unifiedType()).hasValue(JsonType.JSON); + inferencer.recordSubstitutions(secondArg.get().substitutions()); + assertThat(inferencer.specialize(equalsArgFresh)).isEqualTo(JsonType.JSON); + } + + @Test + public void unify_success_jsonEqualsDoubleOneByOneDifferentInferencer() { + TypeParamType equalsArg = TypeParamType.create("T"); + CelType equalsArgFresh = equalsArg.withFreshTypeParamVariables(typeVarGenerator); + Optional firstArg = inferencer.unify(JsonType.JSON, equalsArgFresh); + assertThat(firstArg).isPresent(); + assertThat(firstArg.get().unifiedType()).hasValue(JsonType.JSON); + TypeInferencer inferencer2 = new TypeInferencer(UNION_TYPES, firstArg.get().substitutions()); + Optional secondArg = inferencer2.unify(SimpleType.DOUBLE, equalsArgFresh); + assertThat(secondArg).isPresent(); + assertThat(secondArg.get().unifiedType()).hasValue(JsonType.JSON); + inferencer2.recordSubstitutions(secondArg.get().substitutions()); + assertThat(inferencer2.specialize(equalsArgFresh)).isEqualTo(JsonType.JSON); + } + + @Test + public void unify_success_jsonToDouble() { + Optional result = inferencer.unify(JsonType.JSON, SimpleType.DOUBLE); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(JsonType.JSON); + } + + @Test + public void unify_success_doubleToJson() { + Optional result = inferencer.unify(SimpleType.DOUBLE, JsonType.JSON); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(JsonType.JSON); + } + + @Test + public void unify_false_nestedTypeParamReference() { + TypeParamType typeParamArg = TypeParamType.create("T"); + ListType listType = ListType.create(typeParamArg); + Optional result = inferencer.unify(typeParamArg, listType); + assertThat(result).isEmpty(); + } + + @Test + public void unify_success_dynOrErrorYieldsError() { + Optional result = inferencer.unify(SimpleType.DYN, SimpleType.ERROR); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(SimpleType.ERROR); + } + + @Test + public void unify_success_doubleNullToNullableDoubleWithTypeParam() { + CelType outputType = TypeParamType.create("O").withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify(ImmutableList.of(SimpleType.DOUBLE, SimpleType.NULL_TYPE), outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(NullableType.create(SimpleType.DOUBLE)); + } + + @Test + public void unify_success_doubleNullToNullableDoubleWithConcreteType() { + CelType outputType = NullableType.create(SimpleType.DOUBLE); + Optional result = + inferencer.unify(ImmutableList.of(SimpleType.DOUBLE, SimpleType.NULL_TYPE), outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(outputType); + } + + @Test + public void unify_success_doubleNullStringToJson() { + CelType outputType = TypeParamType.create("O").withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify( + ImmutableList.of(SimpleType.DOUBLE, SimpleType.NULL_TYPE, SimpleType.STRING), + outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(JsonType.JSON); + } + + @Test + public void unify_success_doubleNullStringToDyn() { + TypeInferencer inferencer = new TypeInferencer(ImmutableList.of(SimpleType.DYN)); + CelType outputType = TypeParamType.create("O").withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify( + ImmutableList.of(SimpleType.DOUBLE, SimpleType.NULL_TYPE, SimpleType.STRING), + outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(SimpleType.DYN); + } + + @Test + public void unify_false_doubleNullStringNoJsonNoTopType() { + TypeInferencer inferencer = new TypeInferencer(ImmutableList.of()); + CelType outputType = TypeParamType.create("O").withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify( + ImmutableList.of(SimpleType.DOUBLE, SimpleType.NULL_TYPE, SimpleType.STRING), + outputType); + assertThat(result).isEmpty(); + } + + @Test + public void unify_success_abstractTypeListToJsonParam() { + OpaqueType setListDouble = OpaqueType.create("set", ListType.create(SimpleType.DOUBLE)); + OpaqueType setString = OpaqueType.create("set", SimpleType.STRING); + CelType outputType = TypeParamType.create("O").withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify(ImmutableList.of(setListDouble, setString), outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(OpaqueType.create("set", JsonType.JSON)); + } + + @Test + public void unify_success_abstractTypeMapToMapJsonParam() { + OpaqueType setListDouble = + OpaqueType.create("set", MapType.create(SimpleType.STRING, SimpleType.DOUBLE)); + OpaqueType setString = + OpaqueType.create("set", MapType.create(SimpleType.STRING, SimpleType.STRING)); + CelType outputType = TypeParamType.create("O").withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify(ImmutableList.of(setListDouble, setString), outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()) + .hasValue(OpaqueType.create("set", MapType.create(SimpleType.STRING, JsonType.JSON))); + } + + @Test + public void unify_success_abstractTypeMapToJsonParam() { + OpaqueType setListDouble = + OpaqueType.create("set", MapType.create(SimpleType.STRING, SimpleType.DOUBLE)); + OpaqueType setString = OpaqueType.create("set", SimpleType.STRING); + CelType outputType = TypeParamType.create("0").withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify(ImmutableList.of(setListDouble, setString), outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(OpaqueType.create("set", JsonType.JSON)); + } + + @Test + public void unify_success_opaqueTypeMapToDynParam() { + TypeInferencer inferencer = new TypeInferencer(ImmutableList.of(SimpleType.DYN)); + OpaqueType setListDouble = + OpaqueType.create("set", MapType.create(SimpleType.STRING, SimpleType.DOUBLE)); + OpaqueType setString = OpaqueType.create("set", SimpleType.STRING); + CelType outputType = TypeParamType.create("O").withFreshTypeParamVariables(typeVarGenerator); + // The current ExprChecker would normally return DYN as the result for the overall type, + // but this type inferencer is able to be more fine-grained about where it allows DYN + // to enter into the type resolution. + Optional result = + inferencer.unify(ImmutableList.of(setListDouble, setString), outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(OpaqueType.create("set", SimpleType.DYN)); + } + + @Test + public void unify_success_jsonIntSetsToDynSet() { + OpaqueType setJson = OpaqueType.create("set", JsonType.JSON); + OpaqueType setInt = OpaqueType.create("set", SimpleType.INT); + CelType outputType = TypeParamType.create("O").withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify(ImmutableList.of(setJson, setInt), outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(OpaqueType.create("set", SimpleType.DYN)); + } + + @Test + public void unify_success_nullableStruct() { + StructType structType = + StructType.create("my.struct.Type", ImmutableSet.of(), (fieldName) -> Optional.empty()); + NullableType nullableStructType = NullableType.create(structType); + CelType outputType = TypeParamType.create("O").withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify(ImmutableList.of(nullableStructType, structType), outputType); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(nullableStructType); + } + + @Test + public void unify_false_differentKinds() { + OpaqueType vectorType = OpaqueType.create("vector", SimpleType.STRING); + assertThat(inferencer.unify(JsonType.JSON, vectorType)).isEmpty(); + } + + @Test + public void unify_false_sameKindDifferentTypeName() { + OpaqueType setType = OpaqueType.create("set", SimpleType.STRING); + OpaqueType vectorType = OpaqueType.create("vector", SimpleType.STRING); + assertThat(inferencer.unify(setType, vectorType)).isEmpty(); + } + + @Test + public void unify_false_sameTypeDifferentParameterTypes() { + OpaqueType setType = OpaqueType.create("set", SimpleType.INT); + OpaqueType vectorType = OpaqueType.create("set", SimpleType.STRING); + assertThat(inferencer.unify(setType, vectorType)).isEmpty(); + } + + @Test + public void unify_false_sameTypeDifferentParameterCounts() { + OpaqueType setType = OpaqueType.create("set", SimpleType.INT); + OpaqueType vectorType = OpaqueType.create("set", SimpleType.INT, SimpleType.INT); + assertThat(inferencer.unify(setType, vectorType)).isEmpty(); + } + + @Test + public void isAssignable_success_jsonSelect() { + MapType mapParam = MapType.create(TypeParamType.create("K"), TypeParamType.create("V")); + MapType mapInst = MapType.create(SimpleType.STRING, JsonType.JSON); + MapType mapParamFresh = (MapType) mapParam.withFreshTypeParamVariables(typeVarGenerator); + Optional> result = + inferencer.isAssignable( + ImmutableList.of(mapInst, SimpleType.STRING), + ImmutableList.of(mapParamFresh, mapParamFresh.keyType())); + assertThat(result).isPresent(); + assertThat(result.get()) + .containsExactly( + mapParamFresh.keyType().name(), + SimpleType.STRING, + mapParamFresh.valueType().name(), + JsonType.JSON); + inferencer.recordSubstitutions(result.get()); + assertThat(inferencer.specialize(mapParamFresh.valueType())).isEqualTo(JsonType.JSON); + } + + @Test + public void isAssignable_success_jsonEqualsDoubleAsList() { + TypeParamType equalsArg = TypeParamType.create("T"); + CelType equalsArgFresh = equalsArg.withFreshTypeParamVariables(typeVarGenerator); + Optional> result = + inferencer.isAssignable( + ImmutableList.of(JsonType.JSON, SimpleType.DOUBLE), + ImmutableList.of(equalsArgFresh, equalsArgFresh)); + assertThat(result).isPresent(); + inferencer.recordSubstitutions(result.get()); + assertThat(inferencer.specialize(equalsArgFresh)).isEqualTo(JsonType.JSON); + } + + @Test + public void isAssignable_success_doubleEqualsJsonAsList() { + TypeParamType equalsArg = TypeParamType.create("T"); + CelType equalsArgFresh = equalsArg.withFreshTypeParamVariables(typeVarGenerator); + Optional> result = + inferencer.isAssignable( + ImmutableList.of(SimpleType.DOUBLE, JsonType.JSON), + ImmutableList.of(equalsArgFresh, equalsArgFresh)); + assertThat(result).isPresent(); + inferencer.recordSubstitutions(result.get()); + assertThat(inferencer.specialize(equalsArgFresh)).isEqualTo(JsonType.JSON); + } + + @Test + public void isAssignable_false_doubleEqualsString() { + TypeParamType equalsArg = TypeParamType.create("T"); + CelType equalsArgFresh = equalsArg.withFreshTypeParamVariables(typeVarGenerator); + Optional> result = + inferencer.isAssignable( + ImmutableList.of(SimpleType.DOUBLE, SimpleType.STRING), + ImmutableList.of(equalsArgFresh, equalsArgFresh)); + assertThat(result).isEmpty(); + } + + @Test + public void isAssignable_false_sameTypeDifferentParameterCounts() { + OpaqueType setType = OpaqueType.create("set", SimpleType.STRING); + OpaqueType setType2 = OpaqueType.create("set", SimpleType.STRING, SimpleType.INT); + Optional> result = + inferencer.isAssignable(setType.parameters(), setType2.parameters()); + assertThat(result).isEmpty(); + } + + @Test + public void finalize_success_typeFinalize() { + StructType structType = + StructType.create("my.struct.Type", ImmutableSet.of(), (fieldName) -> Optional.empty()); + TypeType typeOfStructType = TypeType.create(structType); + TypeType typeOfType = TypeType.create(TypeParamType.create("T")); + CelType typeOfTypeWithFreshVars = typeOfType.withFreshTypeParamVariables(typeVarGenerator); + Optional result = + inferencer.unify(typeOfStructType, typeOfTypeWithFreshVars); + assertThat(result).isPresent(); + assertThat(result.get().unifiedType()).hasValue(typeOfStructType); + inferencer.recordSubstitutions(result.get().substitutions()); + assertThat(inferencer.finalize(typeOfTypeWithFreshVars, SimpleType.DYN)) + .isEqualTo(typeOfStructType); + } + + @Test + public void finalize_success_dynFromTypeParam() { + assertThat(inferencer.finalize(TypeParamType.create("T"), SimpleType.DYN)) + .isEqualTo(SimpleType.DYN); + } + + private static class TypeVarGenerator implements Function { + private int typeVarId = 1; + Map generatedNames = new HashMap<>(); + + @Override + public String apply(String name) { + return generatedNames.computeIfAbsent( + name, (unused) -> String.format("@type_var_%d", typeVarId++)); + } + } +} diff --git a/checker/src/test/java/dev/cel/checker/TypeProviderLegacyImplTest.java b/checker/src/test/java/dev/cel/checker/TypeProviderLegacyImplTest.java new file mode 100644 index 000000000..4569877c3 --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/TypeProviderLegacyImplTest.java @@ -0,0 +1,133 @@ +// Copyright 2022 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.checker; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; + +import dev.cel.expr.Type; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Descriptors.Descriptor; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class TypeProviderLegacyImplTest { + + private static final ImmutableList DESCRIPTORS = + ImmutableList.of(TestAllTypes.getDescriptor(), Proto2ExtensionScopedMessage.getDescriptor()); + + private final ProtoMessageTypeProvider proto2Provider = new ProtoMessageTypeProvider(DESCRIPTORS); + + private final DescriptorTypeProvider descriptorTypeProvider = + new DescriptorTypeProvider(DESCRIPTORS); + + private final TypeProviderLegacyImpl compatTypeProvider = + new TypeProviderLegacyImpl(proto2Provider); + + @Test + public void lookupType() { + assertThat(compatTypeProvider.lookupType("cel.expr.conformance.proto2.TestAllTypes")) + .isEqualTo(descriptorTypeProvider.lookupType("cel.expr.conformance.proto2.TestAllTypes")); + assertThat(compatTypeProvider.lookupType("not.registered.TypeName")) + .isEqualTo(descriptorTypeProvider.lookupType("not.registered.TypeName")); + } + + @Test + public void lookupFieldNames() { + Type nestedTestAllTypes = + compatTypeProvider.lookupType("cel.expr.conformance.proto2.NestedTestAllTypes").getType(); + ImmutableSet fieldNames = compatTypeProvider.lookupFieldNames(nestedTestAllTypes); + assertThat(fieldNames) + .containsExactlyElementsIn(descriptorTypeProvider.lookupFieldNames(nestedTestAllTypes)); + assertThat(fieldNames).containsExactly("payload", "child"); + } + + @Test + public void lookupFieldType() { + Type nestedTestAllTypes = + compatTypeProvider.lookupType("cel.expr.conformance.proto2.NestedTestAllTypes").getType(); + assertThat(compatTypeProvider.lookupFieldType(nestedTestAllTypes, "payload")) + .isEqualTo(descriptorTypeProvider.lookupFieldType(nestedTestAllTypes, "payload")); + assertThat(compatTypeProvider.lookupFieldType(nestedTestAllTypes, "child")) + .isEqualTo(descriptorTypeProvider.lookupFieldType(nestedTestAllTypes, "child")); + } + + @Test + public void lookupFieldType_inputNotMessage() { + Type globalEnumType = + compatTypeProvider.lookupType("cel.expr.conformance.proto2.GlobalEnum").getType(); + assertThat(compatTypeProvider.lookupFieldType(globalEnumType, "payload")).isNull(); + assertThat(compatTypeProvider.lookupFieldType(globalEnumType, "payload")) + .isEqualTo(descriptorTypeProvider.lookupFieldType(globalEnumType, "payload")); + } + + @Test + public void lookupExtension() { + TypeProvider.ExtensionFieldType extensionType = + compatTypeProvider.lookupExtensionType("cel.expr.conformance.proto2.nested_enum_ext"); + assertThat(extensionType.messageType()) + .isEqualTo(CelProtoTypes.createMessage("cel.expr.conformance.proto2.TestAllTypes")); + assertThat(extensionType.fieldType().type()).isEqualTo(CelProtoTypes.INT64); + assertThat(extensionType) + .isEqualTo( + descriptorTypeProvider.lookupExtensionType( + "cel.expr.conformance.proto2.nested_enum_ext")); + } + + @Test + public void lookupEnumValue() { + Integer enumValue = + compatTypeProvider.lookupEnumValue("cel.expr.conformance.proto2.GlobalEnum.GAR"); + assertThat(enumValue).isEqualTo(1); + assertThat(enumValue) + .isEqualTo( + descriptorTypeProvider.lookupEnumValue("cel.expr.conformance.proto2.GlobalEnum.GAR")); + } + + @Test + public void lookupEnumValue_notFoundValue() { + Integer enumValue = + compatTypeProvider.lookupEnumValue("cel.expr.conformance.proto2.GlobalEnum.BAR"); + assertThat(enumValue).isNull(); + assertThat(enumValue) + .isEqualTo( + descriptorTypeProvider.lookupEnumValue("cel.expr.conformance.proto2.GlobalEnum.BAR")); + } + + @Test + public void lookupEnumValue_notFoundEnumType() { + Integer enumValue = + compatTypeProvider.lookupEnumValue("cel.expr.conformance.proto2.InvalidEnum.TEST"); + assertThat(enumValue).isNull(); + assertThat(enumValue) + .isEqualTo( + descriptorTypeProvider.lookupEnumValue("cel.expr.conformance.proto2.InvalidEnum.TEST")); + } + + @Test + public void lookupEnumValue_notFoundBadEnumName() { + assertThat(compatTypeProvider.lookupEnumValue("TEST")).isNull(); + assertThat(compatTypeProvider.lookupEnumValue("TEST.")).isNull(); + assertThat(descriptorTypeProvider.lookupEnumValue("TEST")).isNull(); + assertThat(descriptorTypeProvider.lookupEnumValue("TEST.")).isNull(); + } +} diff --git a/checker/src/test/java/dev/cel/checker/TypesTest.java b/checker/src/test/java/dev/cel/checker/TypesTest.java new file mode 100644 index 000000000..960ebec3f --- /dev/null +++ b/checker/src/test/java/dev/cel/checker/TypesTest.java @@ -0,0 +1,74 @@ +// Copyright 2023 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.checker; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.expr.Type; +import dev.cel.expr.Type.PrimitiveType; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; +import java.util.HashMap; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class TypesTest { + + @Test + public void isAssignable_usingProtoTypes() { + Map subs = new HashMap<>(); + Type typeParamA = CelProtoTypes.createTypeParam("A"); + Type stringType = CelProtoTypes.create(PrimitiveType.STRING); + + Map result = Types.isAssignable(subs, typeParamA, stringType); + + assertThat(result).containsExactly(typeParamA, stringType); + } + + @Test + public void isAssignable_usingCustomTypes() { + Map subs = new HashMap<>(); + CelType intType = SimpleType.INT; + CelType customType = new CustomCelType(); + + // A curated example where a CEL's int type can be assigned to a custom type. + assertThat(Types.isAssignable(subs, intType, customType)).isEqualTo(subs); + // But not the other way around. + assertThat(Types.isAssignable(subs, customType, intType)).isNull(); + } + + private static final class CustomCelType extends CelType { + + @Override + public CelKind kind() { + return CelKind.INT; + } + + @Override + public String name() { + return "customInt"; + } + + @Override + public boolean isAssignableFrom(CelType other) { + return super.isAssignableFrom(other) || other.equals(SimpleType.INT); + } + } +} diff --git a/checker/src/test/resources/BUILD.bazel b/checker/src/test/resources/BUILD.bazel new file mode 100644 index 000000000..3cbe313df --- /dev/null +++ b/checker/src/test/resources/BUILD.bazel @@ -0,0 +1,15 @@ +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//checker:__subpackages__", + ], +) + +filegroup( + name = "baselines", + testonly = True, + srcs = glob(["*.baseline"]), +) diff --git a/checker/src/test/resources/abstractTypeParameterLess.baseline b/checker/src/test/resources/abstractTypeParameterLess.baseline new file mode 100644 index 000000000..10cfae312 --- /dev/null +++ b/checker/src/test/resources/abstractTypeParameterLess.baseline @@ -0,0 +1,20 @@ +Source: type(make_abs()) == abs && make_abs().as_bool() +declare abs { + value type(abs) +} +declare make_abs { + function make_abs () -> abs +} +declare as_bool { + function as_bool abs.() -> bool +} +=====> +_&&_( + _==_( + type( + make_abs()~abs^make_abs + )~type(abs)^type, + abs~type(abs)^abs + )~bool^equals, + make_abs()~abs^make_abs.as_bool()~bool^as_bool +)~bool^logical_and diff --git a/checker/src/test/resources/abstractTypeParameterized.baseline b/checker/src/test/resources/abstractTypeParameterized.baseline new file mode 100644 index 000000000..28cc0000a --- /dev/null +++ b/checker/src/test/resources/abstractTypeParameterized.baseline @@ -0,0 +1,33 @@ +Source: type(vector([1])) == vector(dyn) && vector([1]).at(0) == 1 +declare vector { + function vector_type (type(T)) -> type(vector(T)) + function vector_list (list(T)) -> vector(T) +} +declare at { + function vector_at_int vector(T).(int) -> T +} +=====> +_&&_( + _==_( + type( + vector( + [ + 1~int + ]~list(int) + )~vector(int)^vector_list + )~type(vector(int))^type, + vector( + dyn~type(dyn)^dyn + )~type(vector(dyn))^vector_type + )~bool^equals, + _==_( + vector( + [ + 1~int + ]~list(int) + )~vector(int)^vector_list.at( + 0~int + )~int^vector_at_int, + 1~int + )~bool^equals +)~bool^logical_and diff --git a/checker/src/test/resources/abstractTypeParameterizedError.baseline b/checker/src/test/resources/abstractTypeParameterizedError.baseline new file mode 100644 index 000000000..8ef50993e --- /dev/null +++ b/checker/src/test/resources/abstractTypeParameterizedError.baseline @@ -0,0 +1,12 @@ +Source: add(vector([1, 2]), vector([2u, -1])) == vector([1, 2, 2u, -1]) +declare vector { + function vector_type (type(T)) -> type(vector(T)) + function vector_list (list(T)) -> vector(T) +} +declare add { + function add_vector_type (type(vector(T)), type(vector(T))) -> type(vector(T)) +} +=====> +ERROR: test_location:1:4: found no matching overload for 'add' applied to '(vector(int), vector(dyn))' (candidates: (type(vector(%T4)), type(vector(%T4)))) + | add(vector([1, 2]), vector([2u, -1])) == vector([1, 2, 2u, -1]) + | ...^ diff --git a/checker/src/test/resources/abstractTypeParameterizedInListLiteral.baseline b/checker/src/test/resources/abstractTypeParameterizedInListLiteral.baseline new file mode 100644 index 000000000..3425e0325 --- /dev/null +++ b/checker/src/test/resources/abstractTypeParameterizedInListLiteral.baseline @@ -0,0 +1,26 @@ +Source: size([vector([1, 2]), vector([2u, -1])]) == 2 +declare vector { + function vector_type (type(T)) -> type(vector(T)) + function vector_list (list(T)) -> vector(T) +} +=====> +_==_( + size( + [ + vector( + [ + 1~int, + 2~int + ]~list(int) + )~vector(int)^vector_list, + vector( + [ + 2u~uint, + -1~int + ]~list(dyn) + )~vector(dyn)^vector_list + ]~list(vector(dyn)) + )~int^size_list, + 2~int +)~bool^equals + diff --git a/checker/src/test/resources/aggregateList.baseline b/checker/src/test/resources/aggregateList.baseline new file mode 100644 index 000000000..dd6a74209 --- /dev/null +++ b/checker/src/test/resources/aggregateList.baseline @@ -0,0 +1,16 @@ +Source: [] + [1,2,3,] + [4] +=====> +_+_( + _+_( + []~list(int), + [ + 1~int, + 2~int, + 3~int + ]~list(int) + )~list(int)^add_list, + [ + 4~int + ]~list(int) +)~list(int)^add_list + diff --git a/checker/src/test/resources/aggregateListDyn.baseline b/checker/src/test/resources/aggregateListDyn.baseline new file mode 100644 index 000000000..8943f30a6 --- /dev/null +++ b/checker/src/test/resources/aggregateListDyn.baseline @@ -0,0 +1,6 @@ +Source: [1, 2u] +=====> +[ + 1~int, + 2u~uint +]~list(dyn) diff --git a/checker/src/test/resources/aggregateMap.baseline b/checker/src/test/resources/aggregateMap.baseline new file mode 100644 index 000000000..a2037e7bc --- /dev/null +++ b/checker/src/test/resources/aggregateMap.baseline @@ -0,0 +1,7 @@ +Source: {1:2u, 2:3u} +=====> +{ + 1~int:2u~uint, + 2~int:3u~uint +}~map(int, uint) + diff --git a/checker/src/test/resources/aggregateMapDyn.baseline b/checker/src/test/resources/aggregateMapDyn.baseline new file mode 100644 index 000000000..180739862 --- /dev/null +++ b/checker/src/test/resources/aggregateMapDyn.baseline @@ -0,0 +1,7 @@ +Source: {1:2u, 2u:3} +=====> +{ + 1~int:2u~uint, + 2u~uint:3~int +}~map(dyn, dyn) + diff --git a/checker/src/test/resources/aggregateMapDynKey.baseline b/checker/src/test/resources/aggregateMapDynKey.baseline new file mode 100644 index 000000000..f427643e8 --- /dev/null +++ b/checker/src/test/resources/aggregateMapDynKey.baseline @@ -0,0 +1,7 @@ +Source: {1:2, 2u:3} +=====> +{ + 1~int:2~int, + 2u~uint:3~int +}~map(dyn, int) + diff --git a/checker/src/test/resources/aggregateMapDynValue.baseline b/checker/src/test/resources/aggregateMapDynValue.baseline new file mode 100644 index 000000000..76696e802 --- /dev/null +++ b/checker/src/test/resources/aggregateMapDynValue.baseline @@ -0,0 +1,7 @@ +Source: {1:2u, 2:3} +=====> +{ + 1~int:2u~uint, + 2~int:3~int +}~map(int, dyn) + diff --git a/checker/src/test/resources/aggregateMapFieldSelection.baseline b/checker/src/test/resources/aggregateMapFieldSelection.baseline new file mode 100644 index 000000000..bfc28d444 --- /dev/null +++ b/checker/src/test/resources/aggregateMapFieldSelection.baseline @@ -0,0 +1,7 @@ +Source: {"a":1, "b":2}.a +=====> +{ + "a"~string:1~int, + "b"~string:2~int +}~map(string, int).a~int + diff --git a/checker/src/test/resources/aggregateMessage.baseline b/checker/src/test/resources/aggregateMessage.baseline new file mode 100644 index 000000000..eb138b0e8 --- /dev/null +++ b/checker/src/test/resources/aggregateMessage.baseline @@ -0,0 +1,6 @@ +Source: TestAllTypes{single_int32: 1, single_int64: 2} +=====> +cel.expr.conformance.proto3.TestAllTypes{ + single_int32:1~int, + single_int64:2~int +}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes \ No newline at end of file diff --git a/checker/src/test/resources/aggregateMessageFieldTypeError.baseline b/checker/src/test/resources/aggregateMessageFieldTypeError.baseline new file mode 100644 index 000000000..f9c4e0f88 --- /dev/null +++ b/checker/src/test/resources/aggregateMessageFieldTypeError.baseline @@ -0,0 +1,5 @@ +Source: TestAllTypes{single_int32: 1u} +=====> +ERROR: test_location:1:26: expected type of field 'single_int32' is 'int' but provided type is 'uint' + | TestAllTypes{single_int32: 1u} + | .........................^ diff --git a/checker/src/test/resources/aggregateMessageFieldUndefinedError.baseline b/checker/src/test/resources/aggregateMessageFieldUndefinedError.baseline new file mode 100644 index 000000000..27747db52 --- /dev/null +++ b/checker/src/test/resources/aggregateMessageFieldUndefinedError.baseline @@ -0,0 +1,5 @@ +Source: TestAllTypes{single_int32: 1, undefined: 2} +=====> +ERROR: test_location:1:40: undefined field 'undefined' + | TestAllTypes{single_int32: 1, undefined: 2} + | .......................................^ diff --git a/checker/src/test/resources/anyMessage.baseline b/checker/src/test/resources/anyMessage.baseline new file mode 100644 index 000000000..9c94a0b24 --- /dev/null +++ b/checker/src/test/resources/anyMessage.baseline @@ -0,0 +1,39 @@ +Source: x == google.protobuf.Any{type_url:'types.googleapis.com/cel.expr.conformance.proto3.TestAllTypes'} && x.single_nested_message.bb == 43 || x == cel.expr.conformance.proto3.TestAllTypes{} || y < x|| x >= x +declare x { + value any +} +declare y { + value wrapper(int) +} +=====> +_||_( + _||_( + _&&_( + _==_( + x~any^x, + google.protobuf.Any{ + type_url:"types.googleapis.com/cel.expr.conformance.proto3.TestAllTypes"~string + }~any^google.protobuf.Any + )~bool^equals, + _==_( + x~any^x.single_nested_message~dyn.bb~dyn, + 43~int + )~bool^equals + )~bool^logical_and, + _==_( + x~any^x, + cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes + )~bool^equals + )~bool^logical_or, + _||_( + _<_( + y~wrapper(int)^y, + x~any^x + )~bool^less_int64|less_int64_uint64|less_int64_double, + _>=_( + x~any^x, + x~any^x + )~bool^greater_equals_bool|greater_equals_int64|greater_equals_uint64|greater_equals_double|greater_equals_string|greater_equals_bytes|greater_equals_timestamp|greater_equals_duration|greater_equals_int64_uint64|greater_equals_uint64_int64|greater_equals_int64_double|greater_equals_double_int64|greater_equals_uint64_double|greater_equals_double_uint64 + )~bool^logical_or +)~bool^logical_or + diff --git a/checker/src/test/resources/callStyle.baseline b/checker/src/test/resources/callStyle.baseline new file mode 100644 index 000000000..415f87e62 --- /dev/null +++ b/checker/src/test/resources/callStyle.baseline @@ -0,0 +1,14 @@ +Source: size(x) == x.size() +declare x { + value list(int) +} +declare size { + function my_size list(A).() -> int +} +=====> +_==_( + size( + x~list(int)^x + )~int^size_list, + x~list(int)^x.size()~int^my_size +)~bool^equals \ No newline at end of file diff --git a/checker/src/test/resources/containers.baseline b/checker/src/test/resources/containers.baseline new file mode 100644 index 000000000..cdf26eb63 --- /dev/null +++ b/checker/src/test/resources/containers.baseline @@ -0,0 +1,38 @@ +Source: p3_alias.TestAllTypes{} +=====> +cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes + +Source: proto2.TestAllTypes{} +=====> +cel.expr.conformance.proto2.TestAllTypes{}~cel.expr.conformance.proto2.TestAllTypes^cel.expr.conformance.proto2.TestAllTypes + +Source: proto3.TestAllTypes{} +=====> +cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes + +Source: SGAR +=====> +dev.cel.testing.testdata.proto3.StandaloneGlobalEnum.SGAR~int^dev.cel.testing.testdata.proto3.StandaloneGlobalEnum.SGAR + +Source: foo_bar_alias.baz() +declare foo.bar { + value string +} +declare baz { + function foo_bar_baz_overload string.() -> dyn +} +=====> +foo.bar~string^foo.bar.baz()~dyn^foo_bar_baz_overload + +Source: foo_bar_baz_alias.qux() +declare foo.bar { + value string +} +declare baz { + function foo_bar_baz_overload string.() -> dyn +} +declare foo.bar.baz.qux { + function foo_bar_baz_qux_overload () -> dyn +} +=====> +foo.bar.baz.qux()~dyn^foo_bar_baz_qux_overload \ No newline at end of file diff --git a/checker/src/test/resources/conversions.baseline b/checker/src/test/resources/conversions.baseline new file mode 100644 index 000000000..bc0ae0f00 --- /dev/null +++ b/checker/src/test/resources/conversions.baseline @@ -0,0 +1,12 @@ +Source: int(1u) + int(uint("1")) +=====> +_+_( + int( + 1u~uint + )~int^uint64_to_int64, + int( + uint( + "1"~string + )~uint^string_to_uint64 + )~int^uint64_to_int64 +)~int^add_int64 diff --git a/checker/src/test/resources/dynOperators.baseline b/checker/src/test/resources/dynOperators.baseline new file mode 100644 index 000000000..ceb4ce9e6 --- /dev/null +++ b/checker/src/test/resources/dynOperators.baseline @@ -0,0 +1,16 @@ +Source: x.single_value + 1 / x.single_struct.y == 23 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_==_( + _+_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_value~dyn, + _/_( + 1~int, + x~cel.expr.conformance.proto3.TestAllTypes^x.single_struct~map(string, dyn).y~dyn + )~int^divide_int64 + )~int^add_int64, + 23~int +)~bool^equals + diff --git a/checker/src/test/resources/dynOperatorsAtRuntime.baseline b/checker/src/test/resources/dynOperatorsAtRuntime.baseline new file mode 100644 index 000000000..470289997 --- /dev/null +++ b/checker/src/test/resources/dynOperatorsAtRuntime.baseline @@ -0,0 +1,16 @@ +Source: x.single_value[23] + x.single_struct['y'] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_+_( + _[_]( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_value~dyn, + 23~int + )~dyn^index_list|index_map, + _[_]( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_struct~map(string, dyn), + "y"~string + )~dyn^index_map +)~dyn^add_int64|add_uint64|add_double|add_string|add_bytes|add_list|add_timestamp_duration|add_duration_timestamp|add_duration_duration + diff --git a/checker/src/test/resources/enumValues.baseline b/checker/src/test/resources/enumValues.baseline new file mode 100644 index 000000000..be343985a --- /dev/null +++ b/checker/src/test/resources/enumValues.baseline @@ -0,0 +1,6 @@ +Source: TestAllTypes.NestedEnum.BAR != 99 +=====> +_!=_( + cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR, + 99~int +)~bool^not_equals diff --git a/checker/src/test/resources/equalsWrapper.baseline b/checker/src/test/resources/equalsWrapper.baseline new file mode 100644 index 000000000..ad105a5bd --- /dev/null +++ b/checker/src/test/resources/equalsWrapper.baseline @@ -0,0 +1,40 @@ +Source: x.single_int64_wrapper == 1 && x.single_int32_wrapper != 2 && x.single_double_wrapper != 2.0 && x.single_float_wrapper == 1.0 && x.single_uint32_wrapper == 1u && x.single_uint64_wrapper != 42u +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_&&_( + _&&_( + _&&_( + _==_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_int64_wrapper~wrapper(int), + 1~int + )~bool^equals, + _!=_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_int32_wrapper~wrapper(int), + 2~int + )~bool^not_equals + )~bool^logical_and, + _!=_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_double_wrapper~wrapper(double), + 2.0~double + )~bool^not_equals + )~bool^logical_and, + _&&_( + _&&_( + _==_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_float_wrapper~wrapper(double), + 1.0~double + )~bool^equals, + _==_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_uint32_wrapper~wrapper(uint), + 1u~uint + )~bool^equals + )~bool^logical_and, + _!=_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_uint64_wrapper~wrapper(uint), + 42u~uint + )~bool^not_equals + )~bool^logical_and +)~bool^logical_and + diff --git a/checker/src/test/resources/expectedAggregateList.baseline b/checker/src/test/resources/expectedAggregateList.baseline new file mode 100644 index 000000000..829dbc40c --- /dev/null +++ b/checker/src/test/resources/expectedAggregateList.baseline @@ -0,0 +1,15 @@ +Source: [] + [1,2,3,] + [4] +=====> +_+_( + _+_( + []~list(int), + [ + 1~int, + 2~int, + 3~int + ]~list(int) + )~list(int)^add_list, + [ + 4~int + ]~list(int) +)~list(int)^add_list diff --git a/checker/src/test/resources/flexibleTypeAdaption.baseline b/checker/src/test/resources/flexibleTypeAdaption.baseline new file mode 100644 index 000000000..e2f3ebc3e --- /dev/null +++ b/checker/src/test/resources/flexibleTypeAdaption.baseline @@ -0,0 +1,130 @@ +Source: size([] + [1]) +=====> +size( + _+_( + []~list(int), + [ + 1~int + ]~list(int) + )~list(int)^add_list +)~int^size_list + +Source: [1] + [dyn('string')] +=====> +_+_( + [ + 1~int + ]~list(int), + [ + dyn( + "string"~string + )~dyn^to_dyn + ]~list(dyn) +)~list(dyn)^add_list + +Source: [dyn('string')] + [1] +=====> +_+_( + [ + dyn( + "string"~string + )~dyn^to_dyn + ]~list(dyn), + [ + 1~int + ]~list(int) +)~list(dyn)^add_list + +Source: ([[[1]], [[2]], [[3]]][0][0] + [2, 3, {'four': {'five': 'six'}}])[3] +=====> +_[_]( + _+_( + _[_]( + _[_]( + [ + [ + [ + 1~int + ]~list(int) + ]~list(list(int)), + [ + [ + 2~int + ]~list(int) + ]~list(list(int)), + [ + [ + 3~int + ]~list(int) + ]~list(list(int)) + ]~list(list(list(int))), + 0~int + )~list(list(int))^index_list, + 0~int + )~list(int)^index_list, + [ + 2~int, + 3~int, + { + "four"~string:{ + "five"~string:"six"~string + }~map(string, string) + }~map(string, map(string, string)) + ]~list(dyn) + )~list(dyn)^add_list, + 3~int +)~dyn^index_list + +Source: a.b + 1 == a[0] +declare a { + value T +} +=====> +_==_( + _+_( + a~dyn^a.b~dyn, + 1~int + )~int^add_int64, + _[_]( + a~dyn^a, + 0~int + )~dyn^index_list|index_map +)~bool^equals + +Source: merge({'hello': dyn(1)}, {'world': 2.0}) +declare a { + value T +} +declare merge { + function merge_maps (map(A, B), map(A, B)) -> map(A, B) +} +=====> +merge( + { + "hello"~string:dyn( + 1~int + )~dyn^to_dyn + }~map(string, dyn), + { + "world"~string:2.0~double + }~map(string, double) +)~map(string, dyn)^merge_maps + +Source: 1 in dyn([1, 2, 3]) +declare a { + value T +} +declare merge { + function merge_maps (map(A, B), map(A, B)) -> map(A, B) +} +=====> +@in( + 1~int, + dyn( + [ + 1~int, + 2~int, + 3~int + ]~list(int) + )~dyn^to_dyn +)~bool^in_list|in_map \ No newline at end of file diff --git a/checker/src/test/resources/globalEnumValues.baseline b/checker/src/test/resources/globalEnumValues.baseline new file mode 100644 index 000000000..9a16481e6 --- /dev/null +++ b/checker/src/test/resources/globalEnumValues.baseline @@ -0,0 +1,6 @@ +Source: GlobalEnum.GAZ == 2 +=====> +_==_( + cel.expr.conformance.proto3.GlobalEnum.GAZ~int^cel.expr.conformance.proto3.GlobalEnum.GAZ, + 2~int +)~bool^equals diff --git a/checker/src/test/resources/globalStandaloneEnumValues.baseline b/checker/src/test/resources/globalStandaloneEnumValues.baseline new file mode 100644 index 000000000..22c72be9c --- /dev/null +++ b/checker/src/test/resources/globalStandaloneEnumValues.baseline @@ -0,0 +1,6 @@ +Source: StandaloneGlobalEnum.SGAZ == 2 +=====> +_==_( + dev.cel.testing.testdata.proto3.StandaloneGlobalEnum.SGAZ~int^dev.cel.testing.testdata.proto3.StandaloneGlobalEnum.SGAZ, + 2~int +)~bool^equals diff --git a/checker/src/test/resources/identError.baseline b/checker/src/test/resources/identError.baseline new file mode 100644 index 000000000..a6d6e8de6 --- /dev/null +++ b/checker/src/test/resources/identError.baseline @@ -0,0 +1,5 @@ +Source: undeclared_ident +=====> +ERROR: test_location:1:1: undeclared reference to 'undeclared_ident' (in container '') + | undeclared_ident + | ^ diff --git a/checker/src/test/resources/jsonStructTypeError.baseline b/checker/src/test/resources/jsonStructTypeError.baseline new file mode 100644 index 000000000..9923ddcda --- /dev/null +++ b/checker/src/test/resources/jsonStructTypeError.baseline @@ -0,0 +1,8 @@ +Source: x["iss"] != TestAllTypes{single_int32: 1} +declare x { + value google.protobuf.Struct +} +=====> +ERROR: test_location:1:10: found no matching overload for '_!=_' applied to '(google.protobuf.Value, cel.expr.conformance.proto3.TestAllTypes)' (candidates: (%A3, %A3)) + | x["iss"] != TestAllTypes{single_int32: 1} + | .........^ diff --git a/checker/src/test/resources/jsonType.baseline b/checker/src/test/resources/jsonType.baseline new file mode 100644 index 000000000..8a0f66376 --- /dev/null +++ b/checker/src/test/resources/jsonType.baseline @@ -0,0 +1,50 @@ +Source: x["claims"]["groups"][0].name == "dummy" && x.claims["exp"] == y[1].time && x.claims.structured == {'key': z} && z == 1.0 +declare x { + value google.protobuf.Struct +} +declare y { + value google.protobuf.ListValue +} +declare z { + value google.protobuf.Value +} +=====> +_&&_( + _&&_( + _==_( + _[_]( + _[_]( + _[_]( + x~map(string, dyn)^x, + "claims"~string + )~dyn^index_map, + "groups"~string + )~list(dyn)^index_map, + 0~int + )~dyn^index_list.name~dyn, + "dummy"~string + )~bool^equals, + _==_( + _[_]( + x~map(string, dyn)^x.claims~dyn, + "exp"~string + )~dyn^index_map, + _[_]( + y~list(dyn)^y, + 1~int + )~dyn^index_list.time~dyn + )~bool^equals + )~bool^logical_and, + _&&_( + _==_( + x~map(string, dyn)^x.claims~dyn.structured~dyn, + { + "key"~string:z~dyn^z + }~map(string, dyn) + )~bool^equals, + _==_( + z~dyn^z, + 1.0~double + )~bool^equals + )~bool^logical_and +)~bool^logical_and diff --git a/checker/src/test/resources/jsonTypeNullAccess.baseline b/checker/src/test/resources/jsonTypeNullAccess.baseline new file mode 100644 index 000000000..834b8fde8 --- /dev/null +++ b/checker/src/test/resources/jsonTypeNullAccess.baseline @@ -0,0 +1,54 @@ +Source: google.protobuf.Value{null_value: google.protobuf.NullValue.NULL_VALUE} == null +=====> +_==_( + google.protobuf.Value{ + null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE + }~dyn^google.protobuf.Value, + null~null +)~bool^equals + +Source: cel.expr.conformance.proto3.TestAllTypes{single_value: null}.single_value == null +=====> +_==_( + cel.expr.conformance.proto3.TestAllTypes{ + single_value:null~null + }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn, + null~null +)~bool^equals + +Source: cel.expr.conformance.proto3.TestAllTypes{single_value: google.protobuf.NullValue.NULL_VALUE}.single_value == null +=====> +_==_( + cel.expr.conformance.proto3.TestAllTypes{ + single_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE + }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_value~dyn, + null~null +)~bool^equals + +Source: cel.expr.conformance.proto3.TestAllTypes{null_value: google.protobuf.NullValue.NULL_VALUE}.null_value == null +=====> +ERROR: test_location:1:103: found no matching overload for '_==_' applied to '(int, null)' (candidates: (%A0, %A0)) + | cel.expr.conformance.proto3.TestAllTypes{null_value: google.protobuf.NullValue.NULL_VALUE}.null_value == null + | ......................................................................................................^ + +Source: cel.expr.conformance.proto3.TestAllTypes{null_value: google.protobuf.NullValue.NULL_VALUE}.null_value == 0 +=====> +_==_( + cel.expr.conformance.proto3.TestAllTypes{ + null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE + }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.null_value~int, + 0~int +)~bool^equals + +Source: google.protobuf.NullValue.NULL_VALUE == null +=====> +ERROR: test_location:1:38: found no matching overload for '_==_' applied to '(int, null)' (candidates: (%A0, %A0)) + | google.protobuf.NullValue.NULL_VALUE == null + | .....................................^ + +Source: google.protobuf.NullValue.NULL_VALUE == 0 +=====> +_==_( + google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE, + 0~int +)~bool^equals \ No newline at end of file diff --git a/checker/src/test/resources/jsonTypeNullConstruction.baseline b/checker/src/test/resources/jsonTypeNullConstruction.baseline new file mode 100644 index 000000000..5b9b211a8 --- /dev/null +++ b/checker/src/test/resources/jsonTypeNullConstruction.baseline @@ -0,0 +1,35 @@ +Source: google.protobuf.Value{null_value: google.protobuf.NullValue.NULL_VALUE} +=====> +google.protobuf.Value{ + null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE +}~dyn^google.protobuf.Value + +Source: google.protobuf.Value{null_value: null} +=====> +ERROR: test_location:1:33: expected type of field 'null_value' is 'int' but provided type is 'null' + | google.protobuf.Value{null_value: null} + | ................................^ + +Source: cel.expr.conformance.proto3.TestAllTypes{single_value: null} +=====> +cel.expr.conformance.proto3.TestAllTypes{ + single_value:null~null +}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes + +Source: cel.expr.conformance.proto3.TestAllTypes{single_value: google.protobuf.NullValue.NULL_VALUE} +=====> +cel.expr.conformance.proto3.TestAllTypes{ + single_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE +}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes + +Source: cel.expr.conformance.proto3.TestAllTypes{null_value: null} +=====> +ERROR: test_location:1:52: expected type of field 'null_value' is 'int' but provided type is 'null' + | cel.expr.conformance.proto3.TestAllTypes{null_value: null} + | ...................................................^ + +Source: cel.expr.conformance.proto3.TestAllTypes{null_value: google.protobuf.NullValue.NULL_VALUE} +=====> +cel.expr.conformance.proto3.TestAllTypes{ + null_value:google.protobuf.NullValue.NULL_VALUE~int^google.protobuf.NullValue.NULL_VALUE +}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes \ No newline at end of file diff --git a/checker/src/test/resources/listElemTypeError.baseline b/checker/src/test/resources/listElemTypeError.baseline new file mode 100644 index 000000000..47f3ccc95 --- /dev/null +++ b/checker/src/test/resources/listElemTypeError.baseline @@ -0,0 +1,11 @@ +Source: x + y +declare x { + value list(cel.expr.conformance.proto3.TestAllTypes) +} +declare y { + value list(int) +} +=====> +ERROR: test_location:1:3: found no matching overload for '_+_' applied to '(list(cel.expr.conformance.proto3.TestAllTypes), list(int))' (candidates: (int, int),(uint, uint),(double, double),(string, string),(bytes, bytes),(list(%A0), list(%A0)),(google.protobuf.Timestamp, google.protobuf.Duration),(google.protobuf.Duration, google.protobuf.Timestamp),(google.protobuf.Duration, google.protobuf.Duration)) + | x + y + | ..^ \ No newline at end of file diff --git a/checker/src/test/resources/listIndexTypeError.baseline b/checker/src/test/resources/listIndexTypeError.baseline new file mode 100644 index 000000000..c0fca99bf --- /dev/null +++ b/checker/src/test/resources/listIndexTypeError.baseline @@ -0,0 +1,8 @@ +Source: x[1u] +declare x { + value list(cel.expr.conformance.proto3.TestAllTypes) +} +=====> +ERROR: test_location:1:2: found no matching overload for '_[_]' applied to '(list(cel.expr.conformance.proto3.TestAllTypes), uint)' (candidates: (list(%A0), int),(map(%A1, %B2), %A1)) + | x[1u] + | .^ diff --git a/checker/src/test/resources/listOperators.baseline b/checker/src/test/resources/listOperators.baseline new file mode 100644 index 000000000..5ca16ba91 --- /dev/null +++ b/checker/src/test/resources/listOperators.baseline @@ -0,0 +1,30 @@ +Source: (x + x)[1].single_int32 == size(x) +declare x { + value list(cel.expr.conformance.proto3.TestAllTypes) +} +=====> +_==_( + _[_]( + _+_( + x~list(cel.expr.conformance.proto3.TestAllTypes)^x, + x~list(cel.expr.conformance.proto3.TestAllTypes)^x + )~list(cel.expr.conformance.proto3.TestAllTypes)^add_list, + 1~int + )~cel.expr.conformance.proto3.TestAllTypes^index_list.single_int32~int, + size( + x~list(cel.expr.conformance.proto3.TestAllTypes)^x + )~int^size_list +)~bool^equals + +Source: x.size() == size(x) +declare x { + value list(cel.expr.conformance.proto3.TestAllTypes) +} +=====> +_==_( + x~list(cel.expr.conformance.proto3.TestAllTypes)^x.size()~int^list_size, + size( + x~list(cel.expr.conformance.proto3.TestAllTypes)^x + )~int^size_list +)~bool^equals + diff --git a/checker/src/test/resources/listRepeatedOperators.baseline b/checker/src/test/resources/listRepeatedOperators.baseline new file mode 100644 index 000000000..e04335f98 --- /dev/null +++ b/checker/src/test/resources/listRepeatedOperators.baseline @@ -0,0 +1,13 @@ +Source: x.repeated_int64[x.single_int32] == 23 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_==_( + _[_]( + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int64~list(int), + x~cel.expr.conformance.proto3.TestAllTypes^x.single_int32~int + )~int^index_list, + 23~int +)~bool^equals + diff --git a/checker/src/test/resources/mapEmpty.baseline b/checker/src/test/resources/mapEmpty.baseline new file mode 100644 index 000000000..d8ec99820 --- /dev/null +++ b/checker/src/test/resources/mapEmpty.baseline @@ -0,0 +1,12 @@ +Source: size(x.map_int64_nested_type) == 0 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_==_( + size( + x~cel.expr.conformance.proto3.TestAllTypes^x.map_int64_nested_type~map(int, cel.expr.conformance.proto3.NestedTestAllTypes) + )~int^size_map, + 0~int +)~bool^equals + diff --git a/checker/src/test/resources/mapExpr.baseline b/checker/src/test/resources/mapExpr.baseline new file mode 100644 index 000000000..2f7964bc0 --- /dev/null +++ b/checker/src/test/resources/mapExpr.baseline @@ -0,0 +1,96 @@ +Source: x.repeated_int64.map(x, double(x)) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +__comprehension__( + // Variable + x, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int64~list(int), + // Accumulator + @result, + // Init + []~list(double), + // LoopCondition + true~bool, + // LoopStep + _+_( + @result~list(double)^@result, + [ + double( + x~int^x + )~double^int64_to_double + ]~list(double) + )~list(double)^add_list, + // Result + @result~list(double)^@result)~list(double) + +Source: [].map(x, [].map(y, x in y && y in x)) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +ERROR: test_location:1:33: found no matching overload for '@in' applied to '(list(%elem0), %elem0)' (candidates: (%A7, list(%A7)),(%A8, map(%A8, %B9))) + | [].map(x, [].map(y, x in y && y in x)) + | ................................^ + +Source: [{}.map(c,c,c)]+[{}.map(c,c,c)] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_+_( + [ + __comprehension__( + // Variable + c, + // Target + {}~map(bool, dyn), + // Accumulator + @result, + // Init + []~list(bool), + // LoopCondition + true~bool, + // LoopStep + _?_:_( + c~bool^c, + _+_( + @result~list(bool)^@result, + [ + c~bool^c + ]~list(bool) + )~list(bool)^add_list, + @result~list(bool)^@result + )~list(bool)^conditional, + // Result + @result~list(bool)^@result)~list(bool) + ]~list(list(bool)), + [ + __comprehension__( + // Variable + c, + // Target + {}~map(bool, dyn), + // Accumulator + @result, + // Init + []~list(bool), + // LoopCondition + true~bool, + // LoopStep + _?_:_( + c~bool^c, + _+_( + @result~list(bool)^@result, + [ + c~bool^c + ]~list(bool) + )~list(bool)^add_list, + @result~list(bool)^@result + )~list(bool)^conditional, + // Result + @result~list(bool)^@result)~list(bool) + ]~list(list(bool)) +)~list(list(bool))^add_list \ No newline at end of file diff --git a/checker/src/test/resources/mapFilterExpr.baseline b/checker/src/test/resources/mapFilterExpr.baseline new file mode 100644 index 000000000..1a66e493c --- /dev/null +++ b/checker/src/test/resources/mapFilterExpr.baseline @@ -0,0 +1,112 @@ +Source: x.repeated_int64.map(x, x > 0, double(x)) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +__comprehension__( + // Variable + x, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int64~list(int), + // Accumulator + @result, + // Init + []~list(double), + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _>_( + x~int^x, + 0~int + )~bool^greater_int64, + _+_( + @result~list(double)^@result, + [ + double( + x~int^x + )~double^int64_to_double + ]~list(double) + )~list(double)^add_list, + @result~list(double)^@result + )~list(double)^conditional, + // Result + @result~list(double)^@result)~list(double) + +Source: lists.filter(x, x > 1.5) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare lists { + value dyn +} +=====> +__comprehension__( + // Variable + x, + // Target + lists~dyn^lists, + // Accumulator + @result, + // Init + []~list(dyn), + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _>_( + x~dyn^x, + 1.5~double + )~bool^greater_double|greater_int64_double|greater_uint64_double, + _+_( + @result~list(dyn)^@result, + [ + x~dyn^x + ]~list(dyn) + )~list(dyn)^add_list, + @result~list(dyn)^@result + )~list(dyn)^conditional, + // Result + @result~list(dyn)^@result)~list(dyn) + +Source: args.user["myextension"].customAttributes.filter(x, x.name == "hobbies") +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare lists { + value dyn +} +declare args { + value map(string, dyn) +} +=====> +__comprehension__( + // Variable + x, + // Target + _[_]( + args~map(string, dyn)^args.user~dyn, + "myextension"~string + )~dyn^index_map.customAttributes~dyn, + // Accumulator + @result, + // Init + []~list(dyn), + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _==_( + x~dyn^x.name~dyn, + "hobbies"~string + )~bool^equals, + _+_( + @result~list(dyn)^@result, + [ + x~dyn^x + ]~list(dyn) + )~list(dyn)^add_list, + @result~list(dyn)^@result + )~list(dyn)^conditional, + // Result + @result~list(dyn)^@result)~list(dyn) \ No newline at end of file diff --git a/checker/src/test/resources/mapIndexTypeError.baseline b/checker/src/test/resources/mapIndexTypeError.baseline new file mode 100644 index 000000000..02fee54dd --- /dev/null +++ b/checker/src/test/resources/mapIndexTypeError.baseline @@ -0,0 +1,8 @@ +Source: x[2].single_int32 == 23 +declare x { + value map(string, cel.expr.conformance.proto3.TestAllTypes) +} +=====> +ERROR: test_location:1:2: found no matching overload for '_[_]' applied to '(map(string, cel.expr.conformance.proto3.TestAllTypes), int)' (candidates: (list(%A0), int),(map(%A1, %B2), %A1)) + | x[2].single_int32 == 23 + | .^ diff --git a/checker/src/test/resources/mapOperators.baseline b/checker/src/test/resources/mapOperators.baseline new file mode 100644 index 000000000..cf040f056 --- /dev/null +++ b/checker/src/test/resources/mapOperators.baseline @@ -0,0 +1,25 @@ +Source: x["a"].single_int32 == 23 +declare x { + value map(string, cel.expr.conformance.proto3.TestAllTypes) +} +=====> +_==_( + _[_]( + x~map(string, cel.expr.conformance.proto3.TestAllTypes)^x, + "a"~string + )~cel.expr.conformance.proto3.TestAllTypes^index_map.single_int32~int, + 23~int +)~bool^equals + +Source: x.size() == size(x) +declare x { + value map(string, cel.expr.conformance.proto3.TestAllTypes) +} +=====> +_==_( + x~map(string, cel.expr.conformance.proto3.TestAllTypes)^x.size()~int^map_size, + size( + x~map(string, cel.expr.conformance.proto3.TestAllTypes)^x + )~int^size_map +)~bool^equals + diff --git a/checker/src/test/resources/messageCreationError.baseline b/checker/src/test/resources/messageCreationError.baseline new file mode 100644 index 000000000..790dc6e0c --- /dev/null +++ b/checker/src/test/resources/messageCreationError.baseline @@ -0,0 +1,41 @@ +Source: x{foo: 1} +declare x { + value int +} +=====> +ERROR: test_location:1:2: 'int' is not a type + | x{foo: 1} + | .^ +ERROR: test_location:1:6: Message type resolution failure while referencing field 'foo'. + | x{foo: 1} + | .....^ + +Source: y{foo: 1} +declare x { + value int +} +declare y { + value type(int) +} +=====> +ERROR: test_location:1:2: 'int' is not a message type + | y{foo: 1} + | .^ +ERROR: test_location:1:6: Message type resolution failure while referencing field 'foo'. + | y{foo: 1} + | .....^ + +Source: z{foo: 1} +declare x { + value int +} +declare y { + value type(int) +} +declare z { + value type(msg_without_descriptor) +} +=====> +ERROR: test_location:1:6: Message type resolution failure while referencing field 'foo'. Ensure that the descriptor for type 'msg_without_descriptor' was added to the environment + | z{foo: 1} + | .....^ diff --git a/checker/src/test/resources/messageFieldSelect.baseline b/checker/src/test/resources/messageFieldSelect.baseline new file mode 100644 index 000000000..2247ce751 --- /dev/null +++ b/checker/src/test/resources/messageFieldSelect.baseline @@ -0,0 +1,22 @@ +Source: x.single_nested_message.bb == 43 && has(x.single_nested_message) && has(x.single_int32) && has(x.repeated_int32) && has(x.map_int64_nested_type) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_&&_( + _&&_( + _&&_( + _==_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage.bb~int, + 43~int + )~bool^equals, + x~cel.expr.conformance.proto3.TestAllTypes^x.single_nested_message~test-only~~bool + )~bool^logical_and, + x~cel.expr.conformance.proto3.TestAllTypes^x.single_int32~test-only~~bool + )~bool^logical_and, + _&&_( + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int32~test-only~~bool, + x~cel.expr.conformance.proto3.TestAllTypes^x.map_int64_nested_type~test-only~~bool + )~bool^logical_and +)~bool^logical_and + diff --git a/checker/src/test/resources/messageFieldSelectError.baseline b/checker/src/test/resources/messageFieldSelectError.baseline new file mode 100644 index 000000000..2bf3ad7f7 --- /dev/null +++ b/checker/src/test/resources/messageFieldSelectError.baseline @@ -0,0 +1,11 @@ +Source: x.single_nested_message.undefined == x.undefined +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +ERROR: test_location:1:24: undefined field 'undefined' + | x.single_nested_message.undefined == x.undefined + | .......................^ +ERROR: test_location:1:39: undefined field 'undefined' + | x.single_nested_message.undefined == x.undefined + | ......................................^ diff --git a/checker/src/test/resources/namespacedFunctions.baseline b/checker/src/test/resources/namespacedFunctions.baseline new file mode 100644 index 000000000..b6ace0e3e --- /dev/null +++ b/checker/src/test/resources/namespacedFunctions.baseline @@ -0,0 +1,168 @@ +Source: ns.func('hello') +declare ns.func { + function ns_func_overload (string) -> int +} +=====> +ns.func( + "hello"~string +)~int^ns_func_overload + +Source: ns.func('hello').member(ns.func('test')) +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +ns.func( + "hello"~string +)~int^ns_func_overload.member( + ns.func( + "test"~string + )~int^ns_func_overload +)~int^ns_member_overload + +Source: {ns.func('test'): 2} +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +{ + ns.func( + "test"~string + )~int^ns_func_overload:2~int +}~map(int, int) + +Source: {2: ns.func('test')} +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +{ + 2~int:ns.func( + "test"~string + )~int^ns_func_overload +}~map(int, int) + +Source: [ns.func('test'), 2] +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +[ + ns.func( + "test"~string + )~int^ns_func_overload, + 2~int +]~list(int) + +Source: [ns.func('test')].map(x, x * 2) +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +__comprehension__( + // Variable + x, + // Target + [ + ns.func( + "test"~string + )~int^ns_func_overload + ]~list(int), + // Accumulator + @result, + // Init + []~list(int), + // LoopCondition + true~bool, + // LoopStep + _+_( + @result~list(int)^@result, + [ + _*_( + x~int^x, + 2~int + )~int^multiply_int64 + ]~list(int) + )~list(int)^add_list, + // Result + @result~list(int)^@result)~list(int) + +Source: [1, 2].map(x, x * ns.func('test')) +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +__comprehension__( + // Variable + x, + // Target + [ + 1~int, + 2~int + ]~list(int), + // Accumulator + @result, + // Init + []~list(int), + // LoopCondition + true~bool, + // LoopStep + _+_( + @result~list(int)^@result, + [ + _*_( + x~int^x, + ns.func( + "test"~string + )~int^ns_func_overload + )~int^multiply_int64 + ]~list(int) + )~list(int)^add_list, + // Result + @result~list(int)^@result)~list(int) + +Source: func('hello') +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +ns.func( + "hello"~string +)~int^ns_func_overload + +Source: func('hello').member(func('test')) +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +ns.func( + "hello"~string +)~int^ns_func_overload.member( + ns.func( + "test"~string + )~int^ns_func_overload +)~int^ns_member_overload \ No newline at end of file diff --git a/checker/src/test/resources/namespacedVariables.baseline b/checker/src/test/resources/namespacedVariables.baseline new file mode 100644 index 000000000..b7594c820 --- /dev/null +++ b/checker/src/test/resources/namespacedVariables.baseline @@ -0,0 +1,16 @@ +Source: x +declare ns.x { + value int +} +=====> +ns.x~int^ns.x + +Source: msgVar.single_int32 +declare ns.x { + value int +} +declare cel.expr.conformance.proto3.msgVar { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +cel.expr.conformance.proto3.msgVar~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.msgVar.single_int32~int diff --git a/checker/src/test/resources/nestedEnums.baseline b/checker/src/test/resources/nestedEnums.baseline new file mode 100644 index 000000000..f05594997 --- /dev/null +++ b/checker/src/test/resources/nestedEnums.baseline @@ -0,0 +1,37 @@ +Source: x.single_nested_enum == TestAllTypes.NestedEnum.BAR +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_==_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_nested_enum~int, + cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR +)~bool^equals + +Source: single_nested_enum == TestAllTypes.NestedEnum.BAR +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare single_nested_enum { + value int +} +=====> +_==_( + single_nested_enum~int^single_nested_enum, + cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR +)~bool^equals + +Source: TestAllTypes{single_nested_enum : TestAllTypes.NestedEnum.BAR}.single_nested_enum == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare single_nested_enum { + value int +} +=====> +_==_( + cel.expr.conformance.proto3.TestAllTypes{ + single_nested_enum:cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR~int^cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR + }~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes.single_nested_enum~int, + 1~int +)~bool^equals \ No newline at end of file diff --git a/checker/src/test/resources/nullNull.baseline b/checker/src/test/resources/nullNull.baseline new file mode 100644 index 000000000..4d200d7d3 --- /dev/null +++ b/checker/src/test/resources/nullNull.baseline @@ -0,0 +1,12 @@ +Source: null == null && null != null +=====> +_&&_( + _==_( + null~null, + null~null + )~bool^equals, + _!=_( + null~null, + null~null + )~bool^not_equals +)~bool^logical_and diff --git a/checker/src/test/resources/nullableMessage.baseline b/checker/src/test/resources/nullableMessage.baseline new file mode 100644 index 000000000..54f8e56d5 --- /dev/null +++ b/checker/src/test/resources/nullableMessage.baseline @@ -0,0 +1,25 @@ +Source: x.single_nested_message != null +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_!=_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_nested_message~cel.expr.conformance.proto3.TestAllTypes.NestedMessage, + null~null +)~bool^not_equals + +Source: null == TestAllTypes{} || TestAllTypes{} == null +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_||_( + _==_( + null~null, + cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes + )~bool^equals, + _==_( + cel.expr.conformance.proto3.TestAllTypes{}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes, + null~null + )~bool^equals +)~bool^logical_or \ No newline at end of file diff --git a/checker/src/test/resources/nullablePrimitiveError.baseline b/checker/src/test/resources/nullablePrimitiveError.baseline new file mode 100644 index 000000000..202497f03 --- /dev/null +++ b/checker/src/test/resources/nullablePrimitiveError.baseline @@ -0,0 +1,8 @@ +Source: x.single_int64 != null +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +ERROR: test_location:1:16: found no matching overload for '_!=_' applied to '(int, null)' (candidates: (%A0, %A0)) + | x.single_int64 != null + | ...............^ diff --git a/checker/src/test/resources/nullableWrapper.baseline b/checker/src/test/resources/nullableWrapper.baseline new file mode 100644 index 000000000..d8e323193 --- /dev/null +++ b/checker/src/test/resources/nullableWrapper.baseline @@ -0,0 +1,10 @@ +Source: x.single_int64_wrapper == null +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_==_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_int64_wrapper~wrapper(int), + null~null +)~bool^equals + diff --git a/checker/src/test/resources/operatorsBool.baseline b/checker/src/test/resources/operatorsBool.baseline new file mode 100644 index 000000000..b66e4014d --- /dev/null +++ b/checker/src/test/resources/operatorsBool.baseline @@ -0,0 +1,16 @@ +Source: false && !true || false ? 2 : 3 +=====> +_?_:_( + _||_( + _&&_( + false~bool, + !_( + true~bool + )~bool^logical_not + )~bool^logical_and, + false~bool + )~bool^logical_or, + 2~int, + 3~int +)~int^conditional + diff --git a/checker/src/test/resources/operatorsBytes.baseline b/checker/src/test/resources/operatorsBytes.baseline new file mode 100644 index 000000000..c7c961f56 --- /dev/null +++ b/checker/src/test/resources/operatorsBytes.baseline @@ -0,0 +1,6 @@ +Source: b"abc" + b"def" +=====> +_+_( + b"abc"~bytes, + b"def"~bytes +)~bytes^add_bytes diff --git a/checker/src/test/resources/operatorsConditional.baseline b/checker/src/test/resources/operatorsConditional.baseline new file mode 100644 index 000000000..f567eb9d5 --- /dev/null +++ b/checker/src/test/resources/operatorsConditional.baseline @@ -0,0 +1,10 @@ +Source: false ? x.single_timestamp : null +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_?_:_( + false~bool, + x~cel.expr.conformance.proto3.TestAllTypes^x.single_timestamp~google.protobuf.Timestamp, + null~null +)~google.protobuf.Timestamp^conditional diff --git a/checker/src/test/resources/operatorsDouble.baseline b/checker/src/test/resources/operatorsDouble.baseline new file mode 100644 index 000000000..8f4f15fb3 --- /dev/null +++ b/checker/src/test/resources/operatorsDouble.baseline @@ -0,0 +1,19 @@ +Source: 1.0 + 2.0 * 3.0 - 1.0 / 2.20202 != 66.6 +=====> +_!=_( + _-_( + _+_( + 1.0~double, + _*_( + 2.0~double, + 3.0~double + )~double^multiply_double + )~double^add_double, + _/_( + 1.0~double, + 2.20202~double + )~double^divide_double + )~double^subtract_double, + 66.6~double +)~bool^not_equals + diff --git a/checker/src/test/resources/operatorsInt64.baseline b/checker/src/test/resources/operatorsInt64.baseline new file mode 100644 index 000000000..f57f828dc --- /dev/null +++ b/checker/src/test/resources/operatorsInt64.baseline @@ -0,0 +1,21 @@ +Source: 1 + 2 * 3 - 1 / 2 == 6 % 1 +=====> +_==_( + _-_( + _+_( + 1~int, + _*_( + 2~int, + 3~int + )~int^multiply_int64 + )~int^add_int64, + _/_( + 1~int, + 2~int + )~int^divide_int64 + )~int^subtract_int64, + _%_( + 6~int, + 1~int + )~int^modulo_int64 +)~bool^equals diff --git a/checker/src/test/resources/operatorsString.baseline b/checker/src/test/resources/operatorsString.baseline new file mode 100644 index 000000000..0d9e0ce61 --- /dev/null +++ b/checker/src/test/resources/operatorsString.baseline @@ -0,0 +1,7 @@ +Source: "abc" + "def" +=====> +_+_( + "abc"~string, + "def"~string +)~string^add_string + diff --git a/checker/src/test/resources/operatorsUInt64.baseline b/checker/src/test/resources/operatorsUInt64.baseline new file mode 100644 index 000000000..7d1797ac2 --- /dev/null +++ b/checker/src/test/resources/operatorsUInt64.baseline @@ -0,0 +1,22 @@ +Source: 1u + 2u * 3u - 1u / 2u == 6u % 1u +=====> +_==_( + _-_( + _+_( + 1u~uint, + _*_( + 2u~uint, + 3u~uint + )~uint^multiply_uint64 + )~uint^add_uint64, + _/_( + 1u~uint, + 2u~uint + )~uint^divide_uint64 + )~uint^subtract_uint64, + _%_( + 6u~uint, + 1u~uint + )~uint^modulo_uint64 +)~bool^equals + diff --git a/checker/src/test/resources/optionalErrors.baseline b/checker/src/test/resources/optionalErrors.baseline new file mode 100644 index 000000000..f143b26bf --- /dev/null +++ b/checker/src/test/resources/optionalErrors.baseline @@ -0,0 +1,26 @@ +Source: {?'key': 'hi'} +=====> +ERROR: test_location:1:10: expected type 'optional_type(string)' but found 'string' + | {?'key': 'hi'} + | .........^ + +Source: [?'value'] +=====> +ERROR: test_location:1:3: expected type 'optional_type(string)' but found 'string' + | [?'value'] + | ..^ + +Source: TestAllTypes{?single_int32: 1} +=====> +ERROR: test_location:1:29: expected type 'optional_type(int)' but found 'int' + | TestAllTypes{?single_int32: 1} + | ............................^ + +Source: a.?b +declare a { + value map(string, string) +} +=====> +ERROR: :1:1: unsupported optional field selection + | a.?b + | ^ diff --git a/checker/src/test/resources/optionals.baseline b/checker/src/test/resources/optionals.baseline new file mode 100644 index 000000000..be50e44ba --- /dev/null +++ b/checker/src/test/resources/optionals.baseline @@ -0,0 +1,121 @@ +Source: a.?b +declare a { + value map(string, string) +} +=====> +_?._( + a~map(string, string)^a, + "b" +)~optional_type(string)^select_optional_field + +Source: x.y +declare x { + value optional_type(map(string, string)) +} +=====> +x~optional_type(map(string, string))^x.y~optional_type(string) + +Source: {?'nested': x.b} +declare x { + value optional_type(map(string, string)) +} +=====> +{ + ?"nested"~string:x~optional_type(map(string, string))^x.b~optional_type(string) +}~map(string, string) + +Source: d.dynamic +declare d { + value optional_type(dyn) +} +=====> +d~optional_type(dyn)^d.dynamic~optional_type(dyn) + +Source: has(d.dynamic) +declare d { + value optional_type(dyn) +} +=====> +d~optional_type(dyn)^d.dynamic~test-only~~bool + +Source: has(e.?b.c) +declare e { + value optional_type(map(string, dyn)) +} +=====> +_?._( + e~optional_type(map(string, dyn))^e, + "b" +)~optional_type(dyn)^select_optional_field.c~test-only~~bool + +Source: {?'key': {'a': 'b'}.?value} +=====> +{ + ?"key"~string:_?._( + { + "a"~string:"b"~string + }~map(string, string), + "value" + )~optional_type(string)^select_optional_field +}~map(string, string) + +Source: {?'key': {'a': 'b'}.?value}.key +=====> +{ + ?"key"~string:_?._( + { + "a"~string:"b"~string + }~map(string, string), + "value" + )~optional_type(string)^select_optional_field +}~map(string, string).key~string + +Source: TestAllTypes{?single_int32: {}.?i} +=====> +cel.expr.conformance.proto3.TestAllTypes{ + ?single_int32:_?._( + {}~map(dyn, int), + "i" + )~optional_type(int)^select_optional_field +}~cel.expr.conformance.proto3.TestAllTypes^cel.expr.conformance.proto3.TestAllTypes + +Source: [?a, ?b, 'world'] +declare a { + value optional_type(string) +} +declare b { + value optional_type(string) +} +=====> +[ + ?a~optional_type(string)^a, + ?b~optional_type(string)^b, + "world"~string +]~list(string) + +Source: [?a, ?b, 2] +declare a { + value optional_type(string) +} +declare b { + value optional_type(string) +} +=====> +[ + ?a~optional_type(string)^a, + ?b~optional_type(string)^b, + 2~int +]~list(dyn) + +Source: {?'str':a, 2:3} +declare a { + value optional_type(string) +} +declare b { + value optional_type(string) +} +=====> +{ + ?"str"~string:a~optional_type(string)^a, + 2~int:3~int +}~map(dyn, dyn) \ No newline at end of file diff --git a/checker/src/test/resources/proto2PrimitiveField.baseline b/checker/src/test/resources/proto2PrimitiveField.baseline new file mode 100644 index 000000000..47546cc8b --- /dev/null +++ b/checker/src/test/resources/proto2PrimitiveField.baseline @@ -0,0 +1,18 @@ +Source: x.single_fixed32 != 0u && x.single_fixed64 > 1u && x.single_int32 != null +declare x { + value cel.expr.conformance.proto2.TestAllTypes +} +=====> +ERROR: test_location:1:67: found no matching overload for '_!=_' applied to '(int, null)' (candidates: (%A1, %A1)) + | x.single_fixed32 != 0u && x.single_fixed64 > 1u && x.single_int32 != null + | ..................................................................^ + +Source: x.nestedgroup.single_name == '' +declare x { + value cel.expr.conformance.proto2.TestAllTypes +} +=====> +_==_( + x~cel.expr.conformance.proto2.TestAllTypes^x.nestedgroup~cel.expr.conformance.proto2.TestAllTypes.NestedGroup.single_name~string, + ""~string +)~bool^equals diff --git a/checker/src/test/resources/quantifiers.baseline b/checker/src/test/resources/quantifiers.baseline new file mode 100644 index 000000000..3f204a6f5 --- /dev/null +++ b/checker/src/test/resources/quantifiers.baseline @@ -0,0 +1,85 @@ +Source: x.repeated_int64.all(e, e > 0) && x.repeated_int64.exists(e, e < 0) && x.repeated_int64.exists_one(e, e == 0) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_&&_( + _&&_( + __comprehension__( + // Variable + e, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int64~list(int), + // Accumulator + @result, + // Init + true~bool, + // LoopCondition + @not_strictly_false( + @result~bool^@result + )~bool^not_strictly_false, + // LoopStep + _&&_( + @result~bool^@result, + _>_( + e~int^e, + 0~int + )~bool^greater_int64 + )~bool^logical_and, + // Result + @result~bool^@result)~bool, + __comprehension__( + // Variable + e, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int64~list(int), + // Accumulator + @result, + // Init + false~bool, + // LoopCondition + @not_strictly_false( + !_( + @result~bool^@result + )~bool^logical_not + )~bool^not_strictly_false, + // LoopStep + _||_( + @result~bool^@result, + _<_( + e~int^e, + 0~int + )~bool^less_int64 + )~bool^logical_or, + // Result + @result~bool^@result)~bool + )~bool^logical_and, + __comprehension__( + // Variable + e, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int64~list(int), + // Accumulator + @result, + // Init + 0~int, + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _==_( + e~int^e, + 0~int + )~bool^equals, + _+_( + @result~int^@result, + 1~int + )~int^add_int64, + @result~int^@result + )~int^conditional, + // Result + _==_( + @result~int^@result, + 1~int + )~bool^equals)~bool +)~bool^logical_and \ No newline at end of file diff --git a/checker/src/test/resources/quantifiersErrors.baseline b/checker/src/test/resources/quantifiersErrors.baseline new file mode 100644 index 000000000..17c1736c5 --- /dev/null +++ b/checker/src/test/resources/quantifiersErrors.baseline @@ -0,0 +1,11 @@ +Source: x.all(e, 0) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +ERROR: test_location:1:1: expression of type 'cel.expr.conformance.proto3.TestAllTypes' cannot be range of a comprehension (must be list, map, or dynamic) + | x.all(e, 0) + | ^ +ERROR: test_location:1:6: found no matching overload for '_&&_' applied to '(bool, int)' (candidates: (bool, bool)) + | x.all(e, 0) + | .....^ diff --git a/checker/src/test/resources/referenceTypeAbsolute.baseline b/checker/src/test/resources/referenceTypeAbsolute.baseline new file mode 100644 index 000000000..401e6fe0c --- /dev/null +++ b/checker/src/test/resources/referenceTypeAbsolute.baseline @@ -0,0 +1,36 @@ +Source: .cel.expr.conformance.proto3.TestAllTypes +=====> +cel.expr.conformance.proto3.TestAllTypes~type(cel.expr.conformance.proto3.TestAllTypes)^cel.expr.conformance.proto3.TestAllTypes + +Source: [0].exists(app, .app.config == 1) +declare app.config { + value int +} +=====> +__comprehension__( + // Variable + app, + // Target + [ + 0~int + ]~list(int), + // Accumulator + @result, + // Init + false~bool, + // LoopCondition + @not_strictly_false( + !_( + @result~bool^@result + )~bool^logical_not + )~bool^not_strictly_false, + // LoopStep + _||_( + @result~bool^@result, + _==_( + .app.config~int^.app.config, + 1~int + )~bool^equals + )~bool^logical_or, + // Result + @result~bool^@result)~bool diff --git a/checker/src/test/resources/referenceTypeRelative.baseline b/checker/src/test/resources/referenceTypeRelative.baseline new file mode 100644 index 000000000..e0c681d61 --- /dev/null +++ b/checker/src/test/resources/referenceTypeRelative.baseline @@ -0,0 +1,3 @@ +Source: proto3.TestAllTypes +=====> +cel.expr.conformance.proto3.TestAllTypes~type(cel.expr.conformance.proto3.TestAllTypes)^cel.expr.conformance.proto3.TestAllTypes diff --git a/checker/src/test/resources/referenceUndefinedError.baseline b/checker/src/test/resources/referenceUndefinedError.baseline new file mode 100644 index 000000000..eb2e6e093 --- /dev/null +++ b/checker/src/test/resources/referenceUndefinedError.baseline @@ -0,0 +1,5 @@ +Source: 1 + x +=====> +ERROR: test_location:1:5: undeclared reference to 'x' (in container '') + | 1 + x + | ....^ diff --git a/checker/src/test/resources/referenceValue.baseline b/checker/src/test/resources/referenceValue.baseline new file mode 100644 index 000000000..165b0bc6b --- /dev/null +++ b/checker/src/test/resources/referenceValue.baseline @@ -0,0 +1,6 @@ +Source: x +declare container.x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +container.x~cel.expr.conformance.proto3.TestAllTypes^container.x diff --git a/checker/src/test/resources/standardEnvDump.baseline b/checker/src/test/resources/standardEnvDump.baseline new file mode 100644 index 000000000..864bfd340 --- /dev/null +++ b/checker/src/test/resources/standardEnvDump.baseline @@ -0,0 +1,299 @@ +Source: 'redundant expression so the env is constructed and can be printed' +=====> +"redundant expression so the env is constructed and can be printed"~string + + +Standard environment: +declare cel.@mapInsert { + function cel_@mapInsert_map_map (map(K, V), map(K, V)) -> map(K, V) + function cel_@mapInsert_map_key_value (map(K, V), K, V) -> map(K, V) +} +declare !_ { + function logical_not (bool) -> bool +} +declare -_ { + function negate_int64 (int) -> int + function negate_double (double) -> double +} +declare @in { + function in_list (A, list(A)) -> bool + function in_map (A, map(A, B)) -> bool +} +declare @not_strictly_false { + function not_strictly_false (bool) -> bool +} +declare _!=_ { + function not_equals (A, A) -> bool +} +declare _%_ { + function modulo_int64 (int, int) -> int + function modulo_uint64 (uint, uint) -> uint +} +declare _&&_ { + function logical_and (bool, bool) -> bool +} +declare _*_ { + function multiply_int64 (int, int) -> int + function multiply_uint64 (uint, uint) -> uint + function multiply_double (double, double) -> double +} +declare _+_ { + function add_int64 (int, int) -> int + function add_uint64 (uint, uint) -> uint + function add_double (double, double) -> double + function add_string (string, string) -> string + function add_bytes (bytes, bytes) -> bytes + function add_list (list(A), list(A)) -> list(A) + function add_timestamp_duration (google.protobuf.Timestamp, google.protobuf.Duration) -> google.protobuf.Timestamp + function add_duration_timestamp (google.protobuf.Duration, google.protobuf.Timestamp) -> google.protobuf.Timestamp + function add_duration_duration (google.protobuf.Duration, google.protobuf.Duration) -> google.protobuf.Duration +} +declare _-_ { + function subtract_int64 (int, int) -> int + function subtract_uint64 (uint, uint) -> uint + function subtract_double (double, double) -> double + function subtract_timestamp_timestamp (google.protobuf.Timestamp, google.protobuf.Timestamp) -> google.protobuf.Duration + function subtract_timestamp_duration (google.protobuf.Timestamp, google.protobuf.Duration) -> google.protobuf.Timestamp + function subtract_duration_duration (google.protobuf.Duration, google.protobuf.Duration) -> google.protobuf.Duration +} +declare _/_ { + function divide_int64 (int, int) -> int + function divide_uint64 (uint, uint) -> uint + function divide_double (double, double) -> double +} +declare _<=_ { + function less_equals_bool (bool, bool) -> bool + function less_equals_int64 (int, int) -> bool + function less_equals_uint64 (uint, uint) -> bool + function less_equals_double (double, double) -> bool + function less_equals_string (string, string) -> bool + function less_equals_bytes (bytes, bytes) -> bool + function less_equals_timestamp (google.protobuf.Timestamp, google.protobuf.Timestamp) -> bool + function less_equals_duration (google.protobuf.Duration, google.protobuf.Duration) -> bool + function less_equals_int64_uint64 (int, uint) -> bool + function less_equals_uint64_int64 (uint, int) -> bool + function less_equals_int64_double (int, double) -> bool + function less_equals_double_int64 (double, int) -> bool + function less_equals_uint64_double (uint, double) -> bool + function less_equals_double_uint64 (double, uint) -> bool +} +declare _<_ { + function less_bool (bool, bool) -> bool + function less_int64 (int, int) -> bool + function less_uint64 (uint, uint) -> bool + function less_double (double, double) -> bool + function less_string (string, string) -> bool + function less_bytes (bytes, bytes) -> bool + function less_timestamp (google.protobuf.Timestamp, google.protobuf.Timestamp) -> bool + function less_duration (google.protobuf.Duration, google.protobuf.Duration) -> bool + function less_int64_uint64 (int, uint) -> bool + function less_uint64_int64 (uint, int) -> bool + function less_int64_double (int, double) -> bool + function less_double_int64 (double, int) -> bool + function less_uint64_double (uint, double) -> bool + function less_double_uint64 (double, uint) -> bool +} +declare _==_ { + function equals (A, A) -> bool +} +declare _>=_ { + function greater_equals_bool (bool, bool) -> bool + function greater_equals_int64 (int, int) -> bool + function greater_equals_uint64 (uint, uint) -> bool + function greater_equals_double (double, double) -> bool + function greater_equals_string (string, string) -> bool + function greater_equals_bytes (bytes, bytes) -> bool + function greater_equals_timestamp (google.protobuf.Timestamp, google.protobuf.Timestamp) -> bool + function greater_equals_duration (google.protobuf.Duration, google.protobuf.Duration) -> bool + function greater_equals_int64_uint64 (int, uint) -> bool + function greater_equals_uint64_int64 (uint, int) -> bool + function greater_equals_int64_double (int, double) -> bool + function greater_equals_double_int64 (double, int) -> bool + function greater_equals_uint64_double (uint, double) -> bool + function greater_equals_double_uint64 (double, uint) -> bool +} +declare _>_ { + function greater_bool (bool, bool) -> bool + function greater_int64 (int, int) -> bool + function greater_uint64 (uint, uint) -> bool + function greater_double (double, double) -> bool + function greater_string (string, string) -> bool + function greater_bytes (bytes, bytes) -> bool + function greater_timestamp (google.protobuf.Timestamp, google.protobuf.Timestamp) -> bool + function greater_duration (google.protobuf.Duration, google.protobuf.Duration) -> bool + function greater_int64_uint64 (int, uint) -> bool + function greater_uint64_int64 (uint, int) -> bool + function greater_int64_double (int, double) -> bool + function greater_double_int64 (double, int) -> bool + function greater_uint64_double (uint, double) -> bool + function greater_double_uint64 (double, uint) -> bool +} +declare _?_:_ { + function conditional (bool, A, A) -> A +} +declare _[_] { + function index_list (list(A), int) -> A + function index_map (map(A, B), A) -> B +} +declare __not_strictly_false__ { + function not_strictly_false (bool) -> bool +} +declare _in_ { + function in_list (A, list(A)) -> bool + function in_map (A, map(A, B)) -> bool +} +declare _||_ { + function logical_or (bool, bool) -> bool +} +declare bool { + value type(bool) +} +declare bool { + function bool_to_bool (bool) -> bool + function string_to_bool (string) -> bool +} +declare bytes { + value type(bytes) +} +declare bytes { + function bytes_to_bytes (bytes) -> bytes + function string_to_bytes (string) -> bytes +} +declare contains { + function contains_string string.(string) -> bool +} +declare double { + value type(double) +} +declare double { + function double_to_double (double) -> double + function int64_to_double (int) -> double + function uint64_to_double (uint) -> double + function string_to_double (string) -> double +} +declare duration { + function duration_to_duration (google.protobuf.Duration) -> google.protobuf.Duration + function string_to_duration (string) -> google.protobuf.Duration +} +declare dyn { + value type(dyn) +} +declare dyn { + function to_dyn (A) -> dyn +} +declare endsWith { + function ends_with_string string.(string) -> bool +} +declare getDate { + function timestamp_to_day_of_month_1_based google.protobuf.Timestamp.() -> int + function timestamp_to_day_of_month_1_based_with_tz google.protobuf.Timestamp.(string) -> int +} +declare getDayOfMonth { + function timestamp_to_day_of_month google.protobuf.Timestamp.() -> int + function timestamp_to_day_of_month_with_tz google.protobuf.Timestamp.(string) -> int +} +declare getDayOfWeek { + function timestamp_to_day_of_week google.protobuf.Timestamp.() -> int + function timestamp_to_day_of_week_with_tz google.protobuf.Timestamp.(string) -> int +} +declare getDayOfYear { + function timestamp_to_day_of_year google.protobuf.Timestamp.() -> int + function timestamp_to_day_of_year_with_tz google.protobuf.Timestamp.(string) -> int +} +declare getFullYear { + function timestamp_to_year google.protobuf.Timestamp.() -> int + function timestamp_to_year_with_tz google.protobuf.Timestamp.(string) -> int +} +declare getHours { + function timestamp_to_hours google.protobuf.Timestamp.() -> int + function timestamp_to_hours_with_tz google.protobuf.Timestamp.(string) -> int + function duration_to_hours google.protobuf.Duration.() -> int +} +declare getMilliseconds { + function timestamp_to_milliseconds google.protobuf.Timestamp.() -> int + function timestamp_to_milliseconds_with_tz google.protobuf.Timestamp.(string) -> int + function duration_to_milliseconds google.protobuf.Duration.() -> int +} +declare getMinutes { + function timestamp_to_minutes google.protobuf.Timestamp.() -> int + function timestamp_to_minutes_with_tz google.protobuf.Timestamp.(string) -> int + function duration_to_minutes google.protobuf.Duration.() -> int +} +declare getMonth { + function timestamp_to_month google.protobuf.Timestamp.() -> int + function timestamp_to_month_with_tz google.protobuf.Timestamp.(string) -> int +} +declare getSeconds { + function timestamp_to_seconds google.protobuf.Timestamp.() -> int + function timestamp_to_seconds_with_tz google.protobuf.Timestamp.(string) -> int + function duration_to_seconds google.protobuf.Duration.() -> int +} +declare int { + value type(int) +} +declare int { + function int64_to_int64 (int) -> int + function uint64_to_int64 (uint) -> int + function double_to_int64 (double) -> int + function string_to_int64 (string) -> int + function timestamp_to_int64 (google.protobuf.Timestamp) -> int +} +declare list { + value type(list(dyn)) +} +declare map { + value type(map(dyn, dyn)) +} +declare matches { + function matches (string, string) -> bool + function matches_string string.(string) -> bool +} +declare null_type { + value type(null) +} +declare size { + function size_string (string) -> int + function size_bytes (bytes) -> int + function size_list (list(A)) -> int + function size_map (map(A, B)) -> int + function string_size string.() -> int + function bytes_size bytes.() -> int + function list_size list(A).() -> int + function map_size map(A, B).() -> int +} +declare startsWith { + function starts_with_string string.(string) -> bool +} +declare string { + value type(string) +} +declare string { + function string_to_string (string) -> string + function int64_to_string (int) -> string + function uint64_to_string (uint) -> string + function double_to_string (double) -> string + function bool_to_string (bool) -> string + function bytes_to_string (bytes) -> string + function timestamp_to_string (google.protobuf.Timestamp) -> string + function duration_to_string (google.protobuf.Duration) -> string +} +declare timestamp { + function string_to_timestamp (string) -> google.protobuf.Timestamp + function timestamp_to_timestamp (google.protobuf.Timestamp) -> google.protobuf.Timestamp + function int64_to_timestamp (int) -> google.protobuf.Timestamp +} +declare type { + value type(dyn) +} +declare type { + function type (A) -> type(A) +} +declare uint { + value type(uint) +} +declare uint { + function uint64_to_uint64 (uint) -> uint + function int64_to_uint64 (int) -> uint + function double_to_uint64 (double) -> uint + function string_to_uint64 (string) -> uint +} \ No newline at end of file diff --git a/checker/src/test/resources/twoVarComprehensions_allMacro.baseline b/checker/src/test/resources/twoVarComprehensions_allMacro.baseline new file mode 100644 index 000000000..6a6de8b75 --- /dev/null +++ b/checker/src/test/resources/twoVarComprehensions_allMacro.baseline @@ -0,0 +1,126 @@ +Source: x.map_string_string.all(i, v, i < v) && x.repeated_int64.all(i, v, i < v) && [1, 2, 3, 4].all(i, v, i < 5 && v > 0) && {'a': 1, 'b': 2}.all(k, v, k.startsWith('a') && v == 1) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_&&_( + _&&_( + __comprehension__( + // Variable + i, + v, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.map_string_string~map(string, string), + // Accumulator + @result, + // Init + true~bool, + // LoopCondition + @not_strictly_false( + @result~bool^@result + )~bool^not_strictly_false, + // LoopStep + _&&_( + @result~bool^@result, + _<_( + i~string^i, + v~string^v + )~bool^less_string + )~bool^logical_and, + // Result + @result~bool^@result)~bool, + __comprehension__( + // Variable + i, + v, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int64~list(int), + // Accumulator + @result, + // Init + true~bool, + // LoopCondition + @not_strictly_false( + @result~bool^@result + )~bool^not_strictly_false, + // LoopStep + _&&_( + @result~bool^@result, + _<_( + i~int^i, + v~int^v + )~bool^less_int64 + )~bool^logical_and, + // Result + @result~bool^@result)~bool + )~bool^logical_and, + _&&_( + __comprehension__( + // Variable + i, + v, + // Target + [ + 1~int, + 2~int, + 3~int, + 4~int + ]~list(int), + // Accumulator + @result, + // Init + true~bool, + // LoopCondition + @not_strictly_false( + @result~bool^@result + )~bool^not_strictly_false, + // LoopStep + _&&_( + @result~bool^@result, + _&&_( + _<_( + i~int^i, + 5~int + )~bool^less_int64, + _>_( + v~int^v, + 0~int + )~bool^greater_int64 + )~bool^logical_and + )~bool^logical_and, + // Result + @result~bool^@result)~bool, + __comprehension__( + // Variable + k, + v, + // Target + { + "a"~string:1~int, + "b"~string:2~int + }~map(string, int), + // Accumulator + @result, + // Init + true~bool, + // LoopCondition + @not_strictly_false( + @result~bool^@result + )~bool^not_strictly_false, + // LoopStep + _&&_( + @result~bool^@result, + _&&_( + k~string^k.startsWith( + "a"~string + )~bool^starts_with_string, + _==_( + v~int^v, + 1~int + )~bool^equals + )~bool^logical_and + )~bool^logical_and, + // Result + @result~bool^@result)~bool + )~bool^logical_and +)~bool^logical_and \ No newline at end of file diff --git a/checker/src/test/resources/twoVarComprehensions_duplicateIterVars.baseline b/checker/src/test/resources/twoVarComprehensions_duplicateIterVars.baseline new file mode 100644 index 000000000..d83030f27 --- /dev/null +++ b/checker/src/test/resources/twoVarComprehensions_duplicateIterVars.baseline @@ -0,0 +1,11 @@ +Source: x.repeated_int64.exists(i, i, i < v) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +ERROR: test_location:1:1: overlapping declaration name 'i' (type 'int' cannot be distinguished from 'int') + | x.repeated_int64.exists(i, i, i < v) + | ^ +ERROR: test_location:1:35: undeclared reference to 'v' (in container '') + | x.repeated_int64.exists(i, i, i < v) + | ..................................^ \ No newline at end of file diff --git a/checker/src/test/resources/twoVarComprehensions_existsMacro.baseline b/checker/src/test/resources/twoVarComprehensions_existsMacro.baseline new file mode 100644 index 000000000..e11ab7866 --- /dev/null +++ b/checker/src/test/resources/twoVarComprehensions_existsMacro.baseline @@ -0,0 +1,134 @@ +Source: x.map_string_string.exists(i, v, i < v) && x.repeated_int64.exists(i, v, i < v) && [1, 2, 3, 4].exists(i, v, i < 5 && v > 0) && {'a': 1, 'b': 2}.exists(k, v, k.startsWith('a') && v == 1) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_&&_( + _&&_( + __comprehension__( + // Variable + i, + v, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.map_string_string~map(string, string), + // Accumulator + @result, + // Init + false~bool, + // LoopCondition + @not_strictly_false( + !_( + @result~bool^@result + )~bool^logical_not + )~bool^not_strictly_false, + // LoopStep + _||_( + @result~bool^@result, + _<_( + i~string^i, + v~string^v + )~bool^less_string + )~bool^logical_or, + // Result + @result~bool^@result)~bool, + __comprehension__( + // Variable + i, + v, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int64~list(int), + // Accumulator + @result, + // Init + false~bool, + // LoopCondition + @not_strictly_false( + !_( + @result~bool^@result + )~bool^logical_not + )~bool^not_strictly_false, + // LoopStep + _||_( + @result~bool^@result, + _<_( + i~int^i, + v~int^v + )~bool^less_int64 + )~bool^logical_or, + // Result + @result~bool^@result)~bool + )~bool^logical_and, + _&&_( + __comprehension__( + // Variable + i, + v, + // Target + [ + 1~int, + 2~int, + 3~int, + 4~int + ]~list(int), + // Accumulator + @result, + // Init + false~bool, + // LoopCondition + @not_strictly_false( + !_( + @result~bool^@result + )~bool^logical_not + )~bool^not_strictly_false, + // LoopStep + _||_( + @result~bool^@result, + _&&_( + _<_( + i~int^i, + 5~int + )~bool^less_int64, + _>_( + v~int^v, + 0~int + )~bool^greater_int64 + )~bool^logical_and + )~bool^logical_or, + // Result + @result~bool^@result)~bool, + __comprehension__( + // Variable + k, + v, + // Target + { + "a"~string:1~int, + "b"~string:2~int + }~map(string, int), + // Accumulator + @result, + // Init + false~bool, + // LoopCondition + @not_strictly_false( + !_( + @result~bool^@result + )~bool^logical_not + )~bool^not_strictly_false, + // LoopStep + _||_( + @result~bool^@result, + _&&_( + k~string^k.startsWith( + "a"~string + )~bool^starts_with_string, + _==_( + v~int^v, + 1~int + )~bool^equals + )~bool^logical_and + )~bool^logical_or, + // Result + @result~bool^@result)~bool + )~bool^logical_and +)~bool^logical_and \ No newline at end of file diff --git a/checker/src/test/resources/twoVarComprehensions_existsOneMacro.baseline b/checker/src/test/resources/twoVarComprehensions_existsOneMacro.baseline new file mode 100644 index 000000000..ed393b921 --- /dev/null +++ b/checker/src/test/resources/twoVarComprehensions_existsOneMacro.baseline @@ -0,0 +1,146 @@ +Source: x.map_string_string.exists_one(i, v, i < v) && x.repeated_int64.exists_one(i, v, i < v) && [1, 2, 3, 4].exists_one(i, v, i < 5 && v > 0) && {'a': 1, 'b': 2}.exists_one(k, v, k.startsWith('a') && v == 1) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_&&_( + _&&_( + __comprehension__( + // Variable + i, + v, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.map_string_string~map(string, string), + // Accumulator + @result, + // Init + 0~int, + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _<_( + i~string^i, + v~string^v + )~bool^less_string, + _+_( + @result~int^@result, + 1~int + )~int^add_int64, + @result~int^@result + )~int^conditional, + // Result + _==_( + @result~int^@result, + 1~int + )~bool^equals)~bool, + __comprehension__( + // Variable + i, + v, + // Target + x~cel.expr.conformance.proto3.TestAllTypes^x.repeated_int64~list(int), + // Accumulator + @result, + // Init + 0~int, + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _<_( + i~int^i, + v~int^v + )~bool^less_int64, + _+_( + @result~int^@result, + 1~int + )~int^add_int64, + @result~int^@result + )~int^conditional, + // Result + _==_( + @result~int^@result, + 1~int + )~bool^equals)~bool + )~bool^logical_and, + _&&_( + __comprehension__( + // Variable + i, + v, + // Target + [ + 1~int, + 2~int, + 3~int, + 4~int + ]~list(int), + // Accumulator + @result, + // Init + 0~int, + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _&&_( + _<_( + i~int^i, + 5~int + )~bool^less_int64, + _>_( + v~int^v, + 0~int + )~bool^greater_int64 + )~bool^logical_and, + _+_( + @result~int^@result, + 1~int + )~int^add_int64, + @result~int^@result + )~int^conditional, + // Result + _==_( + @result~int^@result, + 1~int + )~bool^equals)~bool, + __comprehension__( + // Variable + k, + v, + // Target + { + "a"~string:1~int, + "b"~string:2~int + }~map(string, int), + // Accumulator + @result, + // Init + 0~int, + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _&&_( + k~string^k.startsWith( + "a"~string + )~bool^starts_with_string, + _==_( + v~int^v, + 1~int + )~bool^equals + )~bool^logical_and, + _+_( + @result~int^@result, + 1~int + )~int^add_int64, + @result~int^@result + )~int^conditional, + // Result + _==_( + @result~int^@result, + 1~int + )~bool^equals)~bool + )~bool^logical_and +)~bool^logical_and \ No newline at end of file diff --git a/checker/src/test/resources/twoVarComprehensions_incorrectIterVars.baseline b/checker/src/test/resources/twoVarComprehensions_incorrectIterVars.baseline new file mode 100644 index 000000000..862dd5657 --- /dev/null +++ b/checker/src/test/resources/twoVarComprehensions_incorrectIterVars.baseline @@ -0,0 +1,11 @@ +Source: x.map_string_string.all(i + 1, v, i < v) && x.repeated_int64.all(i, v + 1, i < v) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +ERROR: test_location:1:27: The argument must be a simple name + | x.map_string_string.all(i + 1, v, i < v) && x.repeated_int64.all(i, v + 1, i < v) + | ..........................^ +ERROR: test_location:1:71: The argument must be a simple name + | x.map_string_string.all(i + 1, v, i < v) && x.repeated_int64.all(i, v + 1, i < v) + | ......................................................................^ \ No newline at end of file diff --git a/checker/src/test/resources/twoVarComprehensions_incorrectNumberOfArgs.baseline b/checker/src/test/resources/twoVarComprehensions_incorrectNumberOfArgs.baseline new file mode 100644 index 000000000..08bfb51c0 --- /dev/null +++ b/checker/src/test/resources/twoVarComprehensions_incorrectNumberOfArgs.baseline @@ -0,0 +1,38 @@ +Source: [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +ERROR: test_location:1:24: undeclared reference to 'exists_one' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | .......................^ +ERROR: test_location:1:25: undeclared reference to 'i' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | ........................^ +ERROR: test_location:1:28: undeclared reference to 'v' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | ...........................^ +ERROR: test_location:1:31: undeclared reference to 'i' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | ..............................^ +ERROR: test_location:1:35: undeclared reference to 'v' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | ..................................^ +ERROR: test_location:1:38: undeclared reference to 'v' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | .....................................^ +ERROR: test_location:1:76: undeclared reference to 'transformList' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | ...........................................................................^ +ERROR: test_location:1:77: undeclared reference to 'i' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | ............................................................................^ +ERROR: test_location:1:80: undeclared reference to 'i' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | ...............................................................................^ +ERROR: test_location:1:84: undeclared reference to 'v' (in container '') + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | ...................................................................................^ +ERROR: test_location:1:131: found no matching overload for '_<_' applied to '(cel.expr.conformance.proto3.TestAllTypes, int)' (candidates: (bool, bool),(int, int),(uint, uint),(double, double),(string, string),(bytes, bytes),(google.protobuf.Timestamp, google.protobuf.Timestamp),(google.protobuf.Duration, google.protobuf.Duration),(int, uint),(uint, int),(int, double),(double, int),(uint, double),(double, uint)) + | [1, 2, 3, 4].exists_one(i, v, i < v, v)&& x.map_string_string.transformList(i, i < v) && [1, 2, 3].transformList(i, v, i > 0 && x < 3, (i * v) + v) == [4] + | ..................................................................................................................................^ \ No newline at end of file diff --git a/checker/src/test/resources/twoVarComprehensions_transformListMacro.baseline b/checker/src/test/resources/twoVarComprehensions_transformListMacro.baseline new file mode 100644 index 000000000..f821fa9c2 --- /dev/null +++ b/checker/src/test/resources/twoVarComprehensions_transformListMacro.baseline @@ -0,0 +1,143 @@ +Source: [1, 2, 3].transformList(i, v, i > 0 && v < 3, (i * v) + v) == [4] && [1, 2, 3].transformList(i, v, i % 2 == 0, (i * v) + v) == [1,9] && [1, 2, 3].transformList(i, v, (i * v) + v) == [1,4,9] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_&&_( + _&&_( + _==_( + __comprehension__( + // Variable + i, + v, + // Target + [ + 1~int, + 2~int, + 3~int + ]~list(int), + // Accumulator + @result, + // Init + []~list(int), + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _&&_( + _>_( + i~int^i, + 0~int + )~bool^greater_int64, + _<_( + v~int^v, + 3~int + )~bool^less_int64 + )~bool^logical_and, + _+_( + @result~list(int)^@result, + [ + _+_( + _*_( + i~int^i, + v~int^v + )~int^multiply_int64, + v~int^v + )~int^add_int64 + ]~list(int) + )~list(int)^add_list, + @result~list(int)^@result + )~list(int)^conditional, + // Result + @result~list(int)^@result)~list(int), + [ + 4~int + ]~list(int) + )~bool^equals, + _==_( + __comprehension__( + // Variable + i, + v, + // Target + [ + 1~int, + 2~int, + 3~int + ]~list(int), + // Accumulator + @result, + // Init + []~list(int), + // LoopCondition + true~bool, + // LoopStep + _?_:_( + _==_( + _%_( + i~int^i, + 2~int + )~int^modulo_int64, + 0~int + )~bool^equals, + _+_( + @result~list(int)^@result, + [ + _+_( + _*_( + i~int^i, + v~int^v + )~int^multiply_int64, + v~int^v + )~int^add_int64 + ]~list(int) + )~list(int)^add_list, + @result~list(int)^@result + )~list(int)^conditional, + // Result + @result~list(int)^@result)~list(int), + [ + 1~int, + 9~int + ]~list(int) + )~bool^equals + )~bool^logical_and, + _==_( + __comprehension__( + // Variable + i, + v, + // Target + [ + 1~int, + 2~int, + 3~int + ]~list(int), + // Accumulator + @result, + // Init + []~list(int), + // LoopCondition + true~bool, + // LoopStep + _+_( + @result~list(int)^@result, + [ + _+_( + _*_( + i~int^i, + v~int^v + )~int^multiply_int64, + v~int^v + )~int^add_int64 + ]~list(int) + )~list(int)^add_list, + // Result + @result~list(int)^@result)~list(int), + [ + 1~int, + 4~int, + 9~int + ]~list(int) + )~bool^equals +)~bool^logical_and \ No newline at end of file diff --git a/checker/src/test/resources/types.baseline b/checker/src/test/resources/types.baseline new file mode 100644 index 000000000..939e0ed97 --- /dev/null +++ b/checker/src/test/resources/types.baseline @@ -0,0 +1,48 @@ +Source: list == type([1]) && map == type({1:2u}) +=====> +_&&_( + _==_( + list~type(list(dyn))^list, + type( + [ + 1~int + ]~list(int) + )~type(list(int))^type + )~bool^equals, + _==_( + map~type(map(dyn, dyn))^map, + type( + { + 1~int:2u~uint + }~map(int, uint) + )~type(map(int, uint))^type + )~bool^equals +)~bool^logical_and + +Source: {}.map(c,[c,type(c)]) +=====> +__comprehension__( + // Variable + c, + // Target + {}~map(dyn, dyn), + // Accumulator + @result, + // Init + []~list(list(dyn)), + // LoopCondition + true~bool, + // LoopStep + _+_( + @result~list(list(dyn))^@result, + [ + [ + c~dyn^c, + type( + c~dyn^c + )~type(dyn)^type + ]~list(dyn) + ]~list(list(dyn)) + )~list(list(dyn))^add_list, + // Result + @result~list(list(dyn))^@result)~list(list(dyn)) \ No newline at end of file diff --git a/checker/src/test/resources/unexpectedAggregateMapError.baseline b/checker/src/test/resources/unexpectedAggregateMapError.baseline new file mode 100644 index 000000000..92add2df6 --- /dev/null +++ b/checker/src/test/resources/unexpectedAggregateMapError.baseline @@ -0,0 +1,5 @@ +Source: {1:2u, 2:3u} +=====> +ERROR: test_location:1:1: expected type 'map(int, bool)' but found 'map(int, uint)' + | {1:2u, 2:3u} + | ^ diff --git a/checker/src/test/resources/userFunction.baseline b/checker/src/test/resources/userFunction.baseline new file mode 100644 index 000000000..e8742754a --- /dev/null +++ b/checker/src/test/resources/userFunction.baseline @@ -0,0 +1,21 @@ +Source: myfun(1, true, 3u) + 1.myfun(false, 3u).myfun(true, 42u) +declare myfun { + function myfun_instance int.(bool, uint) -> int + function myfun_static (int, bool, uint) -> int +} +=====> +_+_( + myfun( + 1~int, + true~bool, + 3u~uint + )~int^myfun_static, + 1~int.myfun( + false~bool, + 3u~uint + )~int^myfun_instance.myfun( + true~bool, + 42u~uint + )~int^myfun_instance +)~int^add_int64 + diff --git a/checker/src/test/resources/userFunctionAddsMacroError.baseline b/checker/src/test/resources/userFunctionAddsMacroError.baseline new file mode 100644 index 000000000..75e1c5e65 --- /dev/null +++ b/checker/src/test/resources/userFunctionAddsMacroError.baseline @@ -0,0 +1,8 @@ +Source: false +declare has { + function has_id (dyn) -> dyn +} +=====> +ERROR: test_location:1:1: overload for name 'has' with 1 argument(s) overlaps with predefined macro + | false + | ^ diff --git a/checker/src/test/resources/userFunctionAddsOverload.baseline b/checker/src/test/resources/userFunctionAddsOverload.baseline new file mode 100644 index 000000000..515afa9eb --- /dev/null +++ b/checker/src/test/resources/userFunctionAddsOverload.baseline @@ -0,0 +1,15 @@ +Source: size(x) > 4 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare size { + function size_message (cel.expr.conformance.proto3.TestAllTypes) -> int +} +=====> +_>_( + size( + x~cel.expr.conformance.proto3.TestAllTypes^x + )~int^size_message, + 4~int +)~bool^greater_int64 + diff --git a/checker/src/test/resources/userFunctionMultipleOverloadsWithSanitization.baseline b/checker/src/test/resources/userFunctionMultipleOverloadsWithSanitization.baseline new file mode 100644 index 000000000..9c5abe132 --- /dev/null +++ b/checker/src/test/resources/userFunctionMultipleOverloadsWithSanitization.baseline @@ -0,0 +1,18 @@ +Source: myfun(1) + myfun(s) +declare s { + value google.protobuf.Struct +} +declare myfun { + function myfun_int (int) -> int + function myfun_struct (google.protobuf.Struct) -> int +} +=====> +_+_( + myfun( + 1~int + )~int^myfun_int, + myfun( + s~map(string, dyn)^s + )~int^myfun_struct +)~int^add_int64 + diff --git a/checker/src/test/resources/userFunctionOverlappingOverloadsError.baseline b/checker/src/test/resources/userFunctionOverlappingOverloadsError.baseline new file mode 100644 index 000000000..436dda450 --- /dev/null +++ b/checker/src/test/resources/userFunctionOverlappingOverloadsError.baseline @@ -0,0 +1,9 @@ +Source: func(1) +declare func { + function overlapping_overload_1 int.() -> int + function overlapping_overload_2 int.() -> int +} +=====> +ERROR: test_location:1:1: overlapping overload for name 'func' (type '(int) -> int' cannot be distinguished from '(int) -> int') + | func(1) + | ^ diff --git a/checker/src/test/resources/userFunctionOverlaps.baseline b/checker/src/test/resources/userFunctionOverlaps.baseline new file mode 100644 index 000000000..059ba94b3 --- /dev/null +++ b/checker/src/test/resources/userFunctionOverlaps.baseline @@ -0,0 +1,14 @@ +Source: size(x) == 1u +declare x { + value list(int) +} +declare size { + function my_size (list(TEST)) -> uint +} +=====> +_==_( + size( + x~list(int)^x + )~uint^my_size, + 1u~uint +)~bool^equals \ No newline at end of file diff --git a/checker/src/test/resources/wrapper.baseline b/checker/src/test/resources/wrapper.baseline new file mode 100644 index 000000000..3b3b82375 --- /dev/null +++ b/checker/src/test/resources/wrapper.baseline @@ -0,0 +1,13 @@ +Source: x.single_int64_wrapper + 1 != 23 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +_!=_( + _+_( + x~cel.expr.conformance.proto3.TestAllTypes^x.single_int64_wrapper~wrapper(int), + 1~int + )~int^add_int64, + 23~int +)~bool^not_equals + diff --git a/codelab/BUILD.bazel b/codelab/BUILD.bazel new file mode 100644 index 000000000..95bb127b6 --- /dev/null +++ b/codelab/BUILD.bazel @@ -0,0 +1,16 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//codelab:__subpackages__"], +) + +java_library( + name = "codelab", + exports = ["//codelab/src/main/codelab"], +) + +java_library( + name = "solutions", + exports = ["//codelab/src/main/codelab/solutions"], +) diff --git a/codelab/README.md b/codelab/README.md new file mode 100644 index 000000000..83257d186 --- /dev/null +++ b/codelab/README.md @@ -0,0 +1,1684 @@ +# CEL-Java Codelab + +In this codelab developers would learn some key concepts, how to set up, use variables, customize and build CEL for Java. + +## What is CEL? + +Common Expression Language (CEL) is an expression language that’s fast, portable, and safe to execute in performance-critical applications. CEL is designed to be embedded in an application, with application-specific extensions, and is ideal for extending declarative configurations that your applications might already use. + +## What is covered in this Codelab? + +In this codelab, we’ll walk through some coding Exercises that cover common use cases. This codelab is aimed at developers who would like to learn CEL to use services that already support CEL. This codelab doesn't cover how to integrate CEL into your own project. For a more in-depth look at the language, semantics, and features see the [CEL Language Definition on GitHub](https://github.com/google/cel-spec). + +Some key areas covered are: + +* [Hello, World: Using CEL to evaluate a String](#hello-world) +* [Creating variables](#creating-variables) +* [Commutatibe logical AND/OR](#logical-andor) +* [Adding custom functions](#custom-functions) +* [Building JSON](#building-json) +* [Building Protos](#building-protos) +* [Macros](#macros) +* [Static AST Validators and Optimizers](#static-ast-validators-and-optimizers) +* [Custom AST Validation](#custom-ast-validation) + +### Prerequisites +This codelab builds upon a basic understanding of Protocol Buffers and Java. + +If you're not familiar with Protocol Buffers, the first exercise will give you a sense of how CEL works, but because the more advanced examples use Protocol Buffers as the input into CEL, they may be harder to understand. Consider working through one of these [tutorials](https://developers.google.com/protocol-buffers/docs/tutorials?authuser=0), first. + +Note that Protocol Buffers are not required to use CEL, but they are used extensively in this codelab. + +What you'll need: + +- JDK 8 or higher +- Bazel + +You can test that java and bazel is installed by running: + +``` +java --version +bazel +``` + +## GitHub Setup + +GitHub Repo: + +The code for this codelab lives in the `codelab` folder of the cel-java repo. The solution is available in the `codelab/solution` folder of the same repo. + +Clone and cd into the repo: + +``` +git clone git@github.com:cel-expr/cel-java.git +cd cel-java +``` + +Run the following: +``` +bazel test //codelab/src/test/codelab:Exercise1Test --test_output=errors +``` + +You should see five failing tests in the output: + +``` +There were 5 failures: + +… (omitted) + +FAILURES!!! +Tests run: 5, Failures: 5 +``` + +## Where are CEL-Java Codelab Code in GitHub + +Each exercise is laid out as `ExerciseN.java` and is accompanied by failing tests. Throughout this codelab, we will modify the main exercise code to make these tests pass. + +- Codelab code: https://github.com/cel-expr/cel-java/tree/main/codelab/src/main/codelab +- Test code for the main codelab: https://github.com/cel-expr/cel-java/tree/main/codelab/src/test/codelab +- Codelab solution code: https://github.com/cel-expr/cel-java/tree/main/codelab/src/main/codelab/solutions +- Test code for the solution: https://github.com/cel-expr/cel-java/tree/main/codelab/src/test/codelab/solutions + +We will also be using `google.rpc.context.AttributeContext` in [attribute_context.proto](https://github.com/googleapis/googleapis/blob/master/google/rpc/context/attribute_context.proto) to help with defining inputs for exercises. + +## Hello, World + +In the tried and true tradition of all programming languages, let's start with "Hello, World!". + +Open `Exercise1.java`. You should see two stub methods: + +```java +final class Exercise1 { + /** + * Compile the input {@code expression} and produce an AST. This method parses and type-checks the + * given expression to validate the syntax and type-agreement of the expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + @SuppressWarnings("DoNotCallSuggester") + CelAbstractSyntaxTree compile(String expression) { + throw new UnsupportedOperationException("To be implemented"); + } + + /** + * Evaluates the compiled AST. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ + @SuppressWarnings("DoNotCallSuggester") + Object eval(CelAbstractSyntaxTree ast) { + throw new UnsupportedOperationException("To be implemented"); + } +} +``` + +### Setup the Environment + +CEL applications evaluate an expression against an Environment. + +The standard CEL environment supports all of the types, operators, functions, and macros defined within the language spec. The environment can be customized by providing options to disable macros, declare custom variables and functions, etc. +Java compilation and evaluation environments are constructed by their factories. + +```java +// Setup an environment for expression compilation and evaluation. + +// Breaking behavior changes and optional features are controlled by CelOptions +private static final CelOptions CEL_OPTIONS = CelOptions.current().build(); + +// CelCompiler is used to parse and type-check expressions. +// Note, it is preferable to statically initialize the compiler when it is +// statically configured. +// All CelCompiler instances are immutable and thus trivially thread-safe and +// thus amenable to caching. +private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CEL_OPTIONS) + .build(); + +// CelRuntime takes in a compiled expression and produces an evaluable instance. +// CelRuntime can also be initialized statically and cached just like the +// compiler. +private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setOptions(CEL_OPTIONS) + .build(); +``` + +Both `CelCompilerBuilder` and `CelRuntimeBuilder` allow customization through their fluent APIs. + +### Parse and Check the Expression + +Once the environment has been configured, expressions can be parsed and checked. + +Copy the following into compile method: + +```java +CelAbstractSyntaxTree compile(String expression) { + // Construct a CelCompiler instance. + // CelCompiler is immutable and when statically configured can be moved to a static final + // member. + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + + CelAbstractSyntaxTree ast; + try { + // Parse the expression + ast = celCompiler.parse(expression).getAst(); + } catch (CelValidationException e) { + // Report syntactic errors, if present + throw new IllegalArgumentException( + "Failed to parse expression. Reason: " + e.getMessage(), e); + } + + return ast; +} +``` + +When the expression is syntactically valid, the result of parse call is an executable **CelAbstractSyntaxTree**. Any issues from a malformed expression are raised as an exception of type **CelValidationException**. + +You can type-check the parsed AST by calling check. Append the following at the end of the compile method: + +```java +try { + // Type-check the expression for correctness + ast = celCompiler.check(ast).getAst(); +} catch (CelValidationException e) { + // Report semantic errors, if present. + throw new IllegalArgumentException( + "Failed to type-check expression. Reason: " + e.getMessage(), e); +} +return ast; +``` + +Type-checking issues are also raised via **CelValidationException** similar to the parse call. **e.getMessage()** contains a debug string that renders syntactic and semantic error messages in a human-readable format. + +In this exercise, we expect the evaluated expression to always produce a string output. We can leverage the type-checker to validate this. + +Append `setResultType` method to the CelCompiler declaration: + +```java +// Construct a CelCompiler instance. +// CelCompiler is immutable and when statically configured can be moved to a static final +// member. +// "String" is the expected output type for the type-checked expression +CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setResultType(SimpleType.STRING) + .build(); +``` + +Run the unit tests again. You should now see all compile tests pass: + +``` +bazel test --test_output=errors //codelab/src/test/codelab:Exercise1Test +``` + +CelCompiler offers a `Compile` method where parse and check phases are consolidated. This will be used throughout the remainder of the exercises. + +### Evaluate + +After the expressions have been parsed and checked into an AST representation, it can be converted into an evaluable program whose function bindings and evaluation modes can be customized depending on the stack you are using. + +Once a CEL expression is planned, it can be evaluated against an evaluation context (an activation). The evaluation result will be either a value or an error state. + +Copy the following into eval method: + +```java +/** + * Evaluates the compiled AST. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ +Object eval(CelAbstractSyntaxTree ast) { + // Construct a CelRuntime instance + // CelRuntime is immutable just like the compiler and can be moved to a static final member. + CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + + try { + // Plan the program + CelRuntime.Program program = celRuntime.createProgram(ast); + + // Evaluate the program without any additional arguments. + return program.eval(); + } catch (CelEvaluationException e) { + // Report any evaluation errors, if present + throw new IllegalArgumentException( + "Evaluation error has occurred. Reason: " + e.getMessage(), e); + } +} +``` + +**CelRuntime.Program** represents the planned expression and the method eval evaluates it against the input. Any evaluation errors are raised as an exception of type **CelEvaluationException**. + +Run the unit tests again and everything should pass now. + +## Creating variables + +Most CEL applications will declare variables that can be referenced within expressions. Variables declarations specify a name and a type. A variable's type may either be a CEL builtin type, a protocol buffer well-known type, or any protobuf message type so long as its descriptor is also provided to CEL. + +At runtime, the hosting program binds instances of variables to the evaluation context (using the variable name as a key). + +Suppose you would like to test whether a user provided value is negative. We can write a simple expression for this: value < 0, where value is the variable to be declared. + +Take a look at the evaluate_negativeExpression method in `Exercise2Test.java`: + +```java +@Test +@TestParameters("{value: 5, expectedResult: false}") +@TestParameters("{value: -5, expectedResult: true}") +public void evaluate_negativeExpression(long value, boolean expectedResult) { + CelAbstractSyntaxTree ast = exercise2.compile("value < 0", "value", SimpleType.INT); + + Object evaluatedResult = exercise2.eval(ast, ImmutableMap.of("value", value)); + assertThat(evaluatedResult).isEqualTo(expectedResult); +} +``` + +Let's write the code needed to pass this test. Copy the following into Exercise2.java: + +```java +/** + * Compiles the input expression with provided variable information. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ +CelAbstractSyntaxTree compile(String expression, String variableName, CelType variableType) { + // Compile (parse + type-check) the expression + // CelCompiler is immutable and when statically configured can be moved to a static final + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar(variableName, variableType) + .setResultType(SimpleType.BOOL) + .build(); + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException( + "Failed to compile expression. Reason: " + e.getMessage(), e); + } +} +``` + +The compiler's `addVar` method allows us to declare variables. Note that you must supply the type of the variable being declared. Supported CEL types can be found [here](https://github.com/google/cel-java/tree/main/common/src/main/java/dev/cel/common/types). + +> [!TIP] +> Best practice: You may have noticed `addVar` has an overloaded method which accepts a proto based Type instead of the CEL-Java native CelType used in this example. While the two types are functionally equivalent, we recommend using the native types whenever possible. + +Let's make the evaluation work now. Copy into the eval method: + +```java +/** + * Evaluates the compiled AST with the user provided parameter values. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ +Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + + // Evaluate using the provided map as input variables (key: variableName, value: + // variableValue) + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + // Report any evaluation errors, if present + throw new IllegalArgumentException( + "Evaluation error has occurred. Reason: " + e.getMessage(), e); + } +} +``` + +Now run the unit tests. You should see evaluate_negativeExpressionTest pass: + +``` +bazel test --test_output=errors //codelab/src/test/codelab:Exercise2Test +``` + +You can also declare complex type variables such as a protocol buffer message. Suppose we would like to validate if an auth claim is set on a Request object. + +Take a look at the test case `evaluate_requestAuthorization` in `Exercise2Test.java`: + +```java +@Test +@TestParameters("{group: 'admin', expectedResult: true}") +@TestParameters("{group: 'users', expectedResult: false}") +public void evaluate_requestAuthorization(String group, boolean expectedResult) { + CelAbstractSyntaxTree ast = + exercise2.compile( + "request.auth.claims.group == 'admin'", + "request", + StructTypeReference.create("google.rpc.context.AttributeContext.Request")); + + AttributeContext.Auth auth = + AttributeContext.Auth.newBuilder() + .setPrincipal("user:me@acme.co") + .setClaims( + Struct.newBuilder() + .putFields("group", Value.newBuilder().setStringValue(group).build())) + .build(); + AttributeContext.Request request = AttributeContext.Request.newBuilder().setAuth(auth).build(); + + Object evaluatedResult = exercise2.eval(ast, ImmutableMap.of("request", request)); + assertThat(evaluatedResult).isEqualTo(expectedResult); +} +``` + +You'll notice that for the declared variable name request, we are creating a type reference for Protocol buffer message by providing its fully qualified name `google.rpc.context.AttributeContext.Request`. + +Run the unit test. You should see the following error: + +> Failed to compile expression. Reason: ERROR: :1:12: Message type resolution failure while referencing field 'auth'. Ensure that the descriptor for type 'google.rpc.context.AttributeContext.Request' was added to the environment | request.auth.claims.group == 'admin' + +To use variables that refer to protobuf messages, the type-checker needs to also know the type descriptor. The type descriptor is a protobuf message that describes the field declarations of a protobuf message. Descriptors can be thought of as a reflection type. Descriptors are used within the type-checker to determine the field type references. Descriptors can either be stored and saved, or read from a protobuf message instance. + +To add the needed descriptor, append `addMessageTypes` method to the `celCompiler` declaration: + +```java +CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar(variableName, variableType) + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .setResultType(SimpleType.BOOL) + .build(); +``` + +Run the unit tests again. All test cases should pass now. + +## Logical AND/OR + +One of CEL's more unique features is its use of commutative logical operators. Either side of a conditional branch can short-circuit the evaluation, even in the face of errors or partial input. + +We'll be fixing the tests to complete the expected truth table. + +Run the tests. You should see failures for Logical AND and Ternary: + +``` +bazel test --test_output=errors //codelab/src/test/codelab:Exercise3Test +``` + +Take a look at the evaluate_logicalOrShortCircuits_success test in `Exercise3Test.java`. + +```java +/** + * Demonstrates CEL's unique feature of commutative logical operators. + * + *

If a logical operation can short-circuit a branch that results in an error, CEL evaluation + * will return the logical result instead of propagating the error. + */ +@Test +@TestParameters("{expression: 'true || true', expectedResult: true}") +@TestParameters("{expression: 'true || false', expectedResult: true}") +@TestParameters("{expression: 'false || true', expectedResult: true}") +@TestParameters("{expression: 'false || false', expectedResult: false}") +@TestParameters("{expression: 'true || (1 / 0 > 2)', expectedResult: true}") +@TestParameters("{expression: '(1 / 0 > 2) || true', expectedResult: true}") +public void evaluate_logicalOrShortCircuits_success(String expression, boolean expectedResult) { + Object evaluatedResult = exercise3.compileAndEvaluate(expression); + + assertThat(evaluatedResult).isEqualTo(expectedResult); +} +``` + +You'll note that despite the OR expression containing a branch where the evaluation results in an error, CEL still returns the expected result through short-circuiting. + +Conversely, an exception is surfaced when all branches of the logical operator resolves to an error: + +```java +/** Demonstrates a case where an error is surfaced to the user. */ +@Test +@TestParameters("{expression: 'false || (1 / 0 > 2)'}") +@TestParameters("{expression: '(1 / 0 > 2) || false'}") +public void evaluate_logicalOrFailure_throwsException(String expression) { + IllegalArgumentException exception = + assertThrows( + IllegalArgumentException.class, () -> exercise3.compileAndEvaluate(expression)); + + assertThat(exception).hasMessageThat().contains("Evaluation error has occurred."); + assertThat(exception).hasCauseThat().isInstanceOf(CelEvaluationException.class); + assertThat(exception).hasCauseThat().hasMessageThat().contains("evaluation error: / by zero"); +} +``` + +Using this knowledge, try to complete the truth table by filling in the expressions in @TestParameters for logicalAnd and ternary tests. + +CEL finds an evaluation order which gives results whenever possible, ignoring errors or even missing data that might occur in other evaluation orders. Applications like IAM conditions rely on this property to minimize the cost of evaluation, deferring the gathering of expensive inputs when a result can be reached without them. + +## Custom Functions + +While there are many builtin functions, there are occasions where a custom function is useful: + +- Improve the user experience for common conditions +- Expose context-sensitive state + +In this exercise, we'll be exploring how to expose a function to package together commonly used checks. We'll introduce a '.contains' function for checking if a map has a key set and is set to a particular value, allowing for expressions like: `map.contains(key, value)`. This provides a generalization of this common pattern using built-ins for string maps: `has(map.key) && map.key == value`. + +Take a look at the expression that has .contains function in `Exercise4Test.java`: + +```java +@Test +@TestParameters("{group: 'admin', expectedResult: true}") +@TestParameters("{group: 'users', expectedResult: false}") +public void evaluate_requestContainsGroup_success(String group, boolean expectedResult) { + CelAbstractSyntaxTree ast = exercise4.compile("request.auth.claims.contains('group', 'admin')"); + AttributeContext.Auth auth = + AttributeContext.Auth.newBuilder() + .setPrincipal("user:me@acme.co") + .setClaims( + Struct.newBuilder() + .putFields("group", Value.newBuilder().setStringValue(group).build())) + .build(); + AttributeContext.Request request = AttributeContext.Request.newBuilder().setAuth(auth).build(); + + Object evaluatedResult = exercise4.eval(ast, ImmutableMap.of("request", request)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); +} +``` + +We will build upon the provided compile and eval method implementations in Exercise4.java to make this work: + +```java +final class Exercise4 { + +/** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ +CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("request", StructTypeReference.create(Request.getDescriptor().getFullName())) + .addMessageTypes(Request.getDescriptor()) + .setResultType(SimpleType.BOOL) + // Provide the custom `contains` function declaration here. + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } +} + +/** + * Evaluates the compiled AST with the user provided parameter values. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ +Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + // Provide the custom `contains` function implementation here. + .build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } +} +``` + +Run the test: + +``` +bazel test --test_output=errors //codelab/src/test/codelab:Exercise4Test +``` + +You should see the following error: + +> ERROR: :1:29: found no matching overload for 'contains' applied to 'map(string, dyn).(string, string)' +> | request.auth.claims.contains('group', 'admin') +> | ............................^ + +To fix the error, the contains function will need to be added to the list of declarations which currently declares the request variable. Declaring a function is not much different than declaring a variable. A function must indicate its common name and enumerate a set of overloads with unique signatures. + +The following snippet shows how to declare a parameterized type. This is the most complicated any function overload ever be for CEL: + +```java +/** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ +CelAbstractSyntaxTree compile(String expression) { + // Useful components of the type-signature for 'contains'. + TypeParamType typeParamA = TypeParamType.create("A"); + TypeParamType typeParamB = TypeParamType.create("B"); + MapType mapTypeAB = MapType.create(typeParamA, typeParamB); + + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("request", StructTypeReference.create(Request.getDescriptor().getFullName())) + .addMessageTypes(Request.getDescriptor()) + .setResultType(SimpleType.BOOL) + .addFunctionDeclarations( + newFunctionDeclaration( + "contains", + newMemberOverload( + "map_contains_key_value", + SimpleType.BOOL, + ImmutableList.of(mapTypeAB, typeParamA, typeParamB)))) + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } +} +``` + +Re-run the exercise. Compilation should now succeed and you should see a new error about the missing runtime function: + +> evaluation error at :28: [internal] Unknown overload id 'map_contains_key_value' for function 'contains' + +To fix this, we need to provide the CEL environment with a function implementation for `contains`. + +Provide the function implementation to the runtime using the .addFunctionBindings builder method: + +```java +/** + * Evaluates the compiled AST with the user provided parameter values. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ +Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addFunctionBindings( + CelFunctionBinding.from( + "map_contains_key_value", + ImmutableList.of(Map.class, String.class, Object.class), + Exercise4::mapContainsKeyValue)) + .build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } +} +``` + +A function binding requires an Overload implementation to be provided (the "actual Java code" to be executed). The method reference `Exercise4::mapContainskeyValue` is that implementation: + +```java +/** + * mapContainsKeyValue implements the custom function: map.contains(key, value) -> bool. + * + * @param args, where: + *

    + *
  1. args[0] is the map + *
  2. args[1] is the key + *
  3. args[2] is the value at the key + *
+ * + * @return true If the key was found AND the value at the key equals to the value being checked + */ +@SuppressWarnings("unchecked") // Type-checker guarantees casting safety. +private static boolean mapContainsKeyValue(Object[] args) { + // The declaration of the function ensures that only arguments which match + // the mapContainsKey signature will be provided to the function. + Map map = (Map) args[0]; + String key = (String) args[1]; + Object value = args[2]; + + return map.containsKey(key) && map.containsValue(value); +} +``` + +> [!TIP] +> Best practice: Use `Unary` or `Binary` helper interfaces to improve compile-time correctness for any overload implementations with 2 arguments or fewer. + +> [!TIP] +> Best practice: Declare overload ids according to their types and function names. e.g. targetType_func_argType_argType. In the case where argType is a type param, use a descriptive name instead of the simple type name. + +## Building JSON + +CEL can also produce non-boolean outputs, such as JSON. + +Have a look at the test case in `Exercise5Test.java` first: + +```java +@Test +public void evaluate_jwtWithTimeVariable_producesJsonString() throws Exception { + // Note the quoted keys in the CEL map literal. For proto messages the field names are unquoted + // as they represent well-defined identifiers. + String jwt = + "{'sub': 'serviceAccount:delegate@acme.co'," + + "'aud': 'my-project'," + + "'iss': 'auth.acme.com:12350'," + + "'iat': time," + + "'nbf': time," + + "'exp': time + duration('300s')," + + "'extra_claims': {" + + "'group': 'admin'" + + "}}"; + CelAbstractSyntaxTree ast = exercise5.compile(jwt); + + // The output of the program is a map type. + @SuppressWarnings("unchecked") + Map evaluatedResult = + (Map) + exercise5.eval(ast, ImmutableMap.of("time", ProtoTimeUtils.fromSecondsToTimestamp(1698361778))); + String jsonOutput = exercise5.toJson(evaluatedResult); + + assertThat(jsonOutput) + .isEqualTo( + "{\"sub\":\"serviceAccount:delegate@acme.co\"," + + "\"aud\":\"my-project\"," + + "\"iss\":\"auth.acme.com:12350\"," + + "\"iat\":\"2023-10-26T23:09:38Z\"," + + "\"nbf\":\"2023-10-26T23:09:38Z\"," + + "\"exp\":\"2023-10-26T23:14:38Z\"," + + "\"extra_claims\":{\"group\":\"admin\"}}"); +} +``` + +Run the test: + +```sh +bazel test --test_output=errors //codelab/src/test/codelab:Exercise5Test +``` + +You should see the following error: + +``` +There was 1 failure: +1) evaluate_jwtWithTimeVariable_producesJsonString(codelab.Exercise5Test) +java.lang.IllegalArgumentException: Failed to compile expression. + at codelab.Exercise5.compile(Exercise5.java:49) + at codelab.Exercise5Test.evaluate_jwtWithTimeVariable_producesJsonString(Exercise5Test.java:46) + ... 26 trimmed +Caused by: dev.cel.common.CelValidationException: ERROR: :1:99: undeclared reference to 'time' (in container '') + | {'sub': 'serviceAccount:delegate@acme.co','aud': 'my-project','iss': 'auth.acme.com:12350','iat': time,'nbf': time,'exp': time + duration('300s'),'extra_claims': {'group': 'admin'}} + | ..................................................................................................^ + ... and more ... +``` + +In `Exercise5.java`, add a declaration for the `time` variable of type `SimpleType.TIMESTAMP`: + +```java +CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("time", SimpleType.TIMESTAMP) + .build(); +} +``` + +> [!NOTE] +> Timestamps and durations are well-known types and have special convenience +types within CEL. The `google.protobuf.Timestamp` and `google.protobuf.Duration` +message types are equivalent to the convenience types; however, the fields of +all well-known types are not directly accessible, but are instead mediated by +member functions. + +The expression will successfully compile then evaluate, but you will run into a different error: + +``` +There was 1 failure: +1) evaluate_jwtWithTimeVariable_producesJsonString(codelab.Exercise5Test) +java.lang.UnsupportedOperationException: To be implemented + at codelab.Exercise5.toJson(Exercise5.java:73) + at codelab.Exercise5Test.evaluate_jwtWithTimeVariable_producesJsonString(Exercise5Test.java:52) +``` + +The evaluated result is a native Java map type, and this needs to be explicitly +converted to JSON by leveraging `google.protobuf.Struct`. The internal CEL +representation is JSON convertible as it only refers to types that JSON can +support or for which there is a well-known [Proto to JSON mapping](https://protobuf.dev/programming-guides/proto3/#json). + +Copy and paste the following into `toJson` method: + +```java +/** Converts the evaluated result into a JSON string using protobuf's google.protobuf.Struct. */ +String toJson(Map map) throws InvalidProtocolBufferException { + // Convert the map into google.protobuf.Struct using the CEL provided helper function + Struct jsonStruct = CelProtoJsonAdapter.adaptToJsonStructValue(map); + // Then use Protobuf's JsonFormat to produce a JSON string output. + return JsonFormat.printer().omittingInsignificantWhitespace().print(jsonStruct); +} +``` +Re-running the test will show that it successfully passes. + +## Building Protos + +CEL can also build protobuf messages for any message type compiled into the application. + +Have a look at the test case in `Exercise6Test.java` first: + +```java +@Test +public void evaluate_constructAttributeContext() { + // Given JSON web token and the current time as input variables, + // Setup an expression to construct an AttributeContext protobuf object. + // + // Note: the field names within the proto message types are not quoted as they + // are well-defined names composed of valid identifier characters. Also, note + // that when building nested proto objects, the message name needs to prefix + // the object construction. + String expression = + "Request{\n" + + "auth: Auth{" + + " principal: jwt.iss + '/' + jwt.sub," + + " audiences: [jwt.aud]," + + " presenter: 'azp' in jwt ? jwt.azp : ''," + + " claims: jwt" + + "}," + + "time: now" + + "}"; + // Values for `now` and `jwt` variables to be passed into the runtime + Timestamp now = ProtoTimeUtils.now(); + ImmutableMap jwt = + ImmutableMap.of( + "sub", "serviceAccount:delegate@acme.co", + "aud", "my-project", + "iss", "auth.acme.com:12350", + "extra_claims", ImmutableMap.of("group", "admin")); + AttributeContext.Request expectedMessage = + AttributeContext.Request.newBuilder() + .setTime(now) + .setAuth( + AttributeContext.Auth.newBuilder() + .setPrincipal("auth.acme.com:12350/serviceAccount:delegate@acme.co") + .addAudiences("my-project") + .setClaims( + Struct.newBuilder() + .putAllFields( + ImmutableMap.of( + "sub", newStringValue("serviceAccount:delegate@acme.co"), + "aud", newStringValue("my-project"), + "iss", newStringValue("auth.acme.com:12350"))) + .putFields( + "extra_claims", + Value.newBuilder() + .setStructValue( + Struct.newBuilder() + .putFields("group", newStringValue("admin")) + .build()) + .build()))) + .build(); + + // Compile the `Request` message construction expression and validate that + // the resulting expression type matches the fully qualified message name. + CelAbstractSyntaxTree ast = exercise6.compile(expression); + AttributeContext.Request evaluatedResult = + (AttributeContext.Request) + exercise6.eval( + ast, + ImmutableMap.of( + "now", now, + "jwt", jwt)); + + assertThat(evaluatedResult).isEqualTo(expectedMessage); +} +``` + +Run the test: + +```sh +bazel test --test_output=errors //codelab/src/test/codelab:Exercise6Test +``` + +You should see the following error: + +``` +There was 1 failure: +1) evaluate_constructAttributeContext(codelab.Exercise6Test) +java.lang.IllegalArgumentException: Failed to compile expression. + at codelab.Exercise6.compile(Exercise6.java:42) + at codelab.Exercise6Test.evaluate_constructAttributeContext(Exercise6Test.java:72) + ... 26 trimmed +Caused by: dev.cel.common.CelValidationException: ERROR: :1:8: undeclared reference to 'Request' (in container '') + | Request{ + | .......^ +... and many more ... +``` + +The container is basically the equivalent of a namespace or package, but can +even be as granular as a protobuf message name. CEL containers use the same +namespace resolution rules as [Protobuf and C++][27] for determining where a +given variable, function, or type name is declared. + +Given the container `google.rpc.context.AttributeContext` the type-checker and +the evaluator will try the following identifier names for all variables, types, +and functions: + +* `google.rpc.context.AttributeContext.` +* `google.rpc.context.` +* `google.rpc.` +* `google.` +* `` + +For absolute names, prefix the variable, type, or function reference with a +leading dot `.`. In the example, the expression `.` will only search for the +top-level `` identifier without first checking within the container. + +Try specifying the `.setContainer("google.rpc.context.AttributeContext")` option +to the compiler environment then run the test again: + +```java +CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer("google.rpc.context.AttributeContext") + // Declare variables for "jwt" and "now" here + .addMessageTypes(Request.getDescriptor()) + .setResultType(StructTypeReference.create(Request.getDescriptor().getFullName())) + .build(); + ... +} +``` + +``` +There was 1 failure: +1) evaluate_constructAttributeContext(codelab.Exercise6Test) +... +Caused by: dev.cel.common.CelValidationException: ERROR: :2:25: undeclared reference to 'jwt' (in container 'google.rpc.context.AttributeContext') + | auth: Auth{ principal: jwt.iss + '/' + jwt.sub, audiences: [jwt.aud], presenter: 'azp' in jwt ? jwt.azp : '', claims: jwt},time: now} + | ........................^ +... and many more ... +``` + +We're making progress. Declare the `jwt` and `now` variables: + +```java +CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer("google.rpc.context.AttributeContext") + .addVar("jwt", SimpleType.DYN) + .addVar("now", SimpleType.TIMESTAMP) + .addMessageTypes(Request.getDescriptor()) + .setResultType(StructTypeReference.create(Request.getDescriptor().getFullName())) + .build(); + ... +} +``` + +The test should pass now. + +> [!NOTE] +> Additional considerations for using CEL to build protos: +> +> 1. There is no native support for the conditional assignment for `oneof` +> fields. +> 2. There are issues round-tripping to / from a `google.protobuf.Any`. +> +> When a `oneof` needs to be set, test whether the desired value is present before +> constructing the message, or extend CEL to include a custom object building +> function such as a [`wither`](https://crates.io/crates/withers_derive#the-wither-pattern) +> method, or perhaps something more abstract. +> +> When an `Any` contains a wrapper type such as `google.protobuf.IntValue`, CEL +> automatically unpacks the `Any` to `int` or `null_type` depending on the +> contents. In the case where the wrapper type is unset, the `null` could not be +> assigned to an `Any` field and have its same original meaning. So far, this is +> the only roundtripping issue we have discovered, but it's worth noting. + +## Macros + +Macros can be used to manipulate the CEL program at parse time. Macros match a +call signature and manipulate the input call and its arguments in order to +produce a new subexpression AST. + +Macros can be used to implement complex logic in the AST that can't be written +directly in CEL. For example, the `has` macro enables field presence testing. +The comprehension macros such as `exists` and `all` replace a function call with +bounded iteration over an input list or map. Neither concept is possible at a +syntactic level, but they are possible through macro expansions. + +Have a look at the test case in `Exercise7Test.java` first: + +```java +@Test +public void evaluate_checkJwtClaimsWithMacro_evaluatesToTrue() { + String expression = + "jwt.extra_claims.exists(c, c.startsWith('group'))" + + " && jwt.extra_claims" + + ".filter(c, c.startsWith('group'))" + + ".all(c, jwt.extra_claims[c]" + + ".all(g, g.endsWith('@acme.co')))"; + ImmutableMap jwt = + ImmutableMap.of( + "sub", + "serviceAccount:delegate@acme.co", + "aud", + "my-project", + "iss", + "auth.acme.com:12350", + "extra_claims", + ImmutableMap.of("group1", ImmutableList.of("admin@acme.co", "analyst@acme.co")), + "labels", + ImmutableList.of("metadata", "prod", "pii"), + "groupN", + ImmutableList.of("forever@acme.co")); + CelAbstractSyntaxTree ast = exercise7.compile(expression); + + // Evaluate a complex-ish JWT with two groups that satisfy the criteria. + // Output: true. + boolean evaluatedResult = (boolean) exercise7.eval(ast, ImmutableMap.of("jwt", jwt)); + + assertThat(evaluatedResult).isTrue(); +} +``` + +Run the test: + +```sh +bazel test --test_output=errors //codelab/src/test/codelab:Exercise7Test +``` + +You should see the following error: + +``` +There was 1 failure: +1) evaluate_checkJwtClaimsWithMacro_evaluatesToTrue(codelab.Exercise7Test) +java.lang.IllegalArgumentException: Failed to compile expression. + at codelab.Exercise7.compile(Exercise7.java:40) + at codelab.Exercise7Test.evaluate_checkJwtClaimsWithMacro_evaluatesToTrue(Exercise7Test.java:52) + ... 26 trimmed +Caused by: dev.cel.common.CelValidationException: ERROR: :1:24: undeclared reference to 'exists' (in container '') + | jwt.extra_claims.exists(c, c.startsWith('group')) && jwt.extra_claims.filter(c, c.startsWith('group')).all(c, jwt.extra_claims[c].all(g, g.endsWith('@acme.co'))) + | .......................^ +... and many more ... +``` + +Specify the option `setStandardMacros` with `CelStandardMacro.ALL`, +`CelStandardMacro.FILTER`, and `CelStandardMacro.EXISTS` as arguments: + +```java +CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("jwt", SimpleType.DYN) + .setStandardMacros( + CelStandardMacro.ALL, CelStandardMacro.FILTER, CelStandardMacro.EXISTS) + .setResultType(SimpleType.BOOL) + .build(); + ... +} +``` + +Run the test again to confirm that it passes. + +These are the currently supported macros: + +| Macro | Signature | Description | +| ------------ | ------------------------- | --------------------------------- | +| `all` | `r.all(var, cond)` | Test if `cond` evaluates `true` for *all* `var` in range `r`. +| `exists` | `r.exists(var, cond)` | Test if `cond` evaluates `true` for *any* `var` in range `r`. +| `exists_one` | `r.exists_one(var, cond)` | Test if `cond` evaluates `true` for *only one* `var` in range `r`. +| `filter` | `r.filter(var, cond)` | For lists, create a new list where each element `var` in range `r` satisfies the condition `cond`. For maps, create a new list where each key `var` in range `r` satisfies the condition `cond`. +| `map` | `r.map(var, expr)` | Create a new list where each each `var` in range `r` is transformed by `expr`. +| | `r.map(var, cond, expr)` | Same as two-arg `map` but with a conditional `cond` filter before the value is transformed. +| `has` | `has(a.b)` | Presence test for `b` on value `a` \: For maps, json tests definition. For protos, tests non-default primitive value or a or a set message field. + +When the range `r` argument is a `map` type, the `var` will be the map key, and +for `list` type values the `var` will be the list element value. The `all`, +`exists`, `exists_one`, `filter`, and `map` macros perform an AST rewrite that +does for-each iteration which is bounded by the size of the input. + +The bounded comprehensions ensure that CEL programs won't be Turing-complete, +but they evaluate in super-linear time with respect to the input. Use these +macros sparingly or not at all. Heavy use of comprehensions usually a good +indicator that a custom function would provide a better user experience and +better performance. + +> [!TIP] +> Best practice: `CelStandardMacro.STANDARD_MACROS` enables all listed macros, but +it's safer to explicitly enable only the required ones for your use case. + +## Static AST Validators and Optimizers + +CEL can perform complex validations on a compiled AST beyond what the +type-checker is capable of. CEL can also enhance evaluation efficiency through +AST optimizations such as constant folding and common subexpression elimination. +We will explore the use of canonical CEL validators and optimizers available. + +> [!NOTE] +> Note: Both validation and optimization require a type-checked AST. + +> [!CAUTION] +> AST validation and optimization should not be done in latency critical +code paths, similar to parsing and type-checking. + +### Validators + +Inspect the first three test cases in `Exercise8Test.java`: + +```java +@Test +public void validate_invalidTimestampLiteral_returnsError() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("timestamp('bad')"); + + CelValidationResult validationResult = exercise8.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:11: timestamp validation failed. Reason: evaluation error: Text 'bad'" + + " could not be parsed at index 0\n" + + " | timestamp('bad')\n" + + " | ..........^"); +} + +@Test +public void validate_invalidDurationLiteral_returnsError() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("duration('bad')"); + + CelValidationResult validationResult = exercise8.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:10: duration validation failed. Reason: evaluation error: invalid" + + " duration format\n" + + " | duration('bad')\n" + + " | .........^"); +} + +@Test +public void validate_invalidRegexLiteral_returnsError() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("'text'.matches('**')"); + + CelValidationResult validationResult = exercise8.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:16: Regex validation failed. Reason: Dangling meta character '*' near" + + " index 0\n" + + "**\n" + + "^\n" + + " | 'text'.matches('**')\n" + + " | ...............^"); +} +``` + +Note that all three test cases contain an expression with invalid literals +that would fail if evaluated. + +Run the validator tests (note the `--test_filter` flag): + +```sh +bazel test --test_output=errors --test_filter=validate //codelab/src/test/codelab:Exercise8Test +``` + + +You should see 4 tests failing: + +``` +There were 4 failures: +1) validate_invalidTimestampLiteral_returnsError(codelab.Exercise8Test) +... and more +FAILURES!!! +Tests run: 4, Failures: 4 +``` + +Setting up a validator requires an instance of a compiler and a runtime. These +have been provided for you out of convenience in `Exercise8.java`: + +```java +private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("x", SimpleType.INT) + .addVar( + "request", StructTypeReference.create("google.rpc.context.AttributeContext.Request")) + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); +private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); +``` + +Copy and paste the following, below where the runtime is declared: + +```java +// Just like the compiler and runtime, the validator and optimizer can be statically +// initialized as their instances are immutable. +private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL_COMPILER, CEL_RUNTIME) + .build(); +``` + +Next, replace the implementation of `validate` method with the following code: + +```java +/** Validates a type-checked AST. */ +CelValidationResult validate(CelAbstractSyntaxTree checkedAst) { + return CEL_VALIDATOR.validate(checkedAst); +} +``` + +Re-run the tests. The tests no longer throws an exception, but they still fail +because we aren't actually validating anything at the moment: + +``` +1) validate_invalidTimestampLiteral_returnsError(codelab.Exercise8Test) +value of: hasError() +expected to be true + at codelab.Exercise8Test.validate_invalidTimestampLiteral_returnsError(Exercise8Test.java:28) +... and more +``` + +We now need to register the individual AST validators. Add the literal +validators for timestamp, duration and regular expressions through +`.addAstValidators` builder method: + +```java +private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL_COMPILER, CEL_RUNTIME) + .addAstValidators( + TimestampLiteralValidator.INSTANCE, + DurationLiteralValidator.INSTANCE, + RegexLiteralValidator.INSTANCE) + .build(); +``` + +Re-run the test. You should observe that the first three literal validation +tests pass. + +There is one more test remaining to be fixed: + +```java +@Test +public void validate_listHasMixedLiterals_throws() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("3 in [1, 2, '3']"); + + // Note that `CelValidationResult` is the same result class used for the compilation path. This + // means you could alternatively invoke `.getAst()` and handle `CelValidationException` as + // usual. + CelValidationResult validationResult = exercise8.validate(ast); + + CelValidationException e = assertThrows(CelValidationException.class, validationResult::getAst); + assertThat(e) + .hasMessageThat() + .contains( + "ERROR: :1:13: expected type 'int' but found 'string'\n" + + " | 3 in [1, 2, '3']\n" + + " | ............^"); +} +``` + +CEL offers a validator to catch literals with mixed types in lists or maps. +For example, `3 in [1, 2, "3"]` is a perfectly valid expression in CEL but +likely unintended as this would evaluate to false. + +Add `HomogeneousLiteralValidator.newInstance()` then rerun the tests to confirm +that all tests pass: + +```java +// Just like the compiler and runtime, the validator and optimizer can be statically +// initialized as their instances are immutable. +private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL_COMPILER, CEL_RUNTIME) + .addAstValidators( + TimestampLiteralValidator.INSTANCE, + DurationLiteralValidator.INSTANCE, + RegexLiteralValidator.INSTANCE, + HomogeneousLiteralValidator.newInstance()) + .build(); +``` + +### Optimizers + +Human authored expressions often contain redundancies that may cause suboptimal +evaluation. In such cases, optimization is highly beneficial if the ASTs will be +repeatedly evaluated. Conversely, there is little point in optimizing an AST if +it will be evaluated once. + +We first look at a classic compiler optimization known as constant folding. Have +a look at the relevant test: + +```java +@Test +public void optimize_constantFold_success() throws Exception { + CelUnparser celUnparser = CelUnparserFactory.newUnparser(); + CelAbstractSyntaxTree ast = exercise8.compile("(1 + 2 + 3 == x) && (x in [1, 2, x])"); + + CelAbstractSyntaxTree optimizedAst = exercise8.optimize(ast); + + assertThat(celUnparser.unparse(optimizedAst)).isEqualTo("6 == x"); +} +``` + +> [!NOTE] +> Note: Unparser can be used to convert an AST into its textual representation. +In this exercise, it's used to verify the result of an AST optimization. + +Constant folding will take all arithmetic expression containing only constant +values, computes the expression then replaces with the result. It will also +prune any branches of the expression that can be removed without affecting the +correctness (akin to dead-code elimination). + +Run the optimizer tests (note the `--test_filter` flag): + +```sh +bazel test --test_output=errors --test_filter=optimize //codelab/src/test/codelab:Exercise8Test +``` + +You should see 3 tests failing: + +``` +There were 3 failures: +1) optimize_commonSubexpressionElimination_success(codelab.Exercise8Test) +... and more +FAILURES!!! +Tests run: 3, Failures: 3 +``` + +Similar to how the validator was setup, the optimizer requires both the compiler +and runtime instances. Copy and paste the following into `Exercise8.java`: + +```java +private static final CelOptimizer CEL_OPTIMIZER = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL_COMPILER, CEL_RUNTIME) + .build(); +``` + +Then change the code in `optimize` method as: + +```java +/** + * Optimizes a type-checked AST. + * + * @throws CelOptimizationException If the optimization fails. + */ +CelAbstractSyntaxTree optimize(CelAbstractSyntaxTree checkedAst) throws CelOptimizationException { + return CEL_OPTIMIZER.optimize(checkedAst); +} +``` + +Next, register `ConstantFoldingOptimizer` via `.addAstOptimizers`: + +```java +private static final CelOptimizer CEL_OPTIMIZER = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL_COMPILER, CEL_RUNTIME) + .addAstOptimizers(ConstantFoldingOptimizer.getInstance()) + .build(); +``` + +Re-run the test. You should see 2 out of 3 tests passing now. + +Please note that optimization removes parsing metadata from the AST, as +modifications may cause it to deviate from the original expression. +Practically, this means the error message will no longer indicate the source +location as shown in the test below: + +```java +@Test +public void optimize_constantFold_evaluateError() throws Exception { + CelAbstractSyntaxTree ast = + exercise8.compile("request.headers.referer == 'https://' + 'cel.dev'"); + CelAbstractSyntaxTree optimizedAst = exercise8.optimize(ast); + ImmutableMap runtimeParameters = + ImmutableMap.of("request", AttributeContext.Request.getDefaultInstance()); + + CelEvaluationException e1 = + assertThrows(CelEvaluationException.class, () -> exercise8.eval(ast, runtimeParameters)); + CelEvaluationException e2 = + assertThrows( + CelEvaluationException.class, () -> exercise8.eval(optimizedAst, runtimeParameters)); + // Note that the errors below differ by their source position. + assertThat(e1) + .hasMessageThat() + .contains("evaluation error at :15: key 'referer' is not present in map."); + assertThat(e2) + .hasMessageThat() + .contains("evaluation error at :0: key 'referer' is not present in map."); +} +``` + +The second optimization technique to cover is Common Subexpression Elimination +(CSE). It will replace instances of identical expressions to a single variable +holding the computed value. + +Have a look at the following test and note the expression containing duplicate field +selections `request.auth.claims.group`: + +```java +@Test +public void optimize_commonSubexpressionElimination_success() throws Exception { + CelUnparser celUnparser = CelUnparserFactory.newUnparser(); + CelAbstractSyntaxTree ast = + exercise8.compile( + "request.auth.claims.group == 'admin' || request.auth.claims.group == 'user'"); + + CelAbstractSyntaxTree optimizedAst = exercise8.optimize(ast); + + assertThat(celUnparser.unparse(optimizedAst)) + .isEqualTo( + "cel.@block([request.auth.claims.group], @index0 == \"admin\" || @index0 == \"user\")"); +} +``` + +CSE will rewrite this expression using a specialized internal function +`cel.@block`. The first argument contain a list duplicate subexpressions +and the second argument is the rewritten result expression that is semantically +the same as the original expression. The subexpressions are lazily evaluated and +memoized when accessed by index (e.g: `@index0`). + +Make the following changes in `Exercise8.java`: + +```java +private static final CelOptimizer CEL_OPTIMIZER = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL_COMPILER, CEL_RUNTIME) + .addAstOptimizers( + ConstantFoldingOptimizer.getInstance(), + SubexpressionOptimizer.newInstance( + SubexpressionOptimizerOptions.newBuilder().enableCelBlock(true).build())) + .build(); +``` + +As seen here, the usage of `cel.block` must explicitly be enabled as it is +only supported in CEL-Java as of now. Disabling `cel.block` will instead rewrite +the AST using cascaded `cel.bind` macros. Prefer using the block format if +possible as it is a more efficient format for evaluation. + +> [!CAUTION] +> You MUST disable `cel.block` if you are targeting `cel-go` or `cel-cpp` for the runtime until its support has been added in those stacks. + +Re-run the tests to confirm that they pass. + +## Custom AST Validation + +As seen in the earlier exercise, CEL offers many built-in validators. There +are however situations where authoring a custom AST validator is beneficial to +improve user experience by providing context-specific feedback. + +We'll be writing a validator to ensure that `AttributeContext.Request` message +is well formatted. Have a look at the test case: + +```java +@Test +public void validate_invalidHttpMethod_returnsError() throws Exception { + String expression = + "google.rpc.context.AttributeContext.Request { \n" + + "scheme: 'http', " + + "method: 'GETTT', " // method is misspelled. + + "host: 'cel.dev' \n" + + "}"; + CelAbstractSyntaxTree ast = exercise9.compile(expression); + + CelValidationResult validationResult = exercise9.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :2:25: GETTT is not an allowed HTTP method.\n" + + " | scheme: 'http', method: 'GETTT', host: 'cel.dev' \n" + + " | ........................^"); + assertThrows(CelValidationException.class, validationResult::getAst); +} +``` + +Run the test: + +```sh +bazel test --test_output=errors //codelab/src/test/codelab:Exercise9Test +``` + +You should see all three tests failing: + +``` +There were 3 failures: +1) validate_invalidHttpMethod_returnsError(codelab.Exercise9Test) +... and more +FAILURES!!! +Tests run: 3, Failures: 3 +``` + +The first step in writing a custom AST validator is to have a class implement +the `CelAstValidator` interface. In `Exercise9.java`, make the +following changes: + +```java +static final class AttributeContextRequestValidator implements CelAstValidator { + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + // Implement validate method here + } +} +``` + +We need a way to fetch then inspect the expression nodes of interest. For this, +CEL provides fluent APIs to navigate a compiled AST via navigable expressions. +A `CelNavigableExpr` allows you to traverse through its descendants or parent +with ease. + +Let's write some logic to filter for expressions containing +`google.rpc.context.AttributeContext.Request` message name. Copy and paste the +following: + +```java +@Override +public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.STRUCT)) + .map(node -> node.expr().struct()) + .filter( + struct -> struct.messageName().equals("google.rpc.context.AttributeContext.Request")) +} +``` + +> [!TIP] +> Call `.toString()` on a `CelExpr` object to obtain a human-readable format +of the AST. + +Next, we'll iterate through the fields of the message to confirm that it has +the correct HTTP method. Otherwise, we'll add it as an error through +`IssuesFactory`. Copy and paste the rest of the code: + +```java +static final class AttributeContextRequestValidator implements CelAstValidator { + private static final ImmutableSet ALLOWED_HTTP_METHODS = + ImmutableSet.of("GET", "POST", "PUT", "DELETE"); + + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.STRUCT)) + .map(node -> node.expr().struct()) + .filter( + struct -> struct.messageName().equals("google.rpc.context.AttributeContext.Request")) + .forEach( + struct -> { + for (CelStruct.Entry entry : struct.entries()) { + String fieldKey = entry.fieldKey(); + if (fieldKey.equals("method")) { + String entryStringValue = getStringValue(entry.value()); + if (!ALLOWED_HTTP_METHODS.contains(entryStringValue)) { + issuesFactory.addError( + entry.value().id(), entryStringValue + " is not an allowed HTTP method."); + } + } + } + }); + } + + /** + * Reads the underlying string value from the expression. + * + * @throws UnsupportedOperationException if the expression is not a constant string value. + */ + private static String getStringValue(CelExpr celExpr) { + return celExpr.constant().stringValue(); + } +} +``` + +Register the custom validator via `.addAstValidators`: + +```java +private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL_COMPILER, CEL_RUNTIME) + .addAstValidators(new AttributeContextRequestValidator()) + .build(); +``` + +Run the test again and confirm that the first test case passes. + +Let's look at the next test: + +```java +@Test +public void validate_schemeIsHttp_returnsWarning() throws Exception { + String expression = + "google.rpc.context.AttributeContext.Request { \n" + + "scheme: 'http', " // https is preferred but not required. + + "method: 'GET', " + + "host: 'cel.dev' \n" + + "}"; + CelAbstractSyntaxTree ast = exercise9.compile(expression); + + CelValidationResult validationResult = exercise9.validate(ast); + + assertThat(validationResult.hasError()).isFalse(); + assertThat(validationResult.getIssueString()) + .isEqualTo( + "WARNING: :2:9: Prefer using https for safety.\n" + + " | scheme: 'http', method: 'GET', host: 'cel.dev' \n" + + " | ........^"); + // Because the validation result does not contain any errors, you can still evaluate it. + assertThat(exercise9.eval(validationResult.getAst())) + .isEqualTo( + AttributeContext.Request.newBuilder() + .setScheme("http") + .setMethod("GET") + .setHost("cel.dev") + .build()); +} +``` + +A validator does not necessarily have to produce a pass/fail outcome. It can +instead provide informational feedbacks or warnings. This is useful when an +expression has no correctness issue, but can be improved based on the +application context. Linting is a good example of this. + +Make the following changes to produce a warning when `https` is not used as the +scheme: + +```java +@Override +public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.STRUCT)) + .map(node -> node.expr().struct()) + .filter( + struct -> struct.messageName().equals("google.rpc.context.AttributeContext.Request")) + .forEach( + struct -> { + for (CelStruct.Entry entry : struct.entries()) { + String fieldKey = entry.fieldKey(); + if (fieldKey.equals("method")) { + String entryStringValue = getStringValue(entry.value()); + if (!ALLOWED_HTTP_METHODS.contains(entryStringValue)) { + issuesFactory.addError( + entry.value().id(), entryStringValue + " is not an allowed HTTP method."); + } + } else if (fieldKey.equals("scheme")) { + String entryStringValue = getStringValue(entry.value()); + if (!entryStringValue.equals("https")) { + issuesFactory.addWarning( + entry.value().id(), "Prefer using https for safety."); + } + } + } + }); +} +``` + +Re-run to confirm that the first two tests pass. + +Another common need is to restrict the use of an expensive function call in an +unsafe manner. Suppose we have a function that issues an RPC. We'll write a +validator to ensure that it can't be used within a macro to prevent repeated +invocations within an expression. + +Inspect the test case: + +```java +@Test +public void validate_isPrimeNumberWithinMacro_returnsError() throws Exception { + String expression = "[2,3,5].all(x, is_prime_number(x))"; + CelAbstractSyntaxTree ast = exercise9.compile(expression); + + CelValidationResult validationResult = exercise9.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:12: is_prime_number function cannot be used within CEL macros.\n" + + " | [2,3,5].all(x, is_prime_number(x))\n" + + " | ...........^"); +} +``` + +Then copy and paste the following into `ComprehensionSafetyValidator` in `Exercise9.java`: + +```java +/** Prevents nesting an expensive function call within a macro. */ +static final class ComprehensionSafetyValidator implements CelAstValidator { + private static final String EXPENSIVE_FUNCTION_NAME = "is_prime_number"; + + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.COMPREHENSION)) + .forEach( + comprehensionNode -> { + boolean isFunctionWithinMacro = + comprehensionNode + .descendants() + .anyMatch( + node -> + node.expr() + .callOrDefault() + .function() + .equals(EXPENSIVE_FUNCTION_NAME)); + if (isFunctionWithinMacro) { + issuesFactory.addError( + comprehensionNode.id(), + EXPENSIVE_FUNCTION_NAME + " function cannot be used within CEL macros."); + } + }); + } +} +``` + +> [!NOTE] +> This doesn't stop the expression author from simply chaining the calls together outside the macro (e.g: `is_prime_number(2) && is_prime_number(3) ...)`. One could easily introduce a validator to catch these cases too if desired. + +> [!TIP] +> Use `(kind)OrDefault` to consolidate checking for the expression kind and the retrieval of the underlying expression for brevity. `callOrDefault` here is an example. + +Finally, register the custom validator: + +```java +private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL_COMPILER, CEL_RUNTIME) + .addAstValidators( + new AttributeContextRequestValidator(), + new ComprehensionSafetyValidator()) + .build(); +``` + +Re-run the test to confirm that all tests pass. diff --git a/codelab/src/main/codelab/BUILD.bazel b/codelab/src/main/codelab/BUILD.bazel new file mode 100644 index 000000000..af900769c --- /dev/null +++ b/codelab/src/main/codelab/BUILD.bazel @@ -0,0 +1,44 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = ["//codelab:__pkg__"], +) + +java_library( + name = "codelab", + srcs = glob(["*.java"]), + deps = [ + "//bundle:cel", # unuseddeps: keep + "//common:cel_ast", + "//common:compiler_common", # unuseddeps: keep + "//common:proto_json_adapter", # unuseddeps: keep + "//common/ast", # unuseddeps: keep + "//common/navigation", # unuseddeps: keep + "//common/types", # unuseddeps: keep + "//common/types:type_providers", # unuseddeps: keep + "//compiler", # unuseddeps: keep + "//compiler:compiler_builder", # unuseddeps: keep + "//optimizer", # unuseddeps: keep + "//optimizer:optimization_exception", # unuseddeps: keep + "//optimizer:optimizer_builder", # unuseddeps: keep + "//optimizer/optimizers:common_subexpression_elimination", # unuseddeps: keep + "//optimizer/optimizers:constant_folding", # unuseddeps: keep + "//parser:macro", # unuseddeps: keep + "//runtime", # unuseddeps: keep + "//validator", # unuseddeps: keep + "//validator:ast_validator", # unuseddeps: keep + "//validator:validator_builder", # unuseddeps: keep + "//validator/validators:duration", # unuseddeps: keep + "//validator/validators:homogeneous_literal", # unuseddeps: keep + "//validator/validators:regex", # unuseddeps: keep + "//validator/validators:timestamp", # unuseddeps: keep + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", # unuseddeps: keep + "@maven//:com_google_guava_guava", # unuseddeps: keep + "@maven//:com_google_protobuf_protobuf_java", # unuseddeps: keep + "@maven//:com_google_protobuf_protobuf_java_util", # unuseddeps: keep + "@maven_android//:com_google_protobuf_protobuf_javalite", # unuseddeps: keep + ], +) diff --git a/codelab/src/main/codelab/Exercise1.java b/codelab/src/main/codelab/Exercise1.java new file mode 100644 index 000000000..dfa80fe51 --- /dev/null +++ b/codelab/src/main/codelab/Exercise1.java @@ -0,0 +1,46 @@ +// Copyright 2022 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 codelab; + +import dev.cel.common.CelAbstractSyntaxTree; + +/** + * Exercise1 evaluates a simple literal expression: "Hello, World!" + * + *

Compile, eval, profit! + */ +final class Exercise1 { + /** + * Compile the input {@code expression} and produce an AST. This method parses and type-checks the + * given expression to validate the syntax and type-agreement of the expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + @SuppressWarnings("DoNotCallSuggester") + CelAbstractSyntaxTree compile(String expression) { + throw new UnsupportedOperationException("To be implemented"); + } + + /** + * Evaluates the compiled AST. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ + @SuppressWarnings("DoNotCallSuggester") + Object eval(CelAbstractSyntaxTree ast) { + throw new UnsupportedOperationException("To be implemented"); + } +} diff --git a/codelab/src/main/codelab/Exercise2.java b/codelab/src/main/codelab/Exercise2.java new file mode 100644 index 000000000..2720e995e --- /dev/null +++ b/codelab/src/main/codelab/Exercise2.java @@ -0,0 +1,52 @@ +// Copyright 2022 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 codelab; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.types.CelType; +import java.util.Map; + +/** + * Exercise2 shows how to declare and use variables in expressions through two examples: + * + *

    + *
  • Given a user supplied integer value, test whether the value is negative + *
  • Given a request of type {@link com.google.rpc.context.AttributeContext.Request} determine + * whether a specific auth claim is set. + *
+ */ +final class Exercise2 { + + /** + * Compiles the input expression with provided variable information. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + @SuppressWarnings("DoNotCallSuggester") + CelAbstractSyntaxTree compile(String expression, String variableName, CelType variableType) { + throw new UnsupportedOperationException("To be implemented"); + } + + /** + * Evaluates the compiled AST with the user provided parameter values. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ + @SuppressWarnings("DoNotCallSuggester") + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + throw new UnsupportedOperationException("To be implemented"); + } +} diff --git a/codelab/src/main/codelab/Exercise3.java b/codelab/src/main/codelab/Exercise3.java new file mode 100644 index 000000000..77b57f339 --- /dev/null +++ b/codelab/src/main/codelab/Exercise3.java @@ -0,0 +1,53 @@ +// Copyright 2022 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 codelab; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; + +final class Exercise3 { + + private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder().setResultType(SimpleType.BOOL).build(); + private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder().build(); + + /** + * Compiles the given expression and evaluates it. + * + * @throws IllegalArgumentException If the expression fails to compile or evaluate + */ + Object compileAndEvaluate(String expression) { + CelAbstractSyntaxTree ast; + try { + ast = CEL_COMPILER.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + + try { + CelRuntime.Program program = CEL_RUNTIME.createProgram(ast); + return program.eval(); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } +} diff --git a/codelab/src/main/codelab/Exercise4.java b/codelab/src/main/codelab/Exercise4.java new file mode 100644 index 000000000..df4d3ab1c --- /dev/null +++ b/codelab/src/main/codelab/Exercise4.java @@ -0,0 +1,77 @@ +// Copyright 2022 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 codelab; + +import com.google.rpc.context.AttributeContext.Request; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise4 demonstrates how to extend CEL with custom functions. + * + *

Declare a "contains" member function on map types that return a boolean indicating whether the + * map contains the key-value pair. + */ +final class Exercise4 { + + /** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("request", StructTypeReference.create(Request.getDescriptor().getFullName())) + .addMessageTypes(Request.getDescriptor()) + .setResultType(SimpleType.BOOL) + // Provide the custom `contains` function declaration here. + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + } + + /** + * Evaluates the compiled AST with the user provided parameter values. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + // Provide the custom `contains` function implementation here. + .build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } +} diff --git a/codelab/src/main/codelab/Exercise5.java b/codelab/src/main/codelab/Exercise5.java new file mode 100644 index 000000000..eca2a5df7 --- /dev/null +++ b/codelab/src/main/codelab/Exercise5.java @@ -0,0 +1,73 @@ +// Copyright 2024 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 codelab; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise5 covers how to build complex objects as CEL literals. + * + *

Given the input variable "time", construct a JWT with an expiry of 5 minutes + */ +final class Exercise5 { + + /** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + // Declare the 'time' variable here as a Timestamp. + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + } + + /** + * Evaluates the compiled AST with the user provided parameter values. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } + + /** Converts the evaluated result into a JSON string using protobuf's google.protobuf.Struct. */ + @SuppressWarnings("DoNotCallSuggester") + String toJson(Map map) { + throw new UnsupportedOperationException("To be implemented"); + } +} diff --git a/codelab/src/main/codelab/Exercise6.java b/codelab/src/main/codelab/Exercise6.java new file mode 100644 index 000000000..9991fb566 --- /dev/null +++ b/codelab/src/main/codelab/Exercise6.java @@ -0,0 +1,73 @@ +// Copyright 2024 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 codelab; + +import com.google.rpc.context.AttributeContext.Request; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.StructTypeReference; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise6 describes how to build proto message types within CEL. + * + *

Given an input `jwt` and time `now` construct a `google.rpc.context.AttributeContext.Request` + * with the `time` and `auth` fields populated according to the + * google.rpc.context.AttributeContext.Request specification. + */ +final class Exercise6 { + + /** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + // Set the container here for "google.rpc.context.AttributeContext" + // Declare variables for "jwt" and "now" here + .addMessageTypes(Request.getDescriptor()) + .setResultType(StructTypeReference.create(Request.getDescriptor().getFullName())) + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + } + + /** Evaluates the compiled AST with the user provided parameter values. */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(Request.getDescriptor()) + .build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } +} diff --git a/codelab/src/main/codelab/Exercise7.java b/codelab/src/main/codelab/Exercise7.java new file mode 100644 index 000000000..ce2efd88e --- /dev/null +++ b/codelab/src/main/codelab/Exercise7.java @@ -0,0 +1,72 @@ +// Copyright 2024 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 codelab; + +import com.google.rpc.context.AttributeContext.Request; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise7 introduces macros for dealing with repeated fields and maps. + * + *

Determine whether the `jwt.extra_claims` has at least one key that starts with the `group` + * prefix, and ensure that all group-like keys have list values containing only strings that end + * with '@acme.co`. + */ +final class Exercise7 { + + /** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("jwt", SimpleType.DYN) + // Set the macros here for `all`, `filter` and `exists`. + .setResultType(SimpleType.BOOL) + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + } + + /** Evaluates the compiled AST with the user provided parameter values. */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(Request.getDescriptor()) + .build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } +} diff --git a/codelab/src/main/codelab/Exercise8.java b/codelab/src/main/codelab/Exercise8.java new file mode 100644 index 000000000..d38854687 --- /dev/null +++ b/codelab/src/main/codelab/Exercise8.java @@ -0,0 +1,76 @@ +// Copyright 2024 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 codelab; + +import com.google.rpc.context.AttributeContext; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise8 demonstrates how to leverage canonical CEL validators to perform advanced validations + * on an AST and CEL optimizers to improve evaluation efficiency. + */ +final class Exercise8 { + private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("x", SimpleType.INT) + .addVar( + "request", StructTypeReference.create("google.rpc.context.AttributeContext.Request")) + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); + private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); + + // Statically declare the validator and optimizer here. + + /** + * Compiles the input expression. + * + * @throws CelValidationException If the expression contains parsing or type-checking errors. + */ + CelAbstractSyntaxTree compile(String expression) throws CelValidationException { + return CEL_COMPILER.compile(expression).getAst(); + } + + /** Validates a type-checked AST. */ + @SuppressWarnings("DoNotCallSuggester") + CelValidationResult validate(CelAbstractSyntaxTree checkedAst) { + throw new UnsupportedOperationException("To be implemented"); + } + + /** Optimizes a type-checked AST. */ + @SuppressWarnings("DoNotCallSuggester") + CelAbstractSyntaxTree optimize(CelAbstractSyntaxTree checkedAst) { + throw new UnsupportedOperationException("To be implemented"); + } + + /** Evaluates the compiled AST with the user provided parameter values. */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) + throws CelEvaluationException { + CelRuntime.Program program = CEL_RUNTIME.createProgram(ast); + return program.eval(parameterValues); + } +} diff --git a/codelab/src/main/codelab/Exercise9.java b/codelab/src/main/codelab/Exercise9.java new file mode 100644 index 000000000..85705390c --- /dev/null +++ b/codelab/src/main/codelab/Exercise9.java @@ -0,0 +1,99 @@ +// Copyright 2024 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 codelab; + +import com.google.rpc.context.AttributeContext; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; + +/** + * Exercise9 demonstrates how to author a custom AST validator to perform domain specific + * validations. + * + *

Given a `google.rpc.context.AttributeContext.Request` message, validate that its fields follow + * the expected HTTP specification. + * + *

Given an expression containing an expensive function call, validate that it is not nested + * within a macro. + */ +final class Exercise9 { + private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.ALL) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "is_prime_number", + CelOverloadDecl.newGlobalOverload( + "is_prime_number_int", + "Invokes an expensive RPC call to check if the value is a prime number.", + SimpleType.BOOL, + SimpleType.INT))) + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); + private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); + private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL_COMPILER, CEL_RUNTIME) + // Add your custom AST validators here + .build(); + + /** + * Compiles the input expression. + * + * @throws CelValidationException If the expression contains parsing or type-checking errors. + */ + CelAbstractSyntaxTree compile(String expression) throws CelValidationException { + return CEL_COMPILER.compile(expression).getAst(); + } + + /** Validates a type-checked AST. */ + CelValidationResult validate(CelAbstractSyntaxTree checkedAst) { + return CEL_VALIDATOR.validate(checkedAst); + } + + /** Evaluates the compiled AST. */ + Object eval(CelAbstractSyntaxTree ast) throws CelEvaluationException { + return CEL_RUNTIME.createProgram(ast).eval(); + } + + /** + * Performs general validation on AttributeContext.Request message. The validator raises errors if + * the HTTP request is malformed and semantically invalid (e.g: contains disallowed HTTP methods). + * Warnings are presented if there's potential problems with the contents of the request (e.g: + * using "http" instead of "https" for scheme). + */ + static final class AttributeContextRequestValidator { + // Implement validate method here + } + + /** Prevents nesting an expensive function call within a macro. */ + static final class ComprehensionSafetyValidator { + // Implement validate method here + } +} diff --git a/codelab/src/main/codelab/solutions/BUILD.bazel b/codelab/src/main/codelab/solutions/BUILD.bazel new file mode 100644 index 000000000..eae465fa7 --- /dev/null +++ b/codelab/src/main/codelab/solutions/BUILD.bazel @@ -0,0 +1,46 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = ["//codelab:__pkg__"], +) + +java_library( + name = "solutions", + srcs = glob(["*.java"]), + deps = [ + "//bundle:cel", + "//common:cel_ast", + "//common:compiler_common", + "//common:container", + "//common:proto_json_adapter", + "//common/ast", + "//common/navigation", + "//common/types", + "//common/types:type_providers", + "//compiler", + "//compiler:compiler_builder", + "//optimizer", + "//optimizer:optimization_exception", + "//optimizer:optimizer_builder", + "//optimizer/optimizers:common_subexpression_elimination", + "//optimizer/optimizers:constant_folding", + "//parser:macro", + "//runtime", + "//runtime:function_binding", + "//validator", + "//validator:ast_validator", + "//validator:validator_builder", + "//validator/validators:duration", + "//validator/validators:homogeneous_literal", + "//validator/validators:regex", + "//validator/validators:timestamp", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_protobuf_protobuf_java_util", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) diff --git a/codelab/src/main/codelab/solutions/Exercise1.java b/codelab/src/main/codelab/solutions/Exercise1.java new file mode 100644 index 000000000..0807a1931 --- /dev/null +++ b/codelab/src/main/codelab/solutions/Exercise1.java @@ -0,0 +1,90 @@ +// Copyright 2022 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 codelab.solutions; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; + +/** + * Exercise1 evaluates a simple literal expression: "Hello, World!" + * + *

Compile, eval, profit! + */ +final class Exercise1 { + /** + * Compile the input {@code expression} and produce an AST. This method parses and type-checks the + * given expression to validate the syntax and type-agreement of the expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression) { + // Construct a CelCompiler instance. + // "String" is the expected output type for the type-checked expression + // CelCompiler is immutable and when statically configured can be moved to a static final + // member. + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder().setResultType(SimpleType.STRING).build(); + + CelAbstractSyntaxTree ast; + try { + // Parse the expression + ast = celCompiler.parse(expression).getAst(); + } catch (CelValidationException e) { + // Report syntactic errors, if present + throw new IllegalArgumentException( + "Failed to parse expression. Reason: " + e.getMessage(), e); + } + + try { + // Type-check the expression for correctness + ast = celCompiler.check(ast).getAst(); + } catch (CelValidationException e) { + // Report semantic errors, if present. + throw new IllegalArgumentException( + "Failed to type-check expression. Reason: " + e.getMessage(), e); + } + return ast; + } + + /** + * Evaluates the compiled AST. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ + Object eval(CelAbstractSyntaxTree ast) { + // Construct a CelRuntime instance + // CelRuntime is immutable just like the compiler and can be moved to a static final member. + CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + + try { + // Plan the program + CelRuntime.Program program = celRuntime.createProgram(ast); + + // Evaluate the program without any additional arguments. + return program.eval(); + } catch (CelEvaluationException e) { + // Report any evaluation errors, if present + throw new IllegalArgumentException( + "Evaluation error has occurred. Reason: " + e.getMessage(), e); + } + } +} diff --git a/codelab/src/main/codelab/solutions/Exercise2.java b/codelab/src/main/codelab/solutions/Exercise2.java new file mode 100644 index 000000000..5a1c1e8cc --- /dev/null +++ b/codelab/src/main/codelab/solutions/Exercise2.java @@ -0,0 +1,82 @@ +// Copyright 2022 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 codelab.solutions; + +import com.google.rpc.context.AttributeContext; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise2 shows how to declare and use variables in expressions through two examples: + * + *

    + *
  • Given a user supplied integer value, test whether the value is negative + *
  • Given a request of type {@link com.google.rpc.context.AttributeContext.Request} determine + * whether a specific auth claim is set. + *
+ */ +final class Exercise2 { + + /** + * Compiles the input expression with provided variable information. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression, String variableName, CelType variableType) { + // Compile (parse + type-check) the expression + // CelCompiler is immutable and when statically configured can be moved to a static final + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar(variableName, variableType) + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .setResultType(SimpleType.BOOL) + .build(); + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException( + "Failed to compile expression. Reason: " + e.getMessage(), e); + } + } + + /** + * Evaluates the compiled AST with the user provided parameter values. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + + // Evaluate using the provided map as input variables (key: variableName, value: + // variableValue) + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + // Report any evaluation errors, if present + throw new IllegalArgumentException( + "Evaluation error has occurred. Reason: " + e.getMessage(), e); + } + } +} diff --git a/codelab/src/main/codelab/solutions/Exercise3.java b/codelab/src/main/codelab/solutions/Exercise3.java new file mode 100644 index 000000000..590dfd0df --- /dev/null +++ b/codelab/src/main/codelab/solutions/Exercise3.java @@ -0,0 +1,53 @@ +// Copyright 2022 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 codelab.solutions; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; + +final class Exercise3 { + + private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder().setResultType(SimpleType.BOOL).build(); + private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder().build(); + + /** + * Compiles the given expression and evaluates it. + * + * @throws IllegalArgumentException If the expression fails to compile or evaluate + */ + Object compileAndEvaluate(String expression) { + CelAbstractSyntaxTree ast; + try { + ast = CEL_COMPILER.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + + try { + CelRuntime.Program program = CEL_RUNTIME.createProgram(ast); + return program.eval(); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } +} diff --git a/codelab/src/main/codelab/solutions/Exercise4.java b/codelab/src/main/codelab/solutions/Exercise4.java new file mode 100644 index 000000000..b3cc82a24 --- /dev/null +++ b/codelab/src/main/codelab/solutions/Exercise4.java @@ -0,0 +1,122 @@ +// Copyright 2022 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 codelab.solutions; + +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static dev.cel.common.CelOverloadDecl.newMemberOverload; + +import com.google.common.collect.ImmutableList; +import com.google.rpc.context.AttributeContext.Request; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.MapType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.types.TypeParamType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise4 demonstrates how to extend CEL with custom functions. + * + *

Declare a "contains" member function on map types that return a boolean indicating whether the + * map contains the key-value pair. + */ +final class Exercise4 { + + /** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression) { + // Useful components of the type-signature for 'contains'. + TypeParamType typeParamA = TypeParamType.create("A"); + TypeParamType typeParamB = TypeParamType.create("B"); + MapType mapTypeAB = MapType.create(typeParamA, typeParamB); + + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("request", StructTypeReference.create(Request.getDescriptor().getFullName())) + .addMessageTypes(Request.getDescriptor()) + .setResultType(SimpleType.BOOL) + .addFunctionDeclarations( + newFunctionDeclaration( + "contains", + newMemberOverload( + "map_contains_key_value", + SimpleType.BOOL, + ImmutableList.of(mapTypeAB, typeParamA, typeParamB)))) + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + } + + /** + * Evaluates the compiled AST with the user provided parameter values. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addFunctionBindings( + CelFunctionBinding.from( + "map_contains_key_value", + ImmutableList.of(Map.class, String.class, Object.class), + Exercise4::mapContainsKeyValue)) + .build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } + + /** + * mapContainsKeyValue implements the custom function: map.contains(key, value) -> bool. + * + * @param args, where: + *

    + *
  1. args[0] is the map + *
  2. args[1] is the key + *
  3. args[2] is the value at the key + *
+ * + * @return true If the key was found AND the value at the key equals to the value being checked + */ + @SuppressWarnings("unchecked") // Type-checker guarantees casting safety. + private static boolean mapContainsKeyValue(Object[] args) { + // The declaration of the function ensures that only arguments which match + // the mapContainsKey signature will be provided to the function. + Map map = (Map) args[0]; + String key = (String) args[1]; + Object value = args[2]; + + return map.containsKey(key) && map.containsValue(value); + } +} diff --git a/codelab/src/main/codelab/solutions/Exercise5.java b/codelab/src/main/codelab/solutions/Exercise5.java new file mode 100644 index 000000000..e948adfed --- /dev/null +++ b/codelab/src/main/codelab/solutions/Exercise5.java @@ -0,0 +1,80 @@ +// Copyright 2024 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 codelab.solutions; + +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.Struct; +import com.google.protobuf.util.JsonFormat; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelProtoJsonAdapter; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise5 covers how to build complex objects as CEL literals. + * + *

Given the input variable "time", construct a JWT with an expiry of 5 minutes + */ +final class Exercise5 { + + /** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("time", SimpleType.TIMESTAMP) + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + } + + /** + * Evaluates the compiled AST with the user provided parameter values. + * + * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate. + */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } + + /** Converts the evaluated result into a JSON string using protobuf's google.protobuf.Struct. */ + String toJson(Map map) throws InvalidProtocolBufferException { + // Convert the map into google.protobuf.Struct using the CEL provided helper function + Struct jsonStruct = CelProtoJsonAdapter.adaptToJsonStructValue(map); + // Then use Protobuf's JsonFormat to produce a JSON string output. + return JsonFormat.printer().omittingInsignificantWhitespace().print(jsonStruct); + } +} diff --git a/codelab/src/main/codelab/solutions/Exercise6.java b/codelab/src/main/codelab/solutions/Exercise6.java new file mode 100644 index 000000000..9b6c59949 --- /dev/null +++ b/codelab/src/main/codelab/solutions/Exercise6.java @@ -0,0 +1,76 @@ +// Copyright 2024 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 codelab.solutions; + +import com.google.rpc.context.AttributeContext.Request; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise6 describes how to build proto message types within CEL. + * + *

Given an input `jwt` and time `now` construct a `google.rpc.context.AttributeContext.Request` + * with the `time` and `auth` fields populated according to the + * google.rpc.context.AttributeContext.Request specification. + */ +final class Exercise6 { + + /** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer(CelContainer.ofName("google.rpc.context.AttributeContext")) + .addVar("jwt", SimpleType.DYN) + .addVar("now", SimpleType.TIMESTAMP) + .addMessageTypes(Request.getDescriptor()) + .setResultType(StructTypeReference.create(Request.getDescriptor().getFullName())) + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + } + + /** Evaluates the compiled AST with the user provided parameter values. */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(Request.getDescriptor()) + .build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } +} diff --git a/codelab/src/main/codelab/solutions/Exercise7.java b/codelab/src/main/codelab/solutions/Exercise7.java new file mode 100644 index 000000000..e5be29171 --- /dev/null +++ b/codelab/src/main/codelab/solutions/Exercise7.java @@ -0,0 +1,74 @@ +// Copyright 2024 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 codelab.solutions; + +import com.google.rpc.context.AttributeContext.Request; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.Map; + +/** + * Exercise7 introduces macros for dealing with repeated fields and maps. + * + *

Determine whether the `jwt.extra_claims` has at least one key that starts with the `group` + * prefix, and ensure that all group-like keys have list values containing only strings that end + * with '@acme.co`. + */ +final class Exercise7 { + + /** + * Compiles the input expression. + * + * @throws IllegalArgumentException If the expression is malformed due to syntactic or semantic + * errors. + */ + CelAbstractSyntaxTree compile(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("jwt", SimpleType.DYN) + .setStandardMacros( + CelStandardMacro.ALL, CelStandardMacro.FILTER, CelStandardMacro.EXISTS) + .setResultType(SimpleType.BOOL) + .build(); + + try { + return celCompiler.compile(expression).getAst(); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Failed to compile expression.", e); + } + } + + /** Evaluates the compiled AST with the user provided parameter values. */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) { + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(Request.getDescriptor()) + .build(); + + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + return program.eval(parameterValues); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException("Evaluation error has occurred.", e); + } + } +} diff --git a/codelab/src/main/codelab/solutions/Exercise8.java b/codelab/src/main/codelab/solutions/Exercise8.java new file mode 100644 index 000000000..161089354 --- /dev/null +++ b/codelab/src/main/codelab/solutions/Exercise8.java @@ -0,0 +1,106 @@ +// Copyright 2024 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 codelab.solutions; + +import com.google.rpc.context.AttributeContext; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.optimizer.CelOptimizationException; +import dev.cel.optimizer.CelOptimizer; +import dev.cel.optimizer.CelOptimizerFactory; +import dev.cel.optimizer.optimizers.ConstantFoldingOptimizer; +import dev.cel.optimizer.optimizers.SubexpressionOptimizer; +import dev.cel.optimizer.optimizers.SubexpressionOptimizer.SubexpressionOptimizerOptions; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; +import dev.cel.validator.validators.DurationLiteralValidator; +import dev.cel.validator.validators.HomogeneousLiteralValidator; +import dev.cel.validator.validators.RegexLiteralValidator; +import dev.cel.validator.validators.TimestampLiteralValidator; +import java.util.Map; + +/** + * Exercise8 demonstrates how to leverage canonical CEL validators to perform advanced validations + * on an AST and CEL optimizers to improve evaluation efficiency. + */ +final class Exercise8 { + private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("x", SimpleType.INT) + .addVar( + "request", StructTypeReference.create("google.rpc.context.AttributeContext.Request")) + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); + private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); + + // Just like the compiler and runtime, the validator and optimizer can be statically + // initialized as their instances are immutable. + private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL_COMPILER, CEL_RUNTIME) + .addAstValidators( + TimestampLiteralValidator.INSTANCE, + DurationLiteralValidator.INSTANCE, + RegexLiteralValidator.INSTANCE, + HomogeneousLiteralValidator.newInstance()) + .build(); + private static final CelOptimizer CEL_OPTIMIZER = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL_COMPILER, CEL_RUNTIME) + .addAstOptimizers( + ConstantFoldingOptimizer.getInstance(), + SubexpressionOptimizer.newInstance( + SubexpressionOptimizerOptions.newBuilder().enableCelBlock(true).build())) + .build(); + + /** + * Compiles the input expression. + * + * @throws CelValidationException If the expression contains parsing or type-checking errors. + */ + CelAbstractSyntaxTree compile(String expression) throws CelValidationException { + return CEL_COMPILER.compile(expression).getAst(); + } + + /** Validates a type-checked AST. */ + CelValidationResult validate(CelAbstractSyntaxTree checkedAst) { + return CEL_VALIDATOR.validate(checkedAst); + } + + /** + * Optimizes a type-checked AST. + * + * @throws CelOptimizationException If the optimization fails. + */ + CelAbstractSyntaxTree optimize(CelAbstractSyntaxTree checkedAst) throws CelOptimizationException { + return CEL_OPTIMIZER.optimize(checkedAst); + } + + /** Evaluates the compiled AST with the user provided parameter values. */ + Object eval(CelAbstractSyntaxTree ast, Map parameterValues) + throws CelEvaluationException { + CelRuntime.Program program = CEL_RUNTIME.createProgram(ast); + return program.eval(parameterValues); + } +} diff --git a/codelab/src/main/codelab/solutions/Exercise9.java b/codelab/src/main/codelab/solutions/Exercise9.java new file mode 100644 index 000000000..2b45c3539 --- /dev/null +++ b/codelab/src/main/codelab/solutions/Exercise9.java @@ -0,0 +1,173 @@ +// Copyright 2024 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 codelab.solutions; + +import com.google.common.collect.ImmutableSet; +import com.google.rpc.context.AttributeContext; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.validator.CelAstValidator; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; + +/** + * Exercise9 demonstrates how to author a custom AST validator to perform domain specific + * validations. + * + *

Given a `google.rpc.context.AttributeContext.Request` message, validate that its fields follow + * the expected HTTP specification. + * + *

Given an expression containing an expensive function call, validate that it is not nested + * within a macro. + */ +final class Exercise9 { + private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.ALL) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "is_prime_number", + CelOverloadDecl.newGlobalOverload( + "is_prime_number_int", + "Invokes an expensive RPC call to check if the value is a prime number.", + SimpleType.BOOL, + SimpleType.INT))) + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); + private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(AttributeContext.Request.getDescriptor()) + .build(); + private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL_COMPILER, CEL_RUNTIME) + .addAstValidators( + new AttributeContextRequestValidator(), // + new ComprehensionSafetyValidator()) + .build(); + + /** + * Compiles the input expression. + * + * @throws CelValidationException If the expression contains parsing or type-checking errors. + */ + CelAbstractSyntaxTree compile(String expression) throws CelValidationException { + return CEL_COMPILER.compile(expression).getAst(); + } + + /** Validates a type-checked AST. */ + CelValidationResult validate(CelAbstractSyntaxTree checkedAst) { + return CEL_VALIDATOR.validate(checkedAst); + } + + /** Evaluates the compiled AST. */ + Object eval(CelAbstractSyntaxTree ast) throws CelEvaluationException { + return CEL_RUNTIME.createProgram(ast).eval(); + } + + /** + * Performs general validation on AttributeContext.Request message. The validator raises errors if + * the HTTP request is malformed and semantically invalid (e.g: contains disallowed HTTP methods). + * Warnings are presented if there's potential problems with the contents of the request (e.g: + * using "http" instead of "https" for scheme). + */ + static final class AttributeContextRequestValidator implements CelAstValidator { + private static final ImmutableSet ALLOWED_HTTP_METHODS = + ImmutableSet.of("GET", "POST", "PUT", "DELETE"); + + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.STRUCT)) + .map(node -> node.expr().struct()) + .filter( + struct -> struct.messageName().equals("google.rpc.context.AttributeContext.Request")) + .forEach( + struct -> { + for (CelStruct.Entry entry : struct.entries()) { + String fieldKey = entry.fieldKey(); + if (fieldKey.equals("method")) { + String entryStringValue = getStringValue(entry.value()); + if (!ALLOWED_HTTP_METHODS.contains(entryStringValue)) { + issuesFactory.addError( + entry.value().id(), entryStringValue + " is not an allowed HTTP method."); + } + } else if (fieldKey.equals("scheme")) { + String entryStringValue = getStringValue(entry.value()); + if (!entryStringValue.equals("https")) { + issuesFactory.addWarning( + entry.value().id(), "Prefer using https for safety."); + } + } + } + }); + } + + /** + * Reads the underlying string value from the expression. + * + * @throws UnsupportedOperationException if the expression is not a constant string value. + */ + private static String getStringValue(CelExpr celExpr) { + return celExpr.constant().stringValue(); + } + } + + /** Prevents nesting an expensive function call within a macro. */ + static final class ComprehensionSafetyValidator implements CelAstValidator { + private static final String EXPENSIVE_FUNCTION_NAME = "is_prime_number"; + + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.COMPREHENSION)) + .forEach( + comprehensionNode -> { + boolean isFunctionWithinMacro = + comprehensionNode + .descendants() + .anyMatch( + node -> + node.expr() + .callOrDefault() + .function() + .equals(EXPENSIVE_FUNCTION_NAME)); + if (isFunctionWithinMacro) { + issuesFactory.addError( + comprehensionNode.id(), + EXPENSIVE_FUNCTION_NAME + " function cannot be used within CEL macros."); + } + }); + } + } +} diff --git a/codelab/src/test/codelab/BUILD.bazel b/codelab/src/test/codelab/BUILD.bazel new file mode 100644 index 000000000..fb3f1e235 --- /dev/null +++ b/codelab/src/test/codelab/BUILD.bazel @@ -0,0 +1,158 @@ +load("@rules_java//java:defs.bzl", "java_test") + +package(default_applicable_licenses = [ + "//:license", +]) + +java_test( + name = "Exercise1Test", + srcs = ["Exercise1Test.java"], + tags = ["notap"], + test_class = "codelab.Exercise1Test", + deps = [ + "//:java_truth", + "//codelab", + "//common:cel_ast", + "//compiler", + "//compiler:compiler_builder", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise2Test", + srcs = ["Exercise2Test.java"], + tags = ["notap"], + test_class = "codelab.Exercise2Test", + deps = [ + "//:java_truth", + "//codelab", + "//common:cel_ast", + "//common/types", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise3Test", + srcs = ["Exercise3Test.java"], + tags = ["notap"], + test_class = "codelab.Exercise3Test", + deps = [ + "//:java_truth", + "//codelab", + "//runtime", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise4Test", + srcs = ["Exercise4Test.java"], + tags = ["notap"], + test_class = "codelab.Exercise4Test", + deps = [ + "//:java_truth", + "//codelab", + "//common:cel_ast", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise5Test", + srcs = ["Exercise5Test.java"], + tags = ["notap"], + test_class = "codelab.Exercise5Test", + deps = [ + "//:java_truth", + "//codelab", + "//common:cel_ast", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise6Test", + srcs = ["Exercise6Test.java"], + tags = ["notap"], + test_class = "codelab.Exercise6Test", + deps = [ + "//:java_truth", + "//codelab", + "//common:cel_ast", + "//common/internal:proto_time_utils", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise7Test", + srcs = ["Exercise7Test.java"], + tags = ["notap"], + test_class = "codelab.Exercise7Test", + deps = [ + "//:java_truth", + "//codelab", + "//common:cel_ast", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise8Test", + srcs = ["Exercise8Test.java"], + tags = ["notap"], + test_class = "codelab.Exercise8Test", + deps = [ + "//:java_truth", + "//codelab", + "//common:cel_ast", + "//common:compiler_common", + "//parser:unparser", + "//runtime", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise9Test", + srcs = ["Exercise9Test.java"], + tags = ["notap"], + test_class = "codelab.Exercise9Test", + deps = [ + "//:java_truth", + "//codelab", + "//common:cel_ast", + "//common:compiler_common", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +test_suite( + name = "exercise_test_suite", + tags = ["notap"], +) diff --git a/codelab/src/test/codelab/Exercise1Test.java b/codelab/src/test/codelab/Exercise1Test.java new file mode 100644 index 000000000..7ea1aa1eb --- /dev/null +++ b/codelab/src/test/codelab/Exercise1Test.java @@ -0,0 +1,73 @@ +// Copyright 2022 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 codelab; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class Exercise1Test { + private static final String TEST_EXPRESSION = "'Hello, World!'"; + + private final Exercise1 exercise1 = new Exercise1(); + + @Test + public void compile_stringExpression_parseSuccess() { + CelAbstractSyntaxTree ast = exercise1.compile(TEST_EXPRESSION); + assertThat(ast).isNotNull(); + } + + @Test + public void compile_stringExpression_typecheckSuccess() { + CelAbstractSyntaxTree ast = exercise1.compile(TEST_EXPRESSION); + assertThat(ast.isChecked()).isTrue(); + } + + @Test + public void compile_booleanExpression_throwsValidationException() { + IllegalArgumentException exception = + assertThrows(IllegalArgumentException.class, () -> exercise1.compile("true == true")); + + assertThat(exception).hasMessageThat().contains("Failed to type-check expression."); + assertThat(exception).hasMessageThat().contains("expected type 'string' but found 'bool'"); + } + + @Test + public void evaluate_stringExpression_success() { + CelAbstractSyntaxTree ast = exercise1.compile(TEST_EXPRESSION); + + Object evaluatedResult = exercise1.eval(ast); + + assertThat(evaluatedResult).isEqualTo("Hello, World!"); + } + + @Test + public void evaluate_divideByZeroExpression_throwsEvaluationException() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = compiler.compile("1/0").getAst(); + + IllegalArgumentException exception = + assertThrows(IllegalArgumentException.class, () -> exercise1.eval(ast)); + + assertThat(exception).hasMessageThat().contains("evaluation error at :1: / by zero"); + } +} diff --git a/codelab/src/test/codelab/Exercise2Test.java b/codelab/src/test/codelab/Exercise2Test.java new file mode 100644 index 000000000..24bf28e6b --- /dev/null +++ b/codelab/src/test/codelab/Exercise2Test.java @@ -0,0 +1,67 @@ +// Copyright 2022 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 codelab; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Struct; +import com.google.protobuf.Value; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise2Test { + private final Exercise2 exercise2 = new Exercise2(); + + @Test + @TestParameters("{value: 5, expectedResult: false}") + @TestParameters("{value: -5, expectedResult: true}") + public void evaluate_negativeExpression(long value, boolean expectedResult) { + CelAbstractSyntaxTree ast = exercise2.compile("value < 0", "value", SimpleType.INT); + + Object evaluatedResult = exercise2.eval(ast, ImmutableMap.of("value", value)); + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{group: 'admin', expectedResult: true}") + @TestParameters("{group: 'users', expectedResult: false}") + public void evaluate_requestAuthorization(String group, boolean expectedResult) { + CelAbstractSyntaxTree ast = + exercise2.compile( + "request.auth.claims.group == 'admin'", + "request", + StructTypeReference.create("google.rpc.context.AttributeContext.Request")); + + AttributeContext.Auth auth = + AttributeContext.Auth.newBuilder() + .setPrincipal("user:me@acme.co") + .setClaims( + Struct.newBuilder() + .putFields("group", Value.newBuilder().setStringValue(group).build())) + .build(); + AttributeContext.Request request = AttributeContext.Request.newBuilder().setAuth(auth).build(); + + Object evaluatedResult = exercise2.eval(ast, ImmutableMap.of("request", request)); + assertThat(evaluatedResult).isEqualTo(expectedResult); + } +} diff --git a/codelab/src/test/codelab/Exercise3Test.java b/codelab/src/test/codelab/Exercise3Test.java new file mode 100644 index 000000000..8bf0aa027 --- /dev/null +++ b/codelab/src/test/codelab/Exercise3Test.java @@ -0,0 +1,106 @@ +// Copyright 2022 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 codelab; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.runtime.CelEvaluationException; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise3Test { + private final Exercise3 exercise3 = new Exercise3(); + + /** + * Demonstrates CEL's unique feature of commutative logical operators. + * + *

If a logical operation can short-circuit a branch that results in an error, CEL evaluation + * will return the logical result instead of propagating the error. + */ + @Test + @TestParameters("{expression: 'true || true', expectedResult: true}") + @TestParameters("{expression: 'true || false', expectedResult: true}") + @TestParameters("{expression: 'false || true', expectedResult: true}") + @TestParameters("{expression: 'false || false', expectedResult: false}") + @TestParameters("{expression: 'true || (1 / 0 > 2)', expectedResult: true}") + @TestParameters("{expression: '(1 / 0 > 2) || true', expectedResult: true}") + public void evaluate_logicalOrShortCircuits_success(String expression, boolean expectedResult) { + Object evaluatedResult = exercise3.compileAndEvaluate(expression); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + /** Demonstrates a case where an error is surfaced to the user. */ + @Test + @TestParameters("{expression: 'false || (1 / 0 > 2)'}") + @TestParameters("{expression: '(1 / 0 > 2) || false'}") + public void evaluate_logicalOrFailure_throwsException(String expression) { + IllegalArgumentException exception = + assertThrows( + IllegalArgumentException.class, () -> exercise3.compileAndEvaluate(expression)); + + assertThat(exception).hasMessageThat().contains("Evaluation error has occurred."); + assertThat(exception).hasCauseThat().isInstanceOf(CelEvaluationException.class); + assertThat(exception).hasCauseThat().hasMessageThat().contains("evaluation error"); + assertThat(exception).hasCauseThat().hasMessageThat().contains("/ by zero"); + } + + @Test + @TestParameters("{expression: 'todo: Fill me in using logical AND! (&&)', expectedResult: true}") + public void evaluate_logicalAndShortCircuits_success(String expression, boolean expectedResult) { + Object evaluatedResult = exercise3.compileAndEvaluate(expression); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expression: 'todo: Fill me in using logical AND! (&&)'}") + public void evaluate_logicalAndFailure_throwsException(String expression) { + IllegalArgumentException exception = + assertThrows( + IllegalArgumentException.class, () -> exercise3.compileAndEvaluate(expression)); + + assertThat(exception).hasMessageThat().contains("Evaluation error has occurred."); + assertThat(exception).hasCauseThat().isInstanceOf(CelEvaluationException.class); + assertThat(exception).hasCauseThat().hasMessageThat().contains("evaluation error"); + assertThat(exception).hasCauseThat().hasMessageThat().contains("/ by zero"); + } + + @Test + @TestParameters("{expression: 'false ? (1 / 0) > 2 : false', expectedResult: false}") + @TestParameters("{expression: 'todo: Fill me in using ternary! A ? B : C', expectedResult: true}") + public void evaluate_ternaryShortCircuits_success(String expression, boolean expectedResult) { + Object evaluatedResult = exercise3.compileAndEvaluate(expression); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expression: 'todo: Fill me in using ternary! A ? B : C'}") + public void evaluate_ternaryFailure_throwsException(String expression) { + IllegalArgumentException exception = + assertThrows( + IllegalArgumentException.class, () -> exercise3.compileAndEvaluate(expression)); + + assertThat(exception).hasMessageThat().contains("Evaluation error has occurred."); + assertThat(exception).hasCauseThat().isInstanceOf(CelEvaluationException.class); + assertThat(exception).hasCauseThat().hasMessageThat().contains("evaluation error"); + assertThat(exception).hasCauseThat().hasMessageThat().contains("/ by zero"); + } +} diff --git a/codelab/src/test/codelab/Exercise4Test.java b/codelab/src/test/codelab/Exercise4Test.java new file mode 100644 index 000000000..dc6d4524e --- /dev/null +++ b/codelab/src/test/codelab/Exercise4Test.java @@ -0,0 +1,51 @@ +// Copyright 2022 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 codelab; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Struct; +import com.google.protobuf.Value; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelAbstractSyntaxTree; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise4Test { + private final Exercise4 exercise4 = new Exercise4(); + + @Test + @TestParameters("{group: 'admin', expectedResult: true}") + @TestParameters("{group: 'users', expectedResult: false}") + public void evaluate_requestContainsGroup_success(String group, boolean expectedResult) { + CelAbstractSyntaxTree ast = exercise4.compile("request.auth.claims.contains('group', 'admin')"); + AttributeContext.Auth auth = + AttributeContext.Auth.newBuilder() + .setPrincipal("user:me@acme.co") + .setClaims( + Struct.newBuilder() + .putFields("group", Value.newBuilder().setStringValue(group).build())) + .build(); + AttributeContext.Request request = AttributeContext.Request.newBuilder().setAuth(auth).build(); + + Object evaluatedResult = exercise4.eval(ast, ImmutableMap.of("request", request)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } +} diff --git a/codelab/src/test/codelab/Exercise5Test.java b/codelab/src/test/codelab/Exercise5Test.java new file mode 100644 index 000000000..128300166 --- /dev/null +++ b/codelab/src/test/codelab/Exercise5Test.java @@ -0,0 +1,66 @@ +// Copyright 2024 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 codelab; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Timestamp; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise5Test { + private final Exercise5 exercise5 = new Exercise5(); + + @Test + public void evaluate_jwtWithTimeVariable_producesJsonString() throws Exception { + // Note the quoted keys in the CEL map literal. For proto messages the field names are unquoted + // as they represent well-defined identifiers. + String jwt = + "{'sub': 'serviceAccount:delegate@acme.co'," + + "'aud': 'my-project'," + + "'iss': 'auth.acme.com:12350'," + + "'iat': time," + + "'nbf': time," + + "'exp': time + duration('300s')," + + "'extra_claims': {" + + "'group': 'admin'" + + "}}"; + CelAbstractSyntaxTree ast = exercise5.compile(jwt); + + // The output of the program is a map type. + @SuppressWarnings("unchecked") + Map evaluatedResult = + (Map) + exercise5.eval( + ast, + ImmutableMap.of("time", Timestamp.newBuilder().setSeconds(1698361778).build())); + String jsonOutput = exercise5.toJson(evaluatedResult); + + assertThat(jsonOutput) + .isEqualTo( + "{\"sub\":\"serviceAccount:delegate@acme.co\"," + + "\"aud\":\"my-project\"," + + "\"iss\":\"auth.acme.com:12350\"," + + "\"iat\":\"2023-10-26T23:09:38Z\"," + + "\"nbf\":\"2023-10-26T23:09:38Z\"," + + "\"exp\":\"2023-10-26T23:14:38Z\"," + + "\"extra_claims\":{\"group\":\"admin\"}}"); + } +} diff --git a/codelab/src/test/codelab/Exercise6Test.java b/codelab/src/test/codelab/Exercise6Test.java new file mode 100644 index 000000000..d4add9b90 --- /dev/null +++ b/codelab/src/test/codelab/Exercise6Test.java @@ -0,0 +1,102 @@ +// Copyright 2024 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 codelab; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.Value; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.internal.ProtoTimeUtils; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise6Test { + private final Exercise6 exercise6 = new Exercise6(); + + @Test + public void evaluate_constructAttributeContext() { + // Given JSON web token and the current time as input variables, + // Setup an expression to construct an AttributeContext protobuf object. + // + // Note: the field names within the proto message types are not quoted as they + // are well-defined names composed of valid identifier characters. Also, note + // that when building nested proto objects, the message name needs to prefix + // the object construction. + String expression = + "Request{\n" + + "auth: Auth{" + + " principal: jwt.iss + '/' + jwt.sub," + + " audiences: [jwt.aud]," + + " presenter: 'azp' in jwt ? jwt.azp : ''," + + " claims: jwt" + + "}," + + "time: now" + + "}"; + // Values for `now` and `jwt` variables to be passed into the runtime + Timestamp now = ProtoTimeUtils.now(); + ImmutableMap jwt = + ImmutableMap.of( + "sub", "serviceAccount:delegate@acme.co", + "aud", "my-project", + "iss", "auth.acme.com:12350", + "extra_claims", ImmutableMap.of("group", "admin")); + AttributeContext.Request expectedMessage = + AttributeContext.Request.newBuilder() + .setTime(now) + .setAuth( + AttributeContext.Auth.newBuilder() + .setPrincipal("auth.acme.com:12350/serviceAccount:delegate@acme.co") + .addAudiences("my-project") + .setClaims( + Struct.newBuilder() + .putAllFields( + ImmutableMap.of( + "sub", newStringValue("serviceAccount:delegate@acme.co"), + "aud", newStringValue("my-project"), + "iss", newStringValue("auth.acme.com:12350"))) + .putFields( + "extra_claims", + Value.newBuilder() + .setStructValue( + Struct.newBuilder() + .putFields("group", newStringValue("admin")) + .build()) + .build()))) + .build(); + + // Compile the `Request` message construction expression and validate that + // the resulting expression type matches the fully qualified message name. + CelAbstractSyntaxTree ast = exercise6.compile(expression); + AttributeContext.Request evaluatedResult = + (AttributeContext.Request) + exercise6.eval( + ast, + ImmutableMap.of( + "now", now, + "jwt", jwt)); + + assertThat(evaluatedResult).isEqualTo(expectedMessage); + } + + private static Value newStringValue(String value) { + return Value.newBuilder().setStringValue(value).build(); + } +} diff --git a/codelab/src/test/codelab/Exercise7Test.java b/codelab/src/test/codelab/Exercise7Test.java new file mode 100644 index 000000000..2caf0e4f9 --- /dev/null +++ b/codelab/src/test/codelab/Exercise7Test.java @@ -0,0 +1,60 @@ +// Copyright 2024 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 codelab; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise7Test { + private final Exercise7 exercise7 = new Exercise7(); + + @Test + public void evaluate_checkJwtClaimsWithMacro_evaluatesToTrue() { + String expression = + "jwt.extra_claims.exists(c, c.startsWith('group'))" + + " && jwt.extra_claims" + + ".filter(c, c.startsWith('group'))" + + ".all(c, jwt.extra_claims[c]" + + ".all(g, g.endsWith('@acme.co')))"; + ImmutableMap jwt = + ImmutableMap.of( + "sub", + "serviceAccount:delegate@acme.co", + "aud", + "my-project", + "iss", + "auth.acme.com:12350", + "extra_claims", + ImmutableMap.of("group1", ImmutableList.of("admin@acme.co", "analyst@acme.co")), + "labels", + ImmutableList.of("metadata", "prod", "pii"), + "groupN", + ImmutableList.of("forever@acme.co")); + CelAbstractSyntaxTree ast = exercise7.compile(expression); + + // Evaluate a complex-ish JWT with two groups that satisfy the criteria. + // Output: true. + boolean evaluatedResult = (boolean) exercise7.eval(ast, ImmutableMap.of("jwt", jwt)); + + assertThat(evaluatedResult).isTrue(); + } +} diff --git a/codelab/src/test/codelab/Exercise8Test.java b/codelab/src/test/codelab/Exercise8Test.java new file mode 100644 index 000000000..36fef248c --- /dev/null +++ b/codelab/src/test/codelab/Exercise8Test.java @@ -0,0 +1,147 @@ +// Copyright 2024 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 codelab; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.parser.CelUnparser; +import dev.cel.parser.CelUnparserFactory; +import dev.cel.runtime.CelEvaluationException; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise8Test { + + private final Exercise8 exercise8 = new Exercise8(); + + @Test + public void validate_invalidTimestampLiteral_returnsError() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("timestamp('bad')"); + + CelValidationResult validationResult = exercise8.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:11: timestamp validation failed. Reason: evaluation error: Text 'bad'" + + " could not be parsed at index 0\n" + + " | timestamp('bad')\n" + + " | ..........^"); + } + + @Test + public void validate_invalidDurationLiteral_returnsError() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("duration('bad')"); + + CelValidationResult validationResult = exercise8.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:10: duration validation failed. Reason: evaluation error: invalid" + + " duration format\n" + + " | duration('bad')\n" + + " | .........^"); + } + + @Test + public void validate_invalidRegexLiteral_returnsError() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("'text'.matches('**')"); + + CelValidationResult validationResult = exercise8.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:16: Regex validation failed. Reason: Dangling meta character '*' near" + + " index 0\n" + + "**\n" + + "^\n" + + " | 'text'.matches('**')\n" + + " | ...............^"); + } + + @Test + public void validate_listHasMixedLiterals_throws() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("3 in [1, 2, '3']"); + + // Note that `CelValidationResult` is the same result class used for the compilation path. This + // means you could alternatively invoke `.getAst()` and handle `CelValidationException` as + // usual. + CelValidationResult validationResult = exercise8.validate(ast); + + CelValidationException e = assertThrows(CelValidationException.class, validationResult::getAst); + assertThat(e) + .hasMessageThat() + .contains( + "ERROR: :1:13: expected type 'int' but found 'string'\n" + + " | 3 in [1, 2, '3']\n" + + " | ............^"); + } + + @Test + public void optimize_constantFold_success() throws Exception { + CelUnparser celUnparser = CelUnparserFactory.newUnparser(); + CelAbstractSyntaxTree ast = exercise8.compile("(1 + 2 + 3 == x) && (x in [1, 2, x])"); + + CelAbstractSyntaxTree optimizedAst = exercise8.optimize(ast); + + assertThat(celUnparser.unparse(optimizedAst)).isEqualTo("6 == x"); + } + + @Test + public void optimize_constantFold_evaluateError() throws Exception { + CelAbstractSyntaxTree ast = + exercise8.compile("request.headers.referer == 'https://' + 'cel.dev'"); + CelAbstractSyntaxTree optimizedAst = exercise8.optimize(ast); + ImmutableMap runtimeParameters = + ImmutableMap.of("request", AttributeContext.Request.getDefaultInstance()); + + CelEvaluationException e1 = + assertThrows(CelEvaluationException.class, () -> exercise8.eval(ast, runtimeParameters)); + CelEvaluationException e2 = + assertThrows( + CelEvaluationException.class, () -> exercise8.eval(optimizedAst, runtimeParameters)); + // Note that the errors below differ by their source position. + assertThat(e1) + .hasMessageThat() + .contains("evaluation error at :15: key 'referer' is not present in map."); + assertThat(e2) + .hasMessageThat() + .contains("evaluation error: key 'referer' is not present in map."); + } + + @Test + public void optimize_commonSubexpressionElimination_success() throws Exception { + CelUnparser celUnparser = CelUnparserFactory.newUnparser(); + CelAbstractSyntaxTree ast = + exercise8.compile( + "request.auth.claims.group == 'admin' || request.auth.claims.group == 'user'"); + + CelAbstractSyntaxTree optimizedAst = exercise8.optimize(ast); + + assertThat(celUnparser.unparse(optimizedAst)) + .isEqualTo( + "cel.@block([request.auth.claims.group], @index0 == \"admin\" || @index0 == \"user\")"); + } +} diff --git a/codelab/src/test/codelab/Exercise9Test.java b/codelab/src/test/codelab/Exercise9Test.java new file mode 100644 index 000000000..7157d61c2 --- /dev/null +++ b/codelab/src/test/codelab/Exercise9Test.java @@ -0,0 +1,95 @@ +// Copyright 2024 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 codelab; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise9Test { + private final Exercise9 exercise9 = new Exercise9(); + + @Test + public void validate_invalidHttpMethod_returnsError() throws Exception { + String expression = + "google.rpc.context.AttributeContext.Request { \n" + + "scheme: 'http', " + + "method: 'GETTT', " // method is misspelled. + + "host: 'cel.dev' \n" + + "}"; + CelAbstractSyntaxTree ast = exercise9.compile(expression); + + CelValidationResult validationResult = exercise9.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :2:25: GETTT is not an allowed HTTP method.\n" + + " | scheme: 'http', method: 'GETTT', host: 'cel.dev' \n" + + " | ........................^"); + assertThrows(CelValidationException.class, validationResult::getAst); + } + + @Test + public void validate_schemeIsHttp_returnsWarning() throws Exception { + String expression = + "google.rpc.context.AttributeContext.Request { \n" + + "scheme: 'http', " // https is preferred but not required. + + "method: 'GET', " + + "host: 'cel.dev' \n" + + "}"; + CelAbstractSyntaxTree ast = exercise9.compile(expression); + + CelValidationResult validationResult = exercise9.validate(ast); + + assertThat(validationResult.hasError()).isFalse(); + assertThat(validationResult.getIssueString()) + .isEqualTo( + "WARNING: :2:9: Prefer using https for safety.\n" + + " | scheme: 'http', method: 'GET', host: 'cel.dev' \n" + + " | ........^"); + // Because the validation result does not contain any errors, you can still evaluate it. + assertThat(exercise9.eval(validationResult.getAst())) + .isEqualTo( + AttributeContext.Request.newBuilder() + .setScheme("http") + .setMethod("GET") + .setHost("cel.dev") + .build()); + } + + @Test + public void validate_isPrimeNumberWithinMacro_returnsError() throws Exception { + String expression = "[2,3,5].all(x, is_prime_number(x))"; + CelAbstractSyntaxTree ast = exercise9.compile(expression); + + CelValidationResult validationResult = exercise9.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:12: is_prime_number function cannot be used within CEL macros.\n" + + " | [2,3,5].all(x, is_prime_number(x))\n" + + " | ...........^"); + } +} diff --git a/codelab/src/test/codelab/solutions/BUILD.bazel b/codelab/src/test/codelab/solutions/BUILD.bazel new file mode 100644 index 000000000..9eebbc3f4 --- /dev/null +++ b/codelab/src/test/codelab/solutions/BUILD.bazel @@ -0,0 +1,144 @@ +load("@rules_java//java:defs.bzl", "java_test") + +package(default_applicable_licenses = [ + "//:license", +]) + +java_test( + name = "Exercise1Test", + srcs = ["Exercise1Test.java"], + test_class = "codelab.solutions.Exercise1Test", + deps = [ + "//:java_truth", + "//codelab:solutions", + "//common:cel_ast", + "//compiler", + "//compiler:compiler_builder", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise2Test", + srcs = ["Exercise2Test.java"], + test_class = "codelab.solutions.Exercise2Test", + deps = [ + "//:java_truth", + "//codelab:solutions", + "//common:cel_ast", + "//common/types", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise3Test", + srcs = ["Exercise3Test.java"], + test_class = "codelab.solutions.Exercise3Test", + deps = [ + "//:java_truth", + "//codelab:solutions", + "//runtime", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise4Test", + srcs = ["Exercise4Test.java"], + test_class = "codelab.solutions.Exercise4Test", + deps = [ + "//:java_truth", + "//codelab:solutions", + "//common:cel_ast", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise5Test", + srcs = ["Exercise5Test.java"], + test_class = "codelab.solutions.Exercise5Test", + deps = [ + "//:java_truth", + "//codelab:solutions", + "//common:cel_ast", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise6Test", + srcs = ["Exercise6Test.java"], + test_class = "codelab.solutions.Exercise6Test", + deps = [ + "//:java_truth", + "//codelab:solutions", + "//common:cel_ast", + "//common/internal:proto_time_utils", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise7Test", + srcs = ["Exercise7Test.java"], + test_class = "codelab.solutions.Exercise7Test", + deps = [ + "//:java_truth", + "//codelab:solutions", + "//common:cel_ast", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise8Test", + srcs = ["Exercise8Test.java"], + test_class = "codelab.solutions.Exercise8Test", + deps = [ + "//:java_truth", + "//codelab:solutions", + "//common:cel_ast", + "//common:compiler_common", + "//parser:unparser", + "//runtime", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "Exercise9Test", + srcs = ["Exercise9Test.java"], + test_class = "codelab.solutions.Exercise9Test", + deps = [ + "//:java_truth", + "//codelab:solutions", + "//common:cel_ast", + "//common:compiler_common", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) diff --git a/codelab/src/test/codelab/solutions/Exercise1Test.java b/codelab/src/test/codelab/solutions/Exercise1Test.java new file mode 100644 index 000000000..c1e93862c --- /dev/null +++ b/codelab/src/test/codelab/solutions/Exercise1Test.java @@ -0,0 +1,73 @@ +// Copyright 2022 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 codelab.solutions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class Exercise1Test { + private static final String TEST_EXPRESSION = "'Hello, World!'"; + + private final Exercise1 exercise1 = new Exercise1(); + + @Test + public void compile_stringExpression_parseSuccess() { + CelAbstractSyntaxTree ast = exercise1.compile(TEST_EXPRESSION); + assertThat(ast).isNotNull(); + } + + @Test + public void compile_stringExpression_typecheckSuccess() { + CelAbstractSyntaxTree ast = exercise1.compile(TEST_EXPRESSION); + assertThat(ast.isChecked()).isTrue(); + } + + @Test + public void compile_booleanExpression_throwsValidationException() { + IllegalArgumentException exception = + assertThrows(IllegalArgumentException.class, () -> exercise1.compile("true == true")); + + assertThat(exception).hasMessageThat().contains("Failed to type-check expression."); + assertThat(exception).hasMessageThat().contains("expected type 'string' but found 'bool'"); + } + + @Test + public void evaluate_stringExpression_success() { + CelAbstractSyntaxTree ast = exercise1.compile(TEST_EXPRESSION); + + Object evaluatedResult = exercise1.eval(ast); + + assertThat(evaluatedResult).isEqualTo("Hello, World!"); + } + + @Test + public void evaluate_divideByZeroExpression_throwsEvaluationException() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = compiler.compile("1/0").getAst(); + + IllegalArgumentException exception = + assertThrows(IllegalArgumentException.class, () -> exercise1.eval(ast)); + + assertThat(exception).hasMessageThat().contains("evaluation error at :1: / by zero"); + } +} diff --git a/codelab/src/test/codelab/solutions/Exercise2Test.java b/codelab/src/test/codelab/solutions/Exercise2Test.java new file mode 100644 index 000000000..0c0cb4f9f --- /dev/null +++ b/codelab/src/test/codelab/solutions/Exercise2Test.java @@ -0,0 +1,67 @@ +// Copyright 2022 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 codelab.solutions; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Struct; +import com.google.protobuf.Value; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise2Test { + private final Exercise2 exercise2 = new Exercise2(); + + @Test + @TestParameters("{value: 5, expectedResult: false}") + @TestParameters("{value: -5, expectedResult: true}") + public void evaluate_negativeExpression(long value, boolean expectedResult) { + CelAbstractSyntaxTree ast = exercise2.compile("value < 0", "value", SimpleType.INT); + + Object evaluatedResult = exercise2.eval(ast, ImmutableMap.of("value", value)); + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{group: 'admin', expectedResult: true}") + @TestParameters("{group: 'users', expectedResult: false}") + public void evaluate_requestAuthorization(String group, boolean expectedResult) { + CelAbstractSyntaxTree ast = + exercise2.compile( + "request.auth.claims.group == 'admin'", + "request", + StructTypeReference.create("google.rpc.context.AttributeContext.Request")); + + AttributeContext.Auth auth = + AttributeContext.Auth.newBuilder() + .setPrincipal("user:me@acme.co") + .setClaims( + Struct.newBuilder() + .putFields("group", Value.newBuilder().setStringValue(group).build())) + .build(); + AttributeContext.Request request = AttributeContext.Request.newBuilder().setAuth(auth).build(); + + Object evaluatedResult = exercise2.eval(ast, ImmutableMap.of("request", request)); + assertThat(evaluatedResult).isEqualTo(expectedResult); + } +} diff --git a/codelab/src/test/codelab/solutions/Exercise3Test.java b/codelab/src/test/codelab/solutions/Exercise3Test.java new file mode 100644 index 000000000..0bef54ded --- /dev/null +++ b/codelab/src/test/codelab/solutions/Exercise3Test.java @@ -0,0 +1,116 @@ +// Copyright 2022 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 codelab.solutions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.runtime.CelEvaluationException; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise3Test { + private final Exercise3 exercise3 = new Exercise3(); + + /** + * Demonstrates CEL's unique feature of commutative logical operators. + * + *

If a logical operation can short-circuit a branch that results in an error, CEL evaluation + * will return the logical result instead of propagating the error. + */ + @Test + @TestParameters("{expression: 'true || true', expectedResult: true}") + @TestParameters("{expression: 'true || false', expectedResult: true}") + @TestParameters("{expression: 'false || true', expectedResult: true}") + @TestParameters("{expression: 'false || false', expectedResult: false}") + @TestParameters("{expression: 'true || (1 / 0 > 2)', expectedResult: true}") + @TestParameters("{expression: '(1 / 0 > 2) || true', expectedResult: true}") + public void evaluate_logicalOrShortCircuits_success(String expression, boolean expectedResult) { + Object evaluatedResult = exercise3.compileAndEvaluate(expression); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + /** Demonstrates a case where an error is surfaced to the user. */ + @Test + @TestParameters("{expression: 'false || (1 / 0 > 2)'}") + @TestParameters("{expression: '(1 / 0 > 2) || false'}") + public void evaluate_logicalOrFailure_throwsException(String expression) { + IllegalArgumentException exception = + assertThrows( + IllegalArgumentException.class, () -> exercise3.compileAndEvaluate(expression)); + + assertThat(exception).hasMessageThat().contains("Evaluation error has occurred."); + assertThat(exception).hasCauseThat().isInstanceOf(CelEvaluationException.class); + assertThat(exception).hasCauseThat().hasMessageThat().contains("evaluation error"); + assertThat(exception).hasCauseThat().hasMessageThat().contains("/ by zero"); + } + + @Test + @TestParameters("{expression: 'true && true', expectedResult: true}") + @TestParameters("{expression: 'true && false', expectedResult: false}") + @TestParameters("{expression: 'false && true', expectedResult: false}") + @TestParameters("{expression: 'false && false', expectedResult: false}") + @TestParameters("{expression: 'false && (1 / 0 > 2)', expectedResult: false}") + @TestParameters("{expression: '(1 / 0 > 2) && false', expectedResult: false}") + public void evaluate_logicalAndShortCircuits_success(String expression, boolean expectedResult) { + Object evaluatedResult = exercise3.compileAndEvaluate(expression); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expression: 'true && (1 / 0 > 2)'}") + @TestParameters("{expression: '(1 / 0 > 2) && true'}") + public void evaluate_logicalAndFailure_throwsException(String expression) { + IllegalArgumentException exception = + assertThrows( + IllegalArgumentException.class, () -> exercise3.compileAndEvaluate(expression)); + + assertThat(exception).hasMessageThat().contains("Evaluation error has occurred."); + assertThat(exception).hasCauseThat().isInstanceOf(CelEvaluationException.class); + assertThat(exception).hasCauseThat().hasMessageThat().contains("evaluation error"); + assertThat(exception).hasCauseThat().hasMessageThat().contains("/ by zero"); + } + + @Test + @TestParameters("{expression: 'false ? (1 / 0) > 2 : false', expectedResult: false}") + @TestParameters("{expression: 'false ? (1 / 0) > 2 : true', expectedResult: true}") + @TestParameters("{expression: 'true ? false : (1 / 0) > 2', expectedResult: false}") + @TestParameters("{expression: 'true ? true : (1 / 0) > 2', expectedResult: true}") + public void evaluate_ternaryShortCircuits_success(String expression, boolean expectedResult) { + Object evaluatedResult = exercise3.compileAndEvaluate(expression); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expression: '(1 / 0) > 2 ? true : true'}") + @TestParameters("{expression: 'true ? (1 / 0) > 2 : true'}") + @TestParameters("{expression: 'false ? true : (1 / 0) > 2'}") + public void evaluate_ternaryFailure_throwsException(String expression) { + IllegalArgumentException exception = + assertThrows( + IllegalArgumentException.class, () -> exercise3.compileAndEvaluate(expression)); + + assertThat(exception).hasMessageThat().contains("Evaluation error has occurred."); + assertThat(exception).hasCauseThat().isInstanceOf(CelEvaluationException.class); + assertThat(exception).hasCauseThat().hasMessageThat().contains("evaluation error"); + assertThat(exception).hasCauseThat().hasMessageThat().contains("/ by zero"); + } +} diff --git a/codelab/src/test/codelab/solutions/Exercise4Test.java b/codelab/src/test/codelab/solutions/Exercise4Test.java new file mode 100644 index 000000000..1a734f93a --- /dev/null +++ b/codelab/src/test/codelab/solutions/Exercise4Test.java @@ -0,0 +1,51 @@ +// Copyright 2022 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 codelab.solutions; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Struct; +import com.google.protobuf.Value; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelAbstractSyntaxTree; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise4Test { + private final Exercise4 exercise4 = new Exercise4(); + + @Test + @TestParameters("{group: 'admin', expectedResult: true}") + @TestParameters("{group: 'users', expectedResult: false}") + public void evaluate_requestContainsGroup_success(String group, boolean expectedResult) { + CelAbstractSyntaxTree ast = exercise4.compile("request.auth.claims.contains('group', 'admin')"); + AttributeContext.Auth auth = + AttributeContext.Auth.newBuilder() + .setPrincipal("user:me@acme.co") + .setClaims( + Struct.newBuilder() + .putFields("group", Value.newBuilder().setStringValue(group).build())) + .build(); + AttributeContext.Request request = AttributeContext.Request.newBuilder().setAuth(auth).build(); + + Object evaluatedResult = exercise4.eval(ast, ImmutableMap.of("request", request)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } +} diff --git a/codelab/src/test/codelab/solutions/Exercise5Test.java b/codelab/src/test/codelab/solutions/Exercise5Test.java new file mode 100644 index 000000000..405a73f4d --- /dev/null +++ b/codelab/src/test/codelab/solutions/Exercise5Test.java @@ -0,0 +1,66 @@ +// Copyright 2024 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 codelab.solutions; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Timestamp; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise5Test { + private final Exercise5 exercise5 = new Exercise5(); + + @Test + public void evaluate_jwtWithTimeVariable_producesJsonString() throws Exception { + // Note the quoted keys in the CEL map literal. For proto messages the field names are unquoted + // as they represent well-defined identifiers. + String jwt = + "{'sub': 'serviceAccount:delegate@acme.co'," + + "'aud': 'my-project'," + + "'iss': 'auth.acme.com:12350'," + + "'iat': time," + + "'nbf': time," + + "'exp': time + duration('300s')," + + "'extra_claims': {" + + "'group': 'admin'" + + "}}"; + CelAbstractSyntaxTree ast = exercise5.compile(jwt); + + // The output of the program is a map type. + @SuppressWarnings("unchecked") + Map evaluatedResult = + (Map) + exercise5.eval( + ast, + ImmutableMap.of("time", Timestamp.newBuilder().setSeconds(1698361778).build())); + String jsonOutput = exercise5.toJson(evaluatedResult); + + assertThat(jsonOutput) + .isEqualTo( + "{\"sub\":\"serviceAccount:delegate@acme.co\"," + + "\"aud\":\"my-project\"," + + "\"iss\":\"auth.acme.com:12350\"," + + "\"iat\":\"2023-10-26T23:09:38Z\"," + + "\"nbf\":\"2023-10-26T23:09:38Z\"," + + "\"exp\":\"2023-10-26T23:14:38Z\"," + + "\"extra_claims\":{\"group\":\"admin\"}}"); + } +} diff --git a/codelab/src/test/codelab/solutions/Exercise6Test.java b/codelab/src/test/codelab/solutions/Exercise6Test.java new file mode 100644 index 000000000..fbb1848cc --- /dev/null +++ b/codelab/src/test/codelab/solutions/Exercise6Test.java @@ -0,0 +1,102 @@ +// Copyright 2024 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 codelab.solutions; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.Value; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.internal.ProtoTimeUtils; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise6Test { + private final Exercise6 exercise6 = new Exercise6(); + + @Test + public void evaluate_constructAttributeContext() { + // Given JSON web token and the current time as input variables, + // Setup an expression to construct an AttributeContext protobuf object. + // + // Note: the field names within the proto message types are not quoted as they + // are well-defined names composed of valid identifier characters. Also, note + // that when building nested proto objects, the message name needs to prefix + // the object construction. + String expression = + "Request{\n" + + "auth: Auth{" + + " principal: jwt.iss + '/' + jwt.sub," + + " audiences: [jwt.aud]," + + " presenter: 'azp' in jwt ? jwt.azp : ''," + + " claims: jwt" + + "}," + + "time: now" + + "}"; + // Values for `now` and `jwt` variables to be passed into the runtime + Timestamp now = ProtoTimeUtils.now(); + ImmutableMap jwt = + ImmutableMap.of( + "sub", "serviceAccount:delegate@acme.co", + "aud", "my-project", + "iss", "auth.acme.com:12350", + "extra_claims", ImmutableMap.of("group", "admin")); + AttributeContext.Request expectedMessage = + AttributeContext.Request.newBuilder() + .setTime(now) + .setAuth( + AttributeContext.Auth.newBuilder() + .setPrincipal("auth.acme.com:12350/serviceAccount:delegate@acme.co") + .addAudiences("my-project") + .setClaims( + Struct.newBuilder() + .putAllFields( + ImmutableMap.of( + "sub", newStringValue("serviceAccount:delegate@acme.co"), + "aud", newStringValue("my-project"), + "iss", newStringValue("auth.acme.com:12350"))) + .putFields( + "extra_claims", + Value.newBuilder() + .setStructValue( + Struct.newBuilder() + .putFields("group", newStringValue("admin")) + .build()) + .build()))) + .build(); + + // Compile the `Request` message construction expression and validate that + // the resulting expression type matches the fully qualified message name. + CelAbstractSyntaxTree ast = exercise6.compile(expression); + AttributeContext.Request evaluatedResult = + (AttributeContext.Request) + exercise6.eval( + ast, + ImmutableMap.of( + "now", now, + "jwt", jwt)); + + assertThat(evaluatedResult).isEqualTo(expectedMessage); + } + + private static Value newStringValue(String value) { + return Value.newBuilder().setStringValue(value).build(); + } +} diff --git a/codelab/src/test/codelab/solutions/Exercise7Test.java b/codelab/src/test/codelab/solutions/Exercise7Test.java new file mode 100644 index 000000000..be0fe8af1 --- /dev/null +++ b/codelab/src/test/codelab/solutions/Exercise7Test.java @@ -0,0 +1,60 @@ +// Copyright 2024 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 codelab.solutions; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise7Test { + private final Exercise7 exercise7 = new Exercise7(); + + @Test + public void evaluate_checkJwtClaimsWithMacro_evaluatesToTrue() { + String expression = + "jwt.extra_claims.exists(c, c.startsWith('group'))" + + " && jwt.extra_claims" + + ".filter(c, c.startsWith('group'))" + + ".all(c, jwt.extra_claims[c]" + + ".all(g, g.endsWith('@acme.co')))"; + ImmutableMap jwt = + ImmutableMap.of( + "sub", + "serviceAccount:delegate@acme.co", + "aud", + "my-project", + "iss", + "auth.acme.com:12350", + "extra_claims", + ImmutableMap.of("group1", ImmutableList.of("admin@acme.co", "analyst@acme.co")), + "labels", + ImmutableList.of("metadata", "prod", "pii"), + "groupN", + ImmutableList.of("forever@acme.co")); + CelAbstractSyntaxTree ast = exercise7.compile(expression); + + // Evaluate a complex-ish JWT with two groups that satisfy the criteria. + // Output: true. + boolean evaluatedResult = (boolean) exercise7.eval(ast, ImmutableMap.of("jwt", jwt)); + + assertThat(evaluatedResult).isTrue(); + } +} diff --git a/codelab/src/test/codelab/solutions/Exercise8Test.java b/codelab/src/test/codelab/solutions/Exercise8Test.java new file mode 100644 index 000000000..73a0ddc91 --- /dev/null +++ b/codelab/src/test/codelab/solutions/Exercise8Test.java @@ -0,0 +1,147 @@ +// Copyright 2024 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 codelab.solutions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.parser.CelUnparser; +import dev.cel.parser.CelUnparserFactory; +import dev.cel.runtime.CelEvaluationException; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise8Test { + + private final Exercise8 exercise8 = new Exercise8(); + + @Test + public void validate_invalidTimestampLiteral_returnsError() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("timestamp('bad')"); + + CelValidationResult validationResult = exercise8.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:11: timestamp validation failed. Reason: evaluation error: Text 'bad'" + + " could not be parsed at index 0\n" + + " | timestamp('bad')\n" + + " | ..........^"); + } + + @Test + public void validate_invalidDurationLiteral_returnsError() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("duration('bad')"); + + CelValidationResult validationResult = exercise8.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:10: duration validation failed. Reason: evaluation error: invalid" + + " duration format\n" + + " | duration('bad')\n" + + " | .........^"); + } + + @Test + public void validate_invalidRegexLiteral_returnsError() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("'text'.matches('**')"); + + CelValidationResult validationResult = exercise8.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:16: Regex validation failed. Reason: Dangling meta character '*' near" + + " index 0\n" + + "**\n" + + "^\n" + + " | 'text'.matches('**')\n" + + " | ...............^"); + } + + @Test + public void validate_listHasMixedLiterals_throws() throws Exception { + CelAbstractSyntaxTree ast = exercise8.compile("3 in [1, 2, '3']"); + + // Note that `CelValidationResult` is the same result class used for the compilation path. This + // means you could alternatively invoke `.getAst()` and handle `CelValidationException` as + // usual. + CelValidationResult validationResult = exercise8.validate(ast); + + CelValidationException e = assertThrows(CelValidationException.class, validationResult::getAst); + assertThat(e) + .hasMessageThat() + .contains( + "ERROR: :1:13: expected type 'int' but found 'string'\n" + + " | 3 in [1, 2, '3']\n" + + " | ............^"); + } + + @Test + public void optimize_constantFold_success() throws Exception { + CelUnparser celUnparser = CelUnparserFactory.newUnparser(); + CelAbstractSyntaxTree ast = exercise8.compile("(1 + 2 + 3 == x) && (x in [1, 2, x])"); + + CelAbstractSyntaxTree optimizedAst = exercise8.optimize(ast); + + assertThat(celUnparser.unparse(optimizedAst)).isEqualTo("6 == x"); + } + + @Test + public void optimize_constantFold_evaluateError() throws Exception { + CelAbstractSyntaxTree ast = + exercise8.compile("request.headers.referer == 'https://' + 'cel.dev'"); + CelAbstractSyntaxTree optimizedAst = exercise8.optimize(ast); + ImmutableMap runtimeParameters = + ImmutableMap.of("request", AttributeContext.Request.getDefaultInstance()); + + CelEvaluationException e1 = + assertThrows(CelEvaluationException.class, () -> exercise8.eval(ast, runtimeParameters)); + CelEvaluationException e2 = + assertThrows( + CelEvaluationException.class, () -> exercise8.eval(optimizedAst, runtimeParameters)); + // Note that the errors below differ by their source position. + assertThat(e1) + .hasMessageThat() + .contains("evaluation error at :15: key 'referer' is not present in map."); + assertThat(e2) + .hasMessageThat() + .contains("evaluation error: key 'referer' is not present in map."); + } + + @Test + public void optimize_commonSubexpressionElimination_success() throws Exception { + CelUnparser celUnparser = CelUnparserFactory.newUnparser(); + CelAbstractSyntaxTree ast = + exercise8.compile( + "request.auth.claims.group == 'admin' || request.auth.claims.group == 'user'"); + + CelAbstractSyntaxTree optimizedAst = exercise8.optimize(ast); + + assertThat(celUnparser.unparse(optimizedAst)) + .isEqualTo( + "cel.@block([request.auth.claims.group], @index0 == \"admin\" || @index0 == \"user\")"); + } +} diff --git a/codelab/src/test/codelab/solutions/Exercise9Test.java b/codelab/src/test/codelab/solutions/Exercise9Test.java new file mode 100644 index 000000000..622df45ce --- /dev/null +++ b/codelab/src/test/codelab/solutions/Exercise9Test.java @@ -0,0 +1,95 @@ +// Copyright 2024 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 codelab.solutions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class Exercise9Test { + private final Exercise9 exercise9 = new Exercise9(); + + @Test + public void validate_invalidHttpMethod_returnsError() throws Exception { + String expression = + "google.rpc.context.AttributeContext.Request { \n" + + "scheme: 'http', " + + "method: 'GETTT', " // method is misspelled. + + "host: 'cel.dev' \n" + + "}"; + CelAbstractSyntaxTree ast = exercise9.compile(expression); + + CelValidationResult validationResult = exercise9.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :2:25: GETTT is not an allowed HTTP method.\n" + + " | scheme: 'http', method: 'GETTT', host: 'cel.dev' \n" + + " | ........................^"); + assertThrows(CelValidationException.class, validationResult::getAst); + } + + @Test + public void validate_schemeIsHttp_returnsWarning() throws Exception { + String expression = + "google.rpc.context.AttributeContext.Request { \n" + + "scheme: 'http', " // https is preferred but not required. + + "method: 'GET', " + + "host: 'cel.dev' \n" + + "}"; + CelAbstractSyntaxTree ast = exercise9.compile(expression); + + CelValidationResult validationResult = exercise9.validate(ast); + + assertThat(validationResult.hasError()).isFalse(); + assertThat(validationResult.getIssueString()) + .isEqualTo( + "WARNING: :2:9: Prefer using https for safety.\n" + + " | scheme: 'http', method: 'GET', host: 'cel.dev' \n" + + " | ........^"); + // Because the validation result does not contain any errors, you can still evaluate it. + assertThat(exercise9.eval(validationResult.getAst())) + .isEqualTo( + AttributeContext.Request.newBuilder() + .setScheme("http") + .setMethod("GET") + .setHost("cel.dev") + .build()); + } + + @Test + public void validate_isPrimeNumberWithinMacro_returnsError() throws Exception { + String expression = "[2,3,5].all(x, is_prime_number(x))"; + CelAbstractSyntaxTree ast = exercise9.compile(expression); + + CelValidationResult validationResult = exercise9.validate(ast); + + assertThat(validationResult.hasError()).isTrue(); + assertThat(validationResult.getErrorString()) + .isEqualTo( + "ERROR: :1:12: is_prime_number function cannot be used within CEL macros.\n" + + " | [2,3,5].all(x, is_prime_number(x))\n" + + " | ...........^"); + } +} diff --git a/common/BUILD.bazel b/common/BUILD.bazel new file mode 100644 index 000000000..4e0d7485c --- /dev/null +++ b/common/BUILD.bazel @@ -0,0 +1,129 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "compiler_common", + exports = ["//common/src/main/java/dev/cel/common:compiler_common"], +) + +java_library( + name = "options", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common:options"], +) + +java_library( + name = "container", + exports = ["//common/src/main/java/dev/cel/common:container"], +) + +java_library( + name = "proto_ast", + exports = ["//common/src/main/java/dev/cel/common:proto_ast"], +) + +cel_android_library( + name = "proto_ast_android", + exports = ["//common/src/main/java/dev/cel/common:proto_ast_android"], +) + +java_library( + name = "proto_v1alpha1_ast", + exports = ["//common/src/main/java/dev/cel/common:proto_v1alpha1_ast"], +) + +java_library( + name = "error_codes", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common:error_codes"], +) + +java_library( + name = "mutable_ast", + exports = ["//common/src/main/java/dev/cel/common:mutable_ast"], +) + +java_library( + name = "mutable_source", + exports = ["//common/src/main/java/dev/cel/common:mutable_source"], +) + +java_library( + name = "proto_json_adapter", + exports = ["//common/src/main/java/dev/cel/common:proto_json_adapter"], +) + +java_library( + name = "source", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common:source"], +) + +java_library( + name = "source_location", + exports = ["//common/src/main/java/dev/cel/common:source_location"], +) + +java_library( + name = "cel_source", + exports = ["//common/src/main/java/dev/cel/common:cel_source"], +) + +cel_android_library( + name = "cel_source_android", + exports = ["//common/src/main/java/dev/cel/common:cel_source_android"], +) + +java_library( + name = "cel_source_helper", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common:cel_source_helper"], +) + +java_library( + name = "cel_ast", + exports = ["//common/src/main/java/dev/cel/common:cel_ast"], +) + +cel_android_library( + name = "cel_ast_android", + exports = [ + "//common/src/main/java/dev/cel/common:cel_ast_android", + ], +) + +java_library( + name = "cel_exception", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common:cel_exception"], +) + +java_library( + name = "cel_descriptors", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common:cel_descriptors"], +) + +java_library( + name = "cel_descriptor_util", + visibility = [ + "//:internal", + # TODO: Remove references to the following clients + ], + exports = ["//common/src/main/java/dev/cel/common:cel_descriptor_util"], +) + +java_library( + name = "operator", + exports = ["//common/src/main/java/dev/cel/common:operator"], +) + +cel_android_library( + name = "operator_android", + exports = ["//common/src/main/java/dev/cel/common:operator_android"], +) diff --git a/common/annotations/BUILD.bazel b/common/annotations/BUILD.bazel new file mode 100644 index 000000000..e8ba25e52 --- /dev/null +++ b/common/annotations/BUILD.bazel @@ -0,0 +1,12 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "annotations", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/annotations"], +) diff --git a/common/ast/BUILD.bazel b/common/ast/BUILD.bazel new file mode 100644 index 000000000..276db0322 --- /dev/null +++ b/common/ast/BUILD.bazel @@ -0,0 +1,47 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "ast", + exports = ["//common/src/main/java/dev/cel/common/ast"], +) + +cel_android_library( + name = "ast_android", + exports = ["//common/src/main/java/dev/cel/common/ast:ast_android"], +) + +java_library( + name = "expr_converter", + exports = ["//common/src/main/java/dev/cel/common/ast:expr_converter"], +) + +cel_android_library( + name = "expr_converter_android", + exports = ["//common/src/main/java/dev/cel/common/ast:expr_converter_android"], +) + +java_library( + name = "expr_v1alpha1_converter", + exports = ["//common/src/main/java/dev/cel/common/ast:expr_v1alpha1_converter"], +) + +java_library( + name = "cel_expr_visitor", + exports = ["//common/src/main/java/dev/cel/common/ast:cel_expr_visitor"], +) + +java_library( + name = "expr_factory", + exports = ["//common/src/main/java/dev/cel/common/ast:expr_factory"], +) + +java_library( + name = "mutable_expr", + exports = ["//common/src/main/java/dev/cel/common/ast:mutable_expr"], +) diff --git a/common/exceptions/BUILD.bazel b/common/exceptions/BUILD.bazel new file mode 100644 index 000000000..3464632d9 --- /dev/null +++ b/common/exceptions/BUILD.bazel @@ -0,0 +1,66 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//:internal"], +) + +java_library( + name = "runtime_exception", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/exceptions:runtime_exception"], +) + +java_library( + name = "attribute_not_found", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/exceptions:attribute_not_found"], +) + +java_library( + name = "divide_by_zero", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/exceptions:divide_by_zero"], +) + +java_library( + name = "index_out_of_bounds", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/exceptions:index_out_of_bounds"], +) + +java_library( + name = "bad_format", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/exceptions:bad_format"], +) + +java_library( + name = "numeric_overflow", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/exceptions:numeric_overflow"], +) + +java_library( + name = "invalid_argument", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/exceptions:invalid_argument"], +) + +java_library( + name = "iteration_budget_exceeded", + # used_by_android + 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 + exports = ["//common/src/main/java/dev/cel/common/exceptions:overload_not_found"], +) diff --git a/common/formats/BUILD.bazel b/common/formats/BUILD.bazel new file mode 100644 index 000000000..feed7ce42 --- /dev/null +++ b/common/formats/BUILD.bazel @@ -0,0 +1,39 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//:internal"], +) + +java_library( + name = "yaml_helper", + visibility = [ + "//:internal", + "//java/com/google/cloud/security/green/rundetector/custommodules/detectors:__pkg__", + ], + exports = ["//common/src/main/java/dev/cel/common/formats:yaml_helper"], +) + +java_library( + name = "value_string", + visibility = [ + "//:internal", + "//java/com/google/cloud/security/green/rundetector/custommodules/detectors:__pkg__", + ], + exports = ["//common/src/main/java/dev/cel/common/formats:value_string"], +) + +java_library( + name = "parser_context", + exports = ["//common/src/main/java/dev/cel/common/formats:parser_context"], +) + +java_library( + name = "yaml_parser_context_impl", + exports = ["//common/src/main/java/dev/cel/common/formats:yaml_parser_context_impl"], +) + +java_library( + name = "file_source", + exports = ["//common/src/main/java/dev/cel/common/formats:file_source"], +) diff --git a/common/internal/BUILD.bazel b/common/internal/BUILD.bazel new file mode 100644 index 000000000..7c33e56b9 --- /dev/null +++ b/common/internal/BUILD.bazel @@ -0,0 +1,154 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//:internal"], +) + +java_library( + name = "internal", + exports = ["//common/src/main/java/dev/cel/common/internal"], +) + +java_library( + name = "code_point_stream", + exports = ["//common/src/main/java/dev/cel/common/internal:code_point_stream"], +) + +java_library( + name = "comparison_functions", + exports = ["//common/src/main/java/dev/cel/common/internal:comparison_functions"], +) + +cel_android_library( + name = "comparison_functions_android", + exports = ["//common/src/main/java/dev/cel/common/internal:comparison_functions_android"], +) + +java_library( + name = "converter", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/internal:converter"], +) + +java_library( + name = "dynamic_proto", + exports = ["//common/src/main/java/dev/cel/common/internal:dynamic_proto"], +) + +java_library( + name = "proto_lite_adapter", + exports = ["//common/src/main/java/dev/cel/common/internal:proto_lite_adapter"], +) + +java_library( + name = "proto_equality", + exports = ["//common/src/main/java/dev/cel/common/internal:proto_equality"], +) + +java_library( + name = "file_descriptor_converter", + exports = ["//common/src/main/java/dev/cel/common/internal:file_descriptor_converter"], +) + +java_library( + name = "errors", + exports = ["//common/src/main/java/dev/cel/common/internal:errors"], +) + +java_library( + name = "env_visitor", + exports = ["//common/src/main/java/dev/cel/common/internal:env_visitor"], +) + +java_library( + name = "default_instance_message_factory", + exports = ["//common/src/main/java/dev/cel/common/internal:default_instance_message_factory"], +) + +java_library( + name = "default_instance_message_lite_factory", + exports = ["//common/src/main/java/dev/cel/common/internal:default_instance_message_lite_factory"], +) + +java_library( + name = "well_known_proto", + exports = ["//common/src/main/java/dev/cel/common/internal:well_known_proto"], +) + +cel_android_library( + name = "well_known_proto_android", + exports = ["//common/src/main/java/dev/cel/common/internal:well_known_proto_android"], +) + +java_library( + name = "proto_message_factory", + exports = ["//common/src/main/java/dev/cel/common/internal:proto_message_factory"], +) + +java_library( + name = "default_message_factory", + exports = ["//common/src/main/java/dev/cel/common/internal:default_message_factory"], +) + +java_library( + name = "cel_descriptor_pools", + exports = ["//common/src/main/java/dev/cel/common/internal:cel_descriptor_pools"], +) + +java_library( + name = "cel_lite_descriptor_pool", + exports = ["//common/src/main/java/dev/cel/common/internal:cel_lite_descriptor_pool"], +) + +cel_android_library( + name = "cel_lite_descriptor_pool_android", + exports = ["//common/src/main/java/dev/cel/common/internal:cel_lite_descriptor_pool_android"], +) + +java_library( + name = "default_lite_descriptor_pool", + exports = ["//common/src/main/java/dev/cel/common/internal:default_lite_descriptor_pool"], +) + +cel_android_library( + name = "default_lite_descriptor_pool_android", + exports = ["//common/src/main/java/dev/cel/common/internal:default_lite_descriptor_pool_android"], +) + +java_library( + name = "safe_string_formatter", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/internal:safe_string_formatter"], +) + +cel_android_library( + name = "internal_android", + exports = ["//common/src/main/java/dev/cel/common/internal:internal_android"], +) + +java_library( + name = "proto_time_utils", + exports = ["//common/src/main/java/dev/cel/common/internal:proto_time_utils"], +) + +cel_android_library( + name = "proto_time_utils_android", + exports = ["//common/src/main/java/dev/cel/common/internal:proto_time_utils_android"], +) + +java_library( + name = "date_time_helpers", + exports = ["//common/src/main/java/dev/cel/common/internal:date_time_helpers"], +) + +cel_android_library( + name = "date_time_helpers_android", + exports = ["//common/src/main/java/dev/cel/common/internal:date_time_helpers_android"], +) + +java_library( + name = "reflection_util", + exports = ["//common/src/main/java/dev/cel/common/internal:reflection_util"], +) diff --git a/common/navigation/BUILD.bazel b/common/navigation/BUILD.bazel new file mode 100644 index 000000000..1dba25b8e --- /dev/null +++ b/common/navigation/BUILD.bazel @@ -0,0 +1,21 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "common", + exports = ["//common/src/main/java/dev/cel/common/navigation:common"], +) + +java_library( + name = "navigation", + exports = ["//common/src/main/java/dev/cel/common/navigation"], +) + +java_library( + name = "mutable_navigation", + exports = ["//common/src/main/java/dev/cel/common/navigation:mutable_navigation"], +) diff --git a/common/resources/testdata/proto3/BUILD.bazel b/common/resources/testdata/proto3/BUILD.bazel new file mode 100644 index 000000000..76a097d03 --- /dev/null +++ b/common/resources/testdata/proto3/BUILD.bazel @@ -0,0 +1,15 @@ +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//:internal"], +) + +alias( + name = "test_all_types_file_descriptor_set", + actual = "//common/src/main/resources/testdata/proto3:test_all_types_file_descriptor_set", +) + +alias( + name = "standalone_global_enum_java_proto", + actual = "//common/src/main/resources/testdata/proto3:standalone_global_enum_java_proto", +) diff --git a/common/src/main/java/dev/cel/common/BUILD.bazel b/common/src/main/java/dev/cel/common/BUILD.bazel new file mode 100644 index 000000000..38548744c --- /dev/null +++ b/common/src/main/java/dev/cel/common/BUILD.bazel @@ -0,0 +1,382 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//common:__pkg__", + "//publish:__pkg__", + ], +) + +# keep sorted +COMPILER_COMMON_SOURCES = [ + "CelFunctionDecl.java", + "CelIssue.java", + "CelOverloadDecl.java", + "CelValidationException.java", + "CelValidationResult.java", + "CelVarDecl.java", +] + +# keep sorted +SOURCE_SOURCES = [ + "Source.java", +] + +# keep sorted +PROTO_AST_SOURCE = [ + "CelProtoAbstractSyntaxTree.java", +] + +# keep sorted +PROTO_V1ALPHA1_AST_SOURCE = [ + "CelProtoV1Alpha1AbstractSyntaxTree.java", +] + +java_library( + name = "cel_descriptor_util", + srcs = [ + "CelDescriptorUtil.java", + ], + tags = [ + ], + deps = [ + ":cel_descriptors", + "//common/annotations", + "//common/internal:file_descriptor_converter", + "//common/types:cel_types", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "cel_descriptors", + srcs = [ + "CelDescriptors.java", + ], + tags = [ + ], + deps = [ + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "compiler_common", + srcs = COMPILER_COMMON_SOURCES, + tags = [ + ], + deps = [ + ":cel_ast", + ":cel_exception", + ":cel_source", + ":source", + ":source_location", + "//:auto_value", + "//common/annotations", + "//common/internal:safe_string_formatter", + "//common/types:cel_proto_types", + "//common/types:type_providers", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "cel_exception", + srcs = ["CelException.java"], + # used_by_android + tags = [ + ], + deps = [ + ":error_codes", + ], +) + +java_library( + name = "options", + srcs = ["CelOptions.java"], + # used_by_android + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "proto_ast", + srcs = PROTO_AST_SOURCE, + tags = [ + ], + deps = [ + ":cel_ast", + ":cel_source", + "//common/ast:expr_converter", + "//common/types:cel_proto_types", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "proto_ast_android", + srcs = PROTO_AST_SOURCE, + tags = [ + ], + deps = [ + ":cel_ast_android", + ":cel_source_android", + "//common/ast:expr_converter_android", + "//common/types:cel_proto_types_android", + "@cel_spec//proto/cel/expr:checked_java_proto_lite", + "@cel_spec//proto/cel/expr:syntax_java_proto_lite", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "proto_v1alpha1_ast", + srcs = PROTO_V1ALPHA1_AST_SOURCE, + tags = [ + ], + deps = [ + ":cel_ast", + ":cel_source", + "//common/ast:expr_v1alpha1_converter", + "//common/types:cel_v1alpha1_types", + "@com_google_googleapis//google/api/expr/v1alpha1:expr_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "error_codes", + srcs = ["CelErrorCode.java"], + # used_by_android + tags = [ + ], +) + +java_library( + name = "mutable_ast", + srcs = ["CelMutableAst.java"], + tags = [ + ], + deps = [ + ":cel_ast", + ":mutable_source", + "//common/ast", + "//common/ast:mutable_expr", + "//common/types:type_providers", + ], +) + +java_library( + name = "mutable_source", + srcs = ["CelMutableSource.java"], + tags = [ + ], + deps = [ + ":cel_source", + "//common/ast:mutable_expr", + "//common/internal", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "proto_json_adapter", + srcs = ["CelProtoJsonAdapter.java"], + tags = [ + ], + deps = [ + "//common/internal:date_time_helpers", + "//common/internal:proto_time_utils", + "//common/values", + "//common/values:cel_byte_string", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "source_location", + srcs = ["CelSourceLocation.java"], + tags = [ + ], + deps = [ + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "cel_source", + srcs = ["CelSource.java"], + tags = [ + ], + deps = [ + ":cel_source_helper", + ":source", + ":source_location", + "//:auto_value", + "//common/ast", + "//common/internal", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "cel_source_android", + srcs = ["CelSource.java"], + tags = [ + ], + deps = [ + ":cel_source_helper_android", + ":source_android", + ":source_location_android", + "//:auto_value", + "//common/ast:ast_android", + "//common/internal:internal_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "cel_source_helper", + srcs = ["CelSourceHelper.java"], + tags = [ + ], + deps = [ + ":source_location", + "//common/annotations", + "//common/internal", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "cel_source_helper_android", + srcs = ["CelSourceHelper.java"], + deps = [ + ":source_location_android", + "//common/annotations", + "//common/internal:internal_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "cel_ast", + srcs = ["CelAbstractSyntaxTree.java"], + tags = [ + ], + deps = [ + ":cel_source", + "//:auto_value", + "//common/annotations", + "//common/ast", + "//common/types", + "//common/types:type_providers", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "cel_ast_android", + srcs = ["CelAbstractSyntaxTree.java"], + tags = [ + ], + deps = [ + ":cel_source_android", + "//:auto_value", + "//common/annotations", + "//common/ast:ast_android", + "//common/types:type_providers_android", + "//common/types:types_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "source", + srcs = SOURCE_SOURCES, + tags = [ + ], + deps = [ + "//common/annotations", + "//common/internal", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "source_android", + srcs = SOURCE_SOURCES, + visibility = ["//visibility:private"], + deps = [ + "//common/annotations", + "//common/internal:internal_android", + "@maven_android//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "source_location_android", + srcs = ["CelSourceLocation.java"], + visibility = ["//visibility:private"], + deps = [ + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "container", + srcs = ["CelContainer.java"], + tags = [ + ], + deps = [ + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "operator", + srcs = ["Operator.java"], + tags = [ + ], + deps = ["@maven//:com_google_guava_guava"], +) + +cel_android_library( + name = "operator_android", + srcs = ["Operator.java"], + tags = [ + ], + deps = ["@maven_android//:com_google_guava_guava"], +) diff --git a/common/src/main/java/dev/cel/common/CelAbstractSyntaxTree.java b/common/src/main/java/dev/cel/common/CelAbstractSyntaxTree.java new file mode 100644 index 000000000..b79c67e79 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelAbstractSyntaxTree.java @@ -0,0 +1,139 @@ +// Copyright 2022 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; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelReference; +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Optional; + +/** + * Represents a checked or unchecked expression, its source, and related metadata such as source + * position information. + * + *

Note: Use {@link CelProtoAbstractSyntaxTree} if you need access to the protobuf equivalent + * ASTs, such as ParsedExpr and CheckedExpr from syntax.proto or checked.proto. + */ +@AutoValue +@Immutable +public abstract class CelAbstractSyntaxTree { + + abstract CelSource celSource(); + + abstract CelExpr celExpr(); + + abstract ImmutableMap references(); + + abstract ImmutableMap types(); + + /** + * Constructs a new instance of CelAbstractSyntaxTree that represent a parsed expression. + * + *

Note that ASTs should not be manually constructed except for special circumstances such as + * validating or optimizing an AST. + */ + public static CelAbstractSyntaxTree newParsedAst(CelExpr celExpr, CelSource celSource) { + return new AutoValue_CelAbstractSyntaxTree( + celSource, celExpr, ImmutableMap.of(), ImmutableMap.of()); + } + + /** + * Constructs a new instance of CelAbstractSyntaxTree that represent a checked expression. + * + *

CEL Library Internals. Do not construct a type-checked AST by hand. Use a CelCompiler to + * type-check a parsed AST instead. + */ + @Internal + public static CelAbstractSyntaxTree newCheckedAst( + CelExpr celExpr, + CelSource celSource, + Map references, + Map types) { + return new AutoValue_CelAbstractSyntaxTree( + celSource, celExpr, ImmutableMap.copyOf(references), ImmutableMap.copyOf(types)); + } + + /** Returns the underlying {@link CelExpr} representation of the abstract syntax tree. */ + public CelExpr getExpr() { + return celExpr(); + } + + /** Tests whether the underlying abstract syntax tree has been type checked or not. */ + public boolean isChecked() { + return !types().isEmpty(); + } + + /** + * For a type checked abstract syntax tree the resulting type is returned. Otherwise, the dynamic + * type is returned. + */ + public CelType getResultType() { + return isChecked() ? getType(getExpr().id()).get() : SimpleType.DYN; + } + + /** + * Returns the {@link CelSource} that was used during construction of the abstract syntax tree. + */ + public CelSource getSource() { + return celSource(); + } + + public Optional getType(long exprId) { + return Optional.ofNullable(types().get(exprId)); + } + + public CelType getTypeOrThrow(long exprId) { + return getType(exprId) + .orElseThrow(() -> new NoSuchElementException("Type not found for expr id: " + exprId)); + } + + public ImmutableMap getTypeMap() { + return types(); + } + + public Optional getReference(long exprId) { + return Optional.ofNullable(references().get(exprId)); + } + + public ImmutableMap getReferenceMap() { + return references(); + } + + public CelReference getReferenceOrThrow(long exprId) { + return getReference(exprId) + .orElseThrow(() -> new NoSuchElementException("Expr Id not found: " + exprId)); + } + + Optional findEnumValue(long exprId) { + CelReference ref = references().get(exprId); + return ref != null ? ref.value() : Optional.empty(); + } + + Optional> findOverloadIDs(long exprId) { + CelReference ref = references().get(exprId); + return ref != null && !ref.value().isPresent() + ? Optional.of(ref.overloadIds()) + : Optional.empty(); + } +} diff --git a/common/src/main/java/dev/cel/common/CelContainer.java b/common/src/main/java/dev/cel/common/CelContainer.java new file mode 100644 index 000000000..0ca566fac --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelContainer.java @@ -0,0 +1,349 @@ +// Copyright 2025 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; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableMap.toImmutableMap; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.LinkedHashMap; +import java.util.Locale; +import java.util.Map; +import java.util.Optional; + +/** CelContainer holds a reference to an optional qualified container name and set of aliases. */ +@AutoValue +@Immutable +public abstract class CelContainer { + + public abstract String name(); + + abstract ImmutableMap aliasMap(); + + /** + * Returns the aliases configured in the container. + * + *

The key of the map is the alias and the value is the corresponding fully qualified name. + */ + public ImmutableMap aliases() { + return aliasMap().entrySet().stream() + .filter(e -> e.getValue().kind().equals(AliasKind.ALIAS)) + .collect(toImmutableMap(Map.Entry::getKey, e -> e.getValue().qualifiedName())); + } + + public ImmutableList abbreviations() { + return aliasMap().entrySet().stream() + .filter(e -> e.getValue().kind().equals(AliasKind.ABBREVIATION)) + .map(e -> e.getValue().qualifiedName()) + .collect(toImmutableList()); + } + + /** Builder for {@link CelContainer} */ + @AutoValue.Builder + public abstract static class Builder { + + private final LinkedHashMap aliasMap = new LinkedHashMap<>(); + + abstract String name(); + + /** Sets the fully-qualified name of the container. */ + public abstract Builder setName(String name); + + abstract Builder setAliasMap(ImmutableMap aliasMap); + + /** See {@link #addAbbreviations(ImmutableSet)} for documentation. */ + @CanIgnoreReturnValue + public Builder addAbbreviations(String... qualifiedNames) { + Preconditions.checkNotNull(qualifiedNames); + return addAbbreviations(ImmutableSet.copyOf(qualifiedNames)); + } + + /** + * Configures a set of simple names as abbreviations for fully-qualified names. + * + *

An abbreviation is a simple name that expands to a fully-qualified name. Abbreviations can + * be useful when working with variables, functions, and especially types from multiple + * namespaces: + * + * 

{@code
+     * // CEL object construction
+     * qual.pkg.version.ObjTypeName{
+     *   field: alt.container.ver.FieldTypeName{value: ...}
+     * }
+     * }
+ * + *

Only one the qualified names above may be used as the CEL container, so at least one of + * these references must be a long qualified name within an otherwise short CEL program. Using + * the following abbreviations, the program becomes much simpler: + * + * 

{@code
+     * // CEL Java option
+     * CelContainer.newBuilder().addAbbreviations("qual.pkg.version.ObjTypeName", "alt.container.ver.FieldTypeName").build()
+     * }
+     * {@code
+     * // Simplified Object construction
+     * ObjTypeName{field: FieldTypeName{value: ...}}
+     * }
+ * + *

There are a few rules for the qualified names and the simple abbreviations generated from + * them: + * + *

    + *
  • Qualified names must be dot-delimited, e.g. `package.subpkg.name`. + *
  • The last element in the qualified name is the abbreviation. + *
  • Abbreviations must not collide with each other. + *
  • The abbreviation must not collide with unqualified names in use. + *
+ * + *

Abbreviations are distinct from container-based references in the following important + * ways: + * + *

    + *
  • Abbreviations must expand to a fully-qualified name. + *
  • Expanded abbreviations do not participate in namespace resolution. + *
  • Abbreviation expansion is done instead of the container search for a matching + * identifier. + *
  • Containers follow C++ namespace resolution rules with searches from the most qualified + * name to the least qualified name. + *
  • Container references within the CEL program may be relative, and are resolved to fully + * qualified names at either type-check time or program plan time, whichever comes first. + *
+ * + *

If there is ever a case where an identifier could be in both the container and as an + * abbreviation, the abbreviation wins as this will ensure that the meaning of a program is + * preserved between compilations even as the container evolves. + * + * @throws IllegalArgumentException If qualifiedName is invalid per above specification. + */ + @CanIgnoreReturnValue + public Builder addAbbreviations(ImmutableSet qualifiedNames) { + for (String qualifiedName : qualifiedNames) { + qualifiedName = qualifiedName.trim(); + for (int i = 0; i < qualifiedName.length(); i++) { + if (!isIdentifierChar(qualifiedName.charAt(i))) { + throw new IllegalArgumentException( + String.format( + "invalid qualified name: %s, wanted name of the form 'qualified.name'", + qualifiedName)); + } + } + + int index = qualifiedName.lastIndexOf("."); + if (index <= 0 || index >= qualifiedName.length() - 1) { + throw new IllegalArgumentException( + String.format( + "invalid qualified name: %s, wanted name of the form 'qualified.name'", + qualifiedName)); + } + + String alias = qualifiedName.substring(index + 1); + aliasAs(AliasKind.ABBREVIATION, qualifiedName, alias); + } + + return this; + } + + /** + * Alias associates a fully-qualified name with a user-defined alias. + * + *

In general, {@link #addAbbreviations} is preferred to aliasing since the names generated + * from the Abbrevs option are more easily traced back to source code. Aliasing is useful for + * propagating alias configuration from one container instance to another, and may also be + * useful for remapping poorly chosen protobuf message / package names. + * + *

Note: all the rules that apply to abbreviations also apply to aliasing. + * + *

Note: It is also possible to alias a top-level package or a name that does not contain a + * period. When resolving an identifier, CEL checks for variables and functions before + * attempting to expand aliases for type resolution. Therefore, if an expression consists solely + * of an identifier that matches both an alias and a declared variable (e.g., {@code + * short_alias}), the variable will take precedence and the compilation will succeed. The alias + * expansion will only be used when the alias is a prefix to a longer name (e.g., {@code + * short_alias.TestRequest}) or if no variable with the same name exists, in which case using + * the alias as a standalone identifier will likely result in a compilation error. + * + * @param alias Simple name to be expanded. Must be a valid identifier. + * @param qualifiedName The fully qualified name to expand to. This may be a simple name (e.g. a + * package name) but it must be a valid identifier. + */ + @CanIgnoreReturnValue + public Builder addAlias(String alias, String qualifiedName) { + aliasAs(AliasKind.ALIAS, qualifiedName, alias); + return this; + } + + private void aliasAs(AliasKind kind, String qualifiedName, String alias) { + validateAliasOrThrow(kind, qualifiedName, alias); + aliasMap.put(alias, AliasEntry.create(kind, qualifiedName)); + } + + private void validateAliasOrThrow(AliasKind kind, String qualifiedName, String alias) { + if (alias.isEmpty() || alias.contains(".")) { + throw new IllegalArgumentException( + String.format( + "%s must be non-empty and simple (not qualified): %s=%s", kind, kind, alias)); + } + + if (qualifiedName.charAt(0) == '.') { + throw new IllegalArgumentException( + String.format("qualified name must not begin with a leading '.': %s", qualifiedName)); + } + + AliasEntry aliasRef = aliasMap.get(alias); + if (aliasRef != null) { + throw new IllegalArgumentException( + String.format( + "%s collides with existing reference: name=%s, %s=%s, existing=%s", + kind, qualifiedName, kind, alias, aliasRef.qualifiedName())); + } + + String containerName = name(); + if (containerName.startsWith(alias + ".") || containerName.equals(alias)) { + throw new IllegalArgumentException( + String.format( + "%s collides with container name: name=%s, %s=%s, container=%s", + kind, qualifiedName, kind, alias, containerName)); + } + } + + abstract CelContainer autoBuild(); + + @CheckReturnValue + public CelContainer build() { + setAliasMap(ImmutableMap.copyOf(aliasMap)); + return autoBuild(); + } + } + + /** + * Returns the candidates name of namespaced identifiers in C++ resolution order. + * + *

Names which shadow other names are returned first. If a name includes a leading dot ('.'), + * the name is treated as an absolute identifier which cannot be shadowed. + * + *

Given a container name a.b.c.M.N and a type name R.s, this will deliver in order: + * + *

    + *
  • a.b.c.M.N.R.s + *
  • a.b.c.M.R.s + *
  • a.b.c.R.s + *
  • a.b.R.s + *
  • a.R.s + *
  • R.s + *
+ * + *

If aliases or abbreviations are configured for the container, then alias names will take + * precedence over containerized names. + */ + public ImmutableSet resolveCandidateNames(String typeName) { + if (typeName.startsWith(".")) { + String qualifiedName = typeName.substring(1); + String alias = findAlias(qualifiedName).orElse(qualifiedName); + + return ImmutableSet.of(alias); + } + + String alias = findAlias(typeName).orElse(null); + if (alias != null) { + return ImmutableSet.of(alias); + } + + if (name().isEmpty()) { + return ImmutableSet.of(typeName); + } + + String nextContainer = name(); + ImmutableSet.Builder candidates = + ImmutableSet.builder().add(nextContainer + "." + typeName); + for (int i = nextContainer.lastIndexOf("."); i >= 0; i = nextContainer.lastIndexOf(".")) { + nextContainer = nextContainer.substring(0, i); + candidates.add(nextContainer + "." + typeName); + } + + return candidates.add(typeName).build(); + } + + abstract Builder autoToBuilder(); + + public Builder toBuilder() { + Builder builder = autoToBuilder(); + builder.aliasMap.putAll(aliasMap()); + return builder; + } + + public static Builder newBuilder() { + return new AutoValue_CelContainer.Builder().setName(""); + } + + public static CelContainer ofName(String containerName) { + return newBuilder().setName(containerName).build(); + } + + private Optional findAlias(String name) { + // If an alias exists for the name, ensure it is searched last. + String simple = name; + String qualifier = ""; + int dot = name.indexOf("."); + if (dot > 0) { + simple = name.substring(0, dot); + qualifier = name.substring(dot); + } + AliasEntry alias = aliasMap().get(simple); + if (alias == null) { + return Optional.empty(); + } + + return Optional.of(alias.qualifiedName() + qualifier); + } + + private static boolean isIdentifierChar(int r) { + if (r > 127) { + // Not ASCII + return false; + } + + return r == '.' || r == '_' || Character.isLetter(r) || Character.isDigit(r); + } + + enum AliasKind { + ALIAS, + ABBREVIATION; + + @Override + public String toString() { + return this.name().toLowerCase(Locale.getDefault()); + } + } + + /** Represents an alias or abbreviation. */ + @AutoValue + @Immutable + abstract static class AliasEntry { + static AliasEntry create(AliasKind kind, String qualifiedName) { + return new AutoValue_CelContainer_AliasEntry(kind, qualifiedName); + } + + abstract AliasKind kind(); + + abstract String qualifiedName(); + } +} diff --git a/common/src/main/java/dev/cel/common/CelDescriptorUtil.java b/common/src/main/java/dev/cel/common/CelDescriptorUtil.java new file mode 100644 index 000000000..7695e96d8 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelDescriptorUtil.java @@ -0,0 +1,246 @@ +// Copyright 2022 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; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.FileDescriptorSetConverter; +import dev.cel.common.types.CelTypes; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +/** + * Utility class for working with protobuf descriptors. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class CelDescriptorUtil { + + private CelDescriptorUtil() {} + + /** + * Get the full {@code FileDescriptor} set needed to accurately instantiate the {@code + * descriptors}. + */ + public static ImmutableSet getFileDescriptorsForDescriptors( + Iterable descriptors) { + ImmutableSet.Builder fileDescriptors = ImmutableSet.builder(); + descriptors.forEach(d -> fileDescriptors.add(d.getFile())); + return getFileDescriptorsAndDependencies(fileDescriptors.build()); + } + + /** + * Convert a {@code FileDescriptorSet} into a set of {@code FileDescriptor} instances. + * + *

Warning: This will produce unique FileDescriptor instances. Use with care especially in + * hermetic environments. + */ + public static ImmutableSet getFileDescriptorsFromFileDescriptorSet( + FileDescriptorSet fileDescriptorSet) { + return FileDescriptorSetConverter.convert(fileDescriptorSet); + } + + /** + * Extract the full message {@code CelDescriptors} set from the input set of {@code + * fileDescriptors}. All message type, enum, extension and file descriptors will be extracted. + * + *

Note, the input {@code fileDescriptors} set will be expanded to the complete set of + * dependencies needed to describe the types within the provided files. + */ + public static CelDescriptors getAllDescriptorsFromFileDescriptor( + FileDescriptor... fileDescriptors) { + return getAllDescriptorsFromFileDescriptor(Arrays.asList(fileDescriptors)); + } + + /** + * Extract the full message {@code CelDescriptors} set from the input set of {@code + * fileDescriptors}. All message type, enum, extension and file descriptors will be extracted. + * + *

Note, the input {@code fileDescriptors} set will be expanded to the complete set of + * dependencies needed to describe the types within the provided files. + */ + public static CelDescriptors getAllDescriptorsFromFileDescriptor( + Iterable fileDescriptors) { + return getAllDescriptorsFromFileDescriptor(fileDescriptors, true); + } + + /** + * Extract the full message {@code FileDescriptor} set from the input set of {@code + * fileDescriptors}. All message type, enum, extension and file descriptors will be extracted. + * + * @param resolveTypeDependencies Performs a deep type dependency resolution by expanding all the + * FileDescriptors marked as dependents listed in their imports (Ex: If FileDescriptor A + * imports on FileDescriptor B, FD B's descriptors will be pulled in). Setting false will + * disable this. + */ + public static CelDescriptors getAllDescriptorsFromFileDescriptor( + Iterable fileDescriptors, boolean resolveTypeDependencies) { + ImmutableSet allFileDescriptors = + resolveTypeDependencies + ? getFileDescriptorsAndDependencies(fileDescriptors) + : ImmutableSet.copyOf(fileDescriptors); + + CelDescriptors.Builder celDescriptorsBuilder = CelDescriptors.builder(); + allFileDescriptors.forEach( + fd -> collectAllDescriptorsFromFileDescriptor(fd, celDescriptorsBuilder)); + + return celDescriptorsBuilder.build(); + } + + /** + * Collects all descriptors referenced by the {@code FileDescriptor}, including message types, + * enums and extensions. + */ + private static void collectAllDescriptorsFromFileDescriptor( + FileDescriptor fileDescriptor, CelDescriptors.Builder celDescriptors) { + celDescriptors.addFileDescriptors(fileDescriptor); + + collectEnumDescriptors(fileDescriptor, celDescriptors); + collectMessageTypeDescriptors(fileDescriptor, celDescriptors); + collectExtensions(fileDescriptor, celDescriptors); + } + + private static void collectEnumDescriptors( + FileDescriptor fileDescriptor, CelDescriptors.Builder celDescriptors) { + Set visitedDescriptors = new HashSet<>(); + celDescriptors.addEnumDescriptors(fileDescriptor.getEnumTypes()); + fileDescriptor + .getMessageTypes() + .forEach(d -> collectEnumDescriptors(d, visitedDescriptors, celDescriptors)); + fileDescriptor.getExtensions().forEach(ext -> collectEnumDescriptors(ext, celDescriptors)); + } + + private static void collectEnumDescriptors( + Descriptor descriptor, + Set visitedDescriptors, + CelDescriptors.Builder celDescriptors) { + if (visitedDescriptors.contains(descriptor.getFullName())) { + return; + } + visitedDescriptors.add(descriptor.getFullName()); + celDescriptors.addEnumDescriptors(descriptor.getEnumTypes()); + + descriptor.getFields().forEach(field -> collectEnumDescriptors(field, celDescriptors)); + descriptor + .getNestedTypes() + .forEach(nested -> collectEnumDescriptors(nested, visitedDescriptors, celDescriptors)); + } + + private static void collectEnumDescriptors( + FieldDescriptor fieldDescriptor, CelDescriptors.Builder celDescriptors) { + if (!fieldDescriptor.getType().equals(FieldDescriptor.Type.ENUM)) { + return; + } + celDescriptors.addEnumDescriptors(fieldDescriptor.getEnumType()); + } + + private static void collectMessageTypeDescriptors( + FileDescriptor descriptor, CelDescriptors.Builder celDescriptors) { + Set visited = new HashSet<>(); + descriptor + .getMessageTypes() + .forEach((d) -> collectMessageTypeDescriptors(d, visited, celDescriptors)); + } + + private static void collectMessageTypeDescriptors( + Descriptor descriptor, Set visited, CelDescriptors.Builder celDescriptors) { + String messageName = descriptor.getFullName(); + if (visited.contains(messageName)) { + return; + } + + if (!descriptor.getOptions().getMapEntry()) { + visited.add(messageName); + celDescriptors.addMessageTypeDescriptors(descriptor); + } + + if (CelTypes.getWellKnownCelType(messageName).isPresent()) { + return; + } + + descriptor + .getNestedTypes() + .forEach(nested -> collectMessageTypeDescriptors(nested, visited, celDescriptors)); + descriptor + .getFields() + .forEach(field -> collectFieldDescriptors(field, visited, celDescriptors)); + + celDescriptors.addExtensionDescriptors(descriptor.getExtensions()); + } + + private static void collectExtensions( + FileDescriptor fileDescriptor, CelDescriptors.Builder celDescriptors) { + celDescriptors.addExtensionDescriptors(fileDescriptor.getExtensions()); + Set visited = new HashSet<>(); + fileDescriptor + .getExtensions() + .forEach((d) -> collectFieldDescriptors(d, visited, celDescriptors)); + } + + /** + * Enumerates all message types in a field descriptor. This is used for handling nested type + * entries within a message. + */ + private static void collectFieldDescriptors( + FieldDescriptor fieldDescriptor, Set visited, CelDescriptors.Builder celDescriptors) { + if (!fieldDescriptor.getType().equals(FieldDescriptor.Type.MESSAGE)) { + return; + } + Descriptor fieldMessageType = fieldDescriptor.getMessageType(); + if (fieldDescriptor.isMapField()) { + FieldDescriptor valueDescriptor = fieldDescriptor.getMessageType().getFields().get(1); + if (valueDescriptor.getType().equals(FieldDescriptor.Type.MESSAGE)) { + collectMessageTypeDescriptors(valueDescriptor.getMessageType(), visited, celDescriptors); + } + } else { + collectMessageTypeDescriptors(fieldMessageType, visited, celDescriptors); + } + } + + /** + * Get the full {@code FileDescriptor} set needed by the referenced {@code fileDescriptors}. + * + *

If the {@code FileDescriptor} is provided which contains the {@code AttributeContext} + * message definition, then the expanded {@code FileDescriptor} set should also include the files + * defining {@code Duration}, {@code Timestamp}, and {@code Struct}. + */ + private static ImmutableSet getFileDescriptorsAndDependencies( + Iterable fileDescriptors) { + Set visited = new HashSet<>(); + ImmutableSet.Builder expandedFileDescriptors = ImmutableSet.builder(); + ImmutableSet.copyOf(fileDescriptors) + .forEach((fd) -> copyToFileDescriptorSet(visited, fd, expandedFileDescriptors)); + return expandedFileDescriptors.build(); + } + + private static void copyToFileDescriptorSet( + Set visited, FileDescriptor fd, ImmutableSet.Builder files) { + if (visited.contains(fd.getFullName())) { + return; + } + + visited.add(fd.getFullName()); + for (FileDescriptor dep : fd.getDependencies()) { + copyToFileDescriptorSet(visited, dep, files); + } + files.add(fd); + } +} diff --git a/common/src/main/java/dev/cel/common/CelDescriptors.java b/common/src/main/java/dev/cel/common/CelDescriptors.java new file mode 100644 index 000000000..95eccf115 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelDescriptors.java @@ -0,0 +1,115 @@ +// Copyright 2022 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; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableMultimap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.EnumDescriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import java.util.Arrays; + +/** Value object containing multiple set of descriptors to be provided into the CEL environment. */ +@AutoValue +public abstract class CelDescriptors { + + /** Descriptors of type loaded from {@link FileDescriptor#getMessageTypes()}. */ + public abstract ImmutableSet messageTypeDescriptors(); + + public abstract ImmutableSet enumDescriptors(); + + /** + * Set of field descriptors that are part of a descriptor's extensions. Key: Containing type's + * full name, Value: Extension's field descriptors + */ + public abstract ImmutableMultimap extensionDescriptors(); + + /** File descriptors that were used to load the message type, enum descriptors and extensions. */ + public abstract ImmutableSet fileDescriptors(); + + public static Builder builder() { + return new AutoValue_CelDescriptors.Builder(); + } + + /** Builder for configuring the CelDescriptors */ + @AutoValue.Builder + public abstract static class Builder { + + abstract Builder setMessageTypeDescriptors(ImmutableSet value); + + abstract Builder setEnumDescriptors(ImmutableSet value); + + abstract Builder setExtensionDescriptors(ImmutableMultimap value); + + abstract Builder setFileDescriptors(ImmutableSet value); + + protected abstract ImmutableSet.Builder messageTypeDescriptorsBuilder(); + + protected abstract ImmutableSet.Builder enumDescriptorsBuilder(); + + protected abstract ImmutableMultimap.Builder + extensionDescriptorsBuilder(); + + protected abstract ImmutableSet.Builder fileDescriptorsBuilder(); + + public abstract CelDescriptors build(); + + @CanIgnoreReturnValue + final Builder addMessageTypeDescriptors(Descriptor... descriptors) { + addMessageTypeDescriptors(Arrays.asList(descriptors)); + return this; + } + + @CanIgnoreReturnValue + final Builder addMessageTypeDescriptors(Iterable descriptors) { + messageTypeDescriptorsBuilder().addAll(descriptors); + return this; + } + + @CanIgnoreReturnValue + final Builder addEnumDescriptors(EnumDescriptor... enumDescriptors) { + addEnumDescriptors(Arrays.asList(enumDescriptors)); + return this; + } + + @CanIgnoreReturnValue + final Builder addEnumDescriptors(Iterable enumDescriptors) { + enumDescriptorsBuilder().addAll(enumDescriptors); + return this; + } + + @CanIgnoreReturnValue + final Builder addExtensionDescriptors(Iterable extensionDescriptors) { + extensionDescriptors.forEach( + d -> extensionDescriptorsBuilder().put(d.getContainingType().getFullName(), d)); + return this; + } + + @CanIgnoreReturnValue + final Builder addFileDescriptors(FileDescriptor... fileDescriptors) { + addFileDescriptors(Arrays.asList(fileDescriptors)); + return this; + } + + @CanIgnoreReturnValue + final Builder addFileDescriptors(Iterable fileDescriptors) { + fileDescriptorsBuilder().addAll(fileDescriptors); + return this; + } + } +} diff --git a/common/src/main/java/dev/cel/common/CelErrorCode.java b/common/src/main/java/dev/cel/common/CelErrorCode.java new file mode 100644 index 000000000..65e46097f --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelErrorCode.java @@ -0,0 +1,49 @@ +// Copyright 2023 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; + +/** The canonical error codes for CEL */ +public enum CelErrorCode { + /** + * CEL encountered an unexpected error. This can range from CEL encountering impossible states, a + * failure with dependency or the exact cause of the error is otherwise unknown. + */ + INTERNAL_ERROR, + /** Map or object access using an unknown attribute. */ + ATTRIBUTE_NOT_FOUND, + /** List index is out of bounds. */ + INDEX_OUT_OF_BOUNDS, + /** Division by zero, also reported for modulus operations. */ + DIVIDE_BY_ZERO, + /** Map or object construction supplies same key value more than once. */ + DUPLICATE_ATTRIBUTE, + /** Invalid argument supplied to a function. */ + INVALID_ARGUMENT, + /** Function defined, but no matching overload found. */ + OVERLOAD_NOT_FOUND, + /** Multiple matching overloads found. */ + AMBIGUOUS_OVERLOAD, + /** Type definition could not be found. */ + TYPE_NOT_FOUND, + /** Numeric overflow occurred due to arithmetic or conversions outside represented range. */ + NUMERIC_OVERFLOW, + /** + * Evaluation halted due to reaching the max number of iterations permitted within comprehension + * loops. + */ + ITERATION_BUDGET_EXCEEDED, + /** Conversion failed due to a mismatch in format specification. */ + BAD_FORMAT +} diff --git a/common/src/main/java/dev/cel/common/CelException.java b/common/src/main/java/dev/cel/common/CelException.java new file mode 100644 index 000000000..55c8623a4 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelException.java @@ -0,0 +1,38 @@ +// Copyright 2022 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; + +/** Base class for all checked exceptions explicitly thrown by the library. */ +public abstract class CelException extends Exception { + // By default, unclassified errors are "internal errors". + private CelErrorCode errorCode = CelErrorCode.INTERNAL_ERROR; + + public CelException(String message) { + super(message); + } + + public CelException(String message, Throwable cause) { + super(message, cause); + } + + public CelException(String message, Throwable cause, CelErrorCode errorCode) { + super(message, cause); + this.errorCode = errorCode; + } + + public CelErrorCode getErrorCode() { + return errorCode; + } +} diff --git a/common/src/main/java/dev/cel/common/CelFunctionDecl.java b/common/src/main/java/dev/cel/common/CelFunctionDecl.java new file mode 100644 index 000000000..12beb53d7 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelFunctionDecl.java @@ -0,0 +1,108 @@ +// Copyright 2022 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; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; + +import dev.cel.expr.Decl; +import dev.cel.expr.Decl.FunctionDecl; +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import java.util.Arrays; + +/** Abstract representation of a CEL Function declaration. */ +@AutoValue +@Immutable +public abstract class CelFunctionDecl { + + /** Fully qualified name of the function. */ + public abstract String name(); + + /** Required. List of function overloads. Must contain at least one overload. */ + public abstract ImmutableSet overloads(); + + /** Builder for configuring the {@link CelFunctionDecl}. */ + @AutoValue.Builder + public abstract static class Builder { + public abstract String name(); + + /** Sets the function name {@link #name()} */ + public abstract Builder setName(String name); + + public abstract ImmutableSet overloads(); + + public abstract ImmutableSet.Builder overloadsBuilder(); + + @CanIgnoreReturnValue + public abstract Builder setOverloads(ImmutableSet overloads); + + /** Adds one or more function overloads */ + @CanIgnoreReturnValue + public Builder addOverloads(CelOverloadDecl... overloads) { + checkNotNull(overloads); + return addOverloads(Arrays.asList(overloads)); + } + + /** Adds a collection of overloads */ + @CanIgnoreReturnValue + public Builder addOverloads(Iterable overloads) { + checkNotNull(overloads); + this.overloadsBuilder().addAll(overloads); + return this; + } + + /** Builds a new instance of {@link CelFunctionDecl} */ + @CheckReturnValue + public abstract CelFunctionDecl build(); + } + + public abstract Builder toBuilder(); + + /** Create a new builder to construct a {@code CelFunctionDecl} instance. */ + public static Builder newBuilder() { + return new AutoValue_CelFunctionDecl.Builder().setOverloads(ImmutableSet.of()); + } + + /** Constructs a function declaration with any number of {@link CelOverloadDecl} */ + public static CelFunctionDecl newFunctionDeclaration( + String functionName, CelOverloadDecl... overloads) { + return newFunctionDeclaration(functionName, Arrays.asList(overloads)); + } + + /** Constructs a function declaration with an iterable of {@link CelOverloadDecl} */ + public static CelFunctionDecl newFunctionDeclaration( + String functionName, Iterable overloads) { + return CelFunctionDecl.newBuilder().setName(functionName).addOverloads(overloads).build(); + } + + /** Converts a {@link CelFunctionDecl} to a protobuf equivalent form {@link FunctionDecl} */ + @Internal + public static Decl celFunctionDeclToDecl(CelFunctionDecl celFunctionDecl) { + return Decl.newBuilder() + .setName(celFunctionDecl.name()) + .setFunction( + FunctionDecl.newBuilder() + .addAllOverloads( + celFunctionDecl.overloads().stream() + .map(CelOverloadDecl::celOverloadToOverload) + .collect(toImmutableList()))) + .build(); + } +} diff --git a/common/src/main/java/dev/cel/common/CelIssue.java b/common/src/main/java/dev/cel/common/CelIssue.java new file mode 100644 index 000000000..4de369470 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelIssue.java @@ -0,0 +1,157 @@ +// Copyright 2022 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; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Joiner; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.internal.SafeStringFormatter; +import java.util.Collection; +import java.util.Optional; +import java.util.PrimitiveIterator; + +/** + * Encapulates a {@link CelSourceLocation} and message representing an error within an expression. + */ +@AutoValue +@Immutable +@SuppressWarnings("UnicodeEscape") // Suppressed to distinguish half-width and full-width chars. +public abstract class CelIssue { + private static final Joiner JOINER = Joiner.on('\n'); + + /** Severity of a CelIssue. */ + public enum Severity { + ERROR, + WARNING, + INFORMATION, + DEPRECATED; + } + + // Package-private default constructor to prevent unexpected extensions outside of this codebase. + CelIssue() {} + + public abstract Severity getSeverity(); + + public abstract CelSourceLocation getSourceLocation(); + + public abstract String getMessage(); + + public abstract long getExprId(); + + public static Builder newBuilder() { + return new AutoValue_CelIssue.Builder(); + } + + /** + * Build {@link CelIssue} from the given expression id, {@link CelSourceLocation}, format string, + * and arguments. + */ + public static CelIssue formatError( + long exprId, CelSourceLocation sourceLocation, String message) { + return newBuilder() + .setExprId(exprId) + .setSeverity(Severity.ERROR) + .setSourceLocation(sourceLocation) + .setMessage(message) + .build(); + } + + /** + * Build {@link CelIssue} from the given {@link CelSourceLocation}, format string, and arguments. + */ + public static CelIssue formatError(CelSourceLocation sourceLocation, String message) { + return formatError(0L, sourceLocation, message); + } + + /** Build {@link CelIssue} from the given line, column, format string, and arguments. */ + public static CelIssue formatError(int line, int column, String message) { + return formatError(CelSourceLocation.of(line, column), message); + } + + // Halfwidth '.' and '^'. + private static final char DOT = '\u002e'; + private static final char HAT = '\u005e'; + // Fullwidth '.' and '^'. + private static final char WIDE_DOT = '\uff0e'; + private static final char WIDE_HAT = '\uff3e'; + + /** Returns a human-readable error with all issues joined in a single string. */ + public static String toDisplayString(Collection issues, Source source) { + return JOINER.join( + issues.stream().map(iss -> iss.toDisplayString(source)).collect(toImmutableList())); + } + + /** Returns a string representing this error that is suitable for displaying to humans. */ + public String toDisplayString(Source source) { + // Based onhttps://github.com/google/cel-go/blob/v0.5.1/common/error.go#L42. + String result = + SafeStringFormatter.format( + "%s: %s:%d:%d: %s", + getSeverity(), + source.getDescription(), + getSourceLocation().getLine(), + getSourceLocation().getColumn() + 1, + getMessage()); + if (!CelSourceLocation.NONE.equals(getSourceLocation())) { + Optional optionalSnippet = source.getSnippet(getSourceLocation().getLine()); + if (optionalSnippet.isPresent()) { + StringBuilder builder = new StringBuilder(); + String snippet = optionalSnippet.get().replace('\t', ' '); + builder.append(result).append("\n | ").append(snippet).append("\n | "); + PrimitiveIterator.OfInt codePoints = snippet.codePoints().iterator(); + for (int index = 0; + index < getSourceLocation().getColumn() && codePoints.hasNext(); + index++) { + int codePoint = codePoints.nextInt(); + if (codePoint > 0x7f) { + // We make a naive assumption that all characters above 0xff are fullwidth. + // Unfortunately, + // as of Java 8, there is nothing in the Character class to determine width. + builder.append(WIDE_DOT); + } else { + builder.append(DOT); + } + } + if (codePoints.hasNext() && codePoints.nextInt() > 0x7f) { + // See above. + builder.append(WIDE_HAT); + } else { + builder.append(HAT); + } + result = builder.toString(); + } + } + return result; + } + + /** Builder for configuring {@link CelIssue}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setSeverity(Severity severity); + + public abstract Builder setSourceLocation(CelSourceLocation location); + + public abstract Builder setMessage(String message); + + public abstract Builder setExprId(long exprId); + + @CheckReturnValue + public abstract CelIssue build(); + } +} diff --git a/common/src/main/java/dev/cel/common/CelMutableAst.java b/common/src/main/java/dev/cel/common/CelMutableAst.java new file mode 100644 index 000000000..dd57d8b4e --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelMutableAst.java @@ -0,0 +1,122 @@ +// Copyright 2024 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; + +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExprConverter; +import dev.cel.common.ast.CelReference; +import dev.cel.common.types.CelType; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** + * An abstract representation of CEL Abstract Syntax tree that allows mutation in any of its + * properties. This class is semantically the same as that of the immutable {@link + * CelAbstractSyntaxTree}. + * + *

This should only be used within optimizers to augment an AST. + */ +public final class CelMutableAst { + private final CelMutableExpr mutatedExpr; + private final CelMutableSource source; + private final Map references; + private final Map types; + + /** Returns the underlying {@link CelMutableExpr} representation of the abstract syntax tree. */ + public CelMutableExpr expr() { + return mutatedExpr; + } + + /** + * Returns the {@link CelMutableSource} that was used during construction of the abstract syntax + * tree. + */ + public CelMutableSource source() { + return source; + } + + /** + * Returns the resolved reference to a declaration at expression ID for a type-checked AST. + * + * @return Optional of {@link CelReference} or {@link Optional#empty} if the reference does not + * exist at the ID. + */ + public Optional getReference(long exprId) { + return Optional.ofNullable(references.get(exprId)); + } + + /** + * Returns the type of the expression node for a type-checked AST. + * + * @return Optional of {@link CelType} or {@link Optional#empty} if the type does not exist at the + * ID. + */ + public Optional getType(long exprId) { + return Optional.ofNullable(types.get(exprId)); + } + + /** Converts this mutable AST into a parsed {@link CelAbstractSyntaxTree}. */ + public CelAbstractSyntaxTree toParsedAst() { + return toParsedAst(false); + } + + /** + * Converts this mutable AST into a parsed {@link CelAbstractSyntaxTree}. + * + * @param retainSourcePositions If true, the source positions (line offsets, code points) will be + * retained in the resulting AST. If false, they will be scrubbed. + */ + public CelAbstractSyntaxTree toParsedAst(boolean retainSourcePositions) { + return CelAbstractSyntaxTree.newParsedAst( + CelMutableExprConverter.fromMutableExpr(mutatedExpr), + source.toCelSource(retainSourcePositions)); + } + + /** + * Constructs an instance of {@link CelMutableAst} with the incoming {@link + * CelAbstractSyntaxTree}. + */ + public static CelMutableAst fromCelAst(CelAbstractSyntaxTree ast) { + return new CelMutableAst( + CelMutableExprConverter.fromCelExpr(ast.getExpr()), + CelMutableSource.fromCelSource(ast.getSource()), + ast.getReferenceMap(), + ast.getTypeMap()); + } + + /** + * Constructs an instance of {@link CelMutableAst} with the mutable expression and its source + * builder. + */ + public static CelMutableAst of(CelMutableExpr mutableExpr, CelMutableSource mutableSource) { + return new CelMutableAst(mutableExpr, mutableSource); + } + + private CelMutableAst(CelMutableExpr mutatedExpr, CelMutableSource mutableSource) { + this(mutatedExpr, mutableSource, new HashMap<>(), new HashMap<>()); + } + + private CelMutableAst( + CelMutableExpr mutatedExpr, + CelMutableSource mutableSource, + Map references, + Map types) { + this.mutatedExpr = mutatedExpr; + this.source = mutableSource; + this.references = new HashMap<>(references); + this.types = new HashMap<>(types); + } +} diff --git a/common/src/main/java/dev/cel/common/CelMutableSource.java b/common/src/main/java/dev/cel/common/CelMutableSource.java new file mode 100644 index 000000000..cf85f5af6 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelMutableSource.java @@ -0,0 +1,156 @@ +// Copyright 2024 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; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableMap.toImmutableMap; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.common.CelSource.Extension; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExprConverter; +import dev.cel.common.internal.CelCodePointArray; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * Represents the mutable portion of the {@link CelSource}. This is intended for the purposes of + * augmenting an AST through CEL optimizers. + */ +public final class CelMutableSource { + + private String description; + private final Map macroCalls; + private final Set extensions; + private final CelCodePointArray codePoints; + private final ImmutableList lineOffsets; + private final Map positions; + + @CanIgnoreReturnValue + public CelMutableSource addMacroCalls(long exprId, CelMutableExpr expr) { + this.macroCalls.put(exprId, checkNotNull(CelMutableExpr.newInstance(expr))); + return this; + } + + @CanIgnoreReturnValue + public CelMutableSource addAllMacroCalls(Map macroCalls) { + this.macroCalls.putAll(macroCalls); + return this; + } + + @CanIgnoreReturnValue + public CelMutableSource addAllExtensions(Collection extensions) { + checkNotNull(extensions); + this.extensions.addAll(extensions); + return this; + } + + @CanIgnoreReturnValue + public CelMutableSource setDescription(String description) { + this.description = checkNotNull(description); + return this; + } + + @CanIgnoreReturnValue + public CelMutableSource clearMacroCall(long exprId) { + this.macroCalls.remove(exprId); + return this; + } + + @CanIgnoreReturnValue + public CelMutableSource clearMacroCalls() { + this.macroCalls.clear(); + return this; + } + + public String getDescription() { + return description; + } + + public Map getMacroCalls() { + return macroCalls; + } + + public Set getExtensions() { + return extensions; + } + + public CelSource toCelSource(boolean retainSourcePositions) { + CelSource.Builder builder = + retainSourcePositions + ? CelSource.newBuilder(codePoints, lineOffsets).addPositionsMap(positions) + : CelSource.newBuilder(); + + return builder + .setDescription(description) + .addAllExtensions(extensions) + .addAllMacroCalls( + macroCalls.entrySet().stream() + .collect( + toImmutableMap( + Entry::getKey, v -> CelMutableExprConverter.fromMutableExpr(v.getValue())))) + .build(); + } + + public static CelMutableSource newInstance() { + return new CelMutableSource( + "", + new HashMap<>(), + new HashSet<>(), + CelCodePointArray.fromString(""), + ImmutableList.of(), + new HashMap<>()); + } + + public static CelMutableSource fromCelSource(CelSource source) { + return new CelMutableSource( + source.getDescription(), + source.getMacroCalls().entrySet().stream() + .collect( + Collectors.toMap( + Entry::getKey, + v -> CelMutableExprConverter.fromCelExpr(v.getValue()), + (prev, next) -> { + throw new IllegalStateException( + "Unexpected source collision at ID: " + prev.id()); + }, + HashMap::new)), + source.getExtensions(), + source.getContent(), + source.getLineOffsets(), + source.getPositionsMap()); + } + + CelMutableSource( + String description, + Map macroCalls, + Set extensions, + CelCodePointArray codePoints, + ImmutableList lineOffsets, + Map positions) { + this.description = checkNotNull(description); + this.macroCalls = checkNotNull(macroCalls); + this.extensions = checkNotNull(extensions); + this.codePoints = checkNotNull(codePoints); + this.lineOffsets = checkNotNull(lineOffsets); + this.positions = checkNotNull(positions); + } +} diff --git a/common/src/main/java/dev/cel/common/CelOptions.java b/common/src/main/java/dev/cel/common/CelOptions.java new file mode 100644 index 000000000..d9c2dd818 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelOptions.java @@ -0,0 +1,523 @@ +// Copyright 2022 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; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; + +/** + * Options to configure how the CEL parser, type-checker, and evaluator behave. + * + *

Users are strongly encouraged to use {@link #current} to ensure that the overall CEL stack + * behaves in the manner most consistent with the CEL specification. + */ +@CheckReturnValue +@AutoValue +@Immutable +public abstract class CelOptions { + + /** + * ProtoUnsetFieldOptions describes how to handle Activation.fromProto() calls where proto message + * fields may be unset and should either be handled perhaps as absent or as the default proto + * value. + */ + public enum ProtoUnsetFieldOptions { + // Do not bind a field if it is unset. Repeated fields are bound as empty list. + SKIP, + // Bind the (proto api) default value for a field. + BIND_DEFAULT + } + + public static final CelOptions DEFAULT = current().build(); + + public static final CelOptions LEGACY = newBuilder().disableCelStandardEquality(true).build(); + + // Package-private constructor to prevent extension. + CelOptions() {} + + // Parser related options + + public abstract boolean enableReservedIds(); + + public abstract boolean enableOptionalSyntax(); + + public abstract int maxExpressionCodePointSize(); + + public abstract int maxParseErrorRecoveryLimit(); + + public abstract int maxParseRecursionDepth(); + + public abstract boolean populateMacroCalls(); + + public abstract boolean retainRepeatedUnaryOperators(); + + public abstract boolean retainUnbalancedLogicalExpressions(); + + public abstract boolean enableHiddenAccumulatorVar(); + + public abstract boolean enableQuotedIdentifierSyntax(); + + // Type-Checker related options + + public abstract boolean enableCompileTimeOverloadResolution(); + + public abstract boolean enableHomogeneousLiterals(); + + public abstract boolean enableTimestampEpoch(); + + public abstract boolean enableHeterogeneousNumericComparisons(); + + public abstract boolean enableNamespacedDeclarations(); + + public abstract boolean enableJsonFieldNames(); + + // Evaluation related options + + public abstract boolean disableCelStandardEquality(); + + public abstract boolean enableShortCircuiting(); + + public abstract boolean enableRegexPartialMatch(); + + public abstract boolean enableUnsignedComparisonAndArithmeticIsUnsigned(); + + public abstract boolean enableUnsignedLongs(); + + public abstract boolean enableProtoDifferencerEquality(); + + public abstract boolean errorOnDuplicateMapKeys(); + + public abstract boolean errorOnIntWrap(); + + public abstract boolean resolveTypeDependencies(); + + public abstract boolean enableUnknownTracking(); + + public abstract boolean enableCelValue(); + + public abstract int comprehensionMaxIterations(); + + public abstract boolean evaluateCanonicalTypesToNativeValues(); + + public abstract boolean unwrapWellKnownTypesOnFunctionDispatch(); + + public abstract ProtoUnsetFieldOptions fromProtoUnsetFieldOption(); + + public abstract boolean enableComprehension(); + + public abstract int maxRegexProgramSize(); + + public abstract Builder toBuilder(); + + /** + * Return an unconfigured {@code Builder}. This is equivalent to preserving all legacy behaviors, + * both good and bad, of the original CEL implementation. + */ + public static Builder newBuilder() { + return new AutoValue_CelOptions.Builder() + // Parser options + .enableReservedIds(false) + .enableOptionalSyntax(false) + .maxExpressionCodePointSize(100_000) + .maxParseErrorRecoveryLimit(30) + .maxParseRecursionDepth(250) + .populateMacroCalls(false) + .retainRepeatedUnaryOperators(false) + .retainUnbalancedLogicalExpressions(false) + .enableHiddenAccumulatorVar(true) + .enableQuotedIdentifierSyntax(true) + // Type-Checker options + .enableCompileTimeOverloadResolution(false) + .enableHomogeneousLiterals(false) + .enableTimestampEpoch(false) + .enableHeterogeneousNumericComparisons(false) + .enableNamespacedDeclarations(true) + .enableJsonFieldNames(false) + // Evaluation options + .disableCelStandardEquality(true) + .evaluateCanonicalTypesToNativeValues(false) + .enableShortCircuiting(true) + .enableRegexPartialMatch(false) + .enableUnsignedComparisonAndArithmeticIsUnsigned(false) + .enableUnsignedLongs(false) + .enableProtoDifferencerEquality(false) + .errorOnIntWrap(false) + .errorOnDuplicateMapKeys(false) + .resolveTypeDependencies(true) + .enableUnknownTracking(false) + .enableCelValue(false) + .comprehensionMaxIterations(-1) + .unwrapWellKnownTypesOnFunctionDispatch(true) + .fromProtoUnsetFieldOption(ProtoUnsetFieldOptions.BIND_DEFAULT) + .enableComprehension(true) + .maxRegexProgramSize(-1); + } + + /** + * Return a {@code Builder} configured with the most current set of {@code CelOptions} + * (recommended). + */ + public static Builder current() { + return newBuilder() + .enableReservedIds(true) + .enableUnsignedComparisonAndArithmeticIsUnsigned(true) + .enableUnsignedLongs(true) + .enableRegexPartialMatch(true) + .enableTimestampEpoch(true) + .errorOnDuplicateMapKeys(true) + .evaluateCanonicalTypesToNativeValues(true) + .errorOnIntWrap(true) + .resolveTypeDependencies(true) + .disableCelStandardEquality(false); + } + + /** Builder for configuring the {@code CelOptions}. */ + @AutoValue.Builder + public abstract static class Builder { + // Package-private constructor to prevent extension. + Builder() {} + + // Parser related builder options. + + /** + * Check for use of reserved identifiers during parsing. + * + *

See the language + * spec for a list of reserved identifiers. + */ + public abstract Builder enableReservedIds(boolean value); + + /** + * EnableOptionalSyntax enables syntax for optional field and index selection (e.g: msg.?field). + * + *

Note: This option is automatically enabled for the parser by adding {@code + * CelOptionalLibrary} to the environment. + */ + public abstract Builder enableOptionalSyntax(boolean value); + + /** + * Set a limit on the size of the expression string which may be parsed in terms of the number + * of code points contained within the string. + */ + public abstract Builder maxExpressionCodePointSize(int value); + + /** + * Limit the number of error recovery attempts which may be made by the parser for a given + * syntax error before terminating the parse completely. + */ + public abstract Builder maxParseErrorRecoveryLimit(int value); + + /** Limit the amount of recursion within parse expressions. */ + public abstract Builder maxParseRecursionDepth(int value); + + /** Populate macro_calls map in source_info with macro calls parsed from the expression. */ + public abstract Builder populateMacroCalls(boolean value); + + /** + * Retain all invocations of unary '-' and '!' that occur in source in the abstract syntax. + * + *

By default the parser collapses towers of repeated unary '-' and '!' into zero or one + * instance by assuming these operators to be inverses of themselves. This behavior may not + * always be desirable. + */ + public abstract Builder retainRepeatedUnaryOperators(boolean value); + + /** + * Retain the original grouping of logical connectives '&&' and '||' without attempting to + * rebalance them in the abstract syntax. + * + *

The default rebalancing can reduce the overall nesting depth of the generated protos + * representing abstract syntax, but it relies on associativity of the operations themselves. + * This behavior may not always be desirable. + */ + public abstract Builder retainUnbalancedLogicalExpressions(boolean value); + + /** + * Enable the use of a hidden accumulator variable name. + * + *

This is a temporary option to transition to using an internal identifier for the + * accumulator variable used by builtin comprehension macros. When enabled, parses result in a + * semantically equivalent AST, but with a different accumulator variable that can't be directly + * referenced in the source expression. + */ + public abstract Builder enableHiddenAccumulatorVar(boolean value); + + /** + * Enable quoted identifier syntax. + * + *

This enables the use of quoted identifier syntax when parsing CEL expressions. When + * enabled, the parser will accept identifiers that are surrounded by backticks (`) and will + * treat them as a single identifier. Currently, this is only supported for field specifiers + * over a limited character set. + */ + public abstract Builder enableQuotedIdentifierSyntax(boolean value); + + // Type-Checker related options + + /** + * Require overloads to resolve (narrow to a single candidate) during type checking. + * + *

This eliminates run-time overload dispatch and avoids implicit coercions of the result + * type to type dyn. However, this configuration should only be used if your application is not + * handling any form of dynamic data such as JSON or {@code google.protobuf.Any}. + */ + public abstract Builder enableCompileTimeOverloadResolution(boolean value); + + /** + * During type checking require list-, and map literals to be type-homogeneous in their + * element-, key-, and value types, respectively. + * + *

Without this flag one can use type-mismatched elements, keys, and values, and the type + * checker will implicitly coerce them to type dyn. + * + *

This flag is recommended for all new uses of CEL. + * + * @deprecated Use standalone {@code dev.cel.validators.validator.HomogeneousLiteralValidator} + * instead. + */ + @Deprecated + public abstract Builder enableHomogeneousLiterals(boolean value); + + /** + * Enable the {@code int64_to_timestamp} overload which creates a timestamp from Unix epoch + * seconds. + * + *

Historically used to opt-in to this feature, this option is now enabled by default across + * all runtimes. + * + *

TODO: Remove this feature once it has been auto-enabled. + * + * @deprecated This option is now enabled by default. If you are passing {@code true}, simply + * remove this method call. If you are passing {@code false} to disable this feature, subset + * the environment instead using {@code dev.cel.checker.CelStandardDeclarations} and {@code + * dev.cel.runtime.CelStandardFunctions}. + */ + @Deprecated + public abstract Builder enableTimestampEpoch(boolean value); + + /** + * Enable the {@code less_equals_double_int64} and other cross-type numeric comparisons for + * {@code double}, {@code int64}, and {@code uint64} values. + * + *

This feature adds the declarations for these overloads to the CEL standard environment, + * but the runtime functions are enabled by default. + * + *

TODO: Remove this feature once it has been auto-enabled. + */ + public abstract Builder enableHeterogeneousNumericComparisons(boolean value); + + /** + * Enables the usage of namespaced functions and identifiers. This causes the type-checker to + * rewrite the AST to support namespacing (e.g: a field selector of form `namespace.msg.field` + * gets rewritten as a fully qualified identifier name of `namespace.msg.field`). + * + *

TODO: Remove this feature once it has been auto-enabled. + * + * @deprecated This will be removed in the future. Please update your codebase to not rely on + * existence of certain expression nodes that would be collapsed/removed with this feature + * enabled. + */ + @Deprecated + public abstract Builder enableNamespacedDeclarations(boolean value); + + // Evaluation related options + + /** + * Disable standard CEL equality in favor of the legacy Java equality calls for (in)equality + * tests. + * + *

This feature is how the legacy CEL-Java APIs were originally configured, and in most cases + * will yield identical results to CEL equality, with the exception that equality between + * well-known protobuf types (wrapper types, {@code protobuf.Value}, {@code protobuf.Any}) may + * not compare correctly to simple and aggregate CEL types. + * + *

Additionally, Java equality across numeric types such as {@code double} and {@code long}, + * will be trivially false, whereas CEL equality will compare the values as though they exist on + * a continuous number line. + */ + public abstract Builder disableCelStandardEquality(boolean value); + + /** + * Enable short-circuiting of the logical operator evaluation. If enabled, AND, OR, and TERNARY + * do not evaluate the entire expression once the resulting value is known from the left-hand + * side. + * + *

This option is enabled by default. In most cases, this should not be disabled except for + * debugging purposes or collecting results for all evaluated branches through {@link + * dev.cel.runtime.CelEvaluationListener}. + */ + public abstract Builder enableShortCircuiting(boolean value); + + /** + * Treat regex {@code matches} calls as substring (unanchored) match patterns. + * + *

The default treatment for pattern matching within RE2 is full match within Java; however, + * the CEL standard specifies that the matches() function is a substring match. + */ + public abstract Builder enableRegexPartialMatch(boolean value); + + /** + * Treat unsigned integers as unsigned when doing arithmetic and comparisons. + * + *

Prior to turning on this feature, attempts to perform arithmetic or comparisons on + * unsigned integers larger than 2^63-1 may result in a runtime exception in the form of an + * {@link java.lang.IllegalArgumentException}. + */ + public abstract Builder enableUnsignedComparisonAndArithmeticIsUnsigned(boolean value); + + /** + * Use {@code UnsignedLong} values to represent unsigned integers within CEL instead of the + * nearest Java equivalent of {@code Long}. + * + * @deprecated Do not use. This option is enabled by default in the currently supported feature + * set {@link CelOptions#DEFAULT}. This flag will be removed in the future. + */ + @Deprecated + public abstract Builder enableUnsignedLongs(boolean value); + + /** + * Perform equality using {@code ProtoEquality} proto equality. + * + *

CEL's alternative implementation to the {@code Message#equals} comes with a few key + * differences: + * + *

    + *
  • NaN is not equal to itself. + *
  • Any values are unpacked before comparison. + *
  • If two Any values cannot be unpacked, they are compared by bytes. + *
+ */ + public abstract Builder enableProtoDifferencerEquality(boolean value); + + /** Throw errors on duplicate keys in map literals. */ + public abstract Builder errorOnDuplicateMapKeys(boolean value); + + /** + * Throw errors when ints or uints wrap. + * + *

Prior to this feature, int and uint arithmetic wrapped, i.e. was coerced into range via + * mod 2^64. The spec settled on throwing an error instead. Note that this makes arithmetic non- + * associative. + */ + public abstract Builder errorOnIntWrap(boolean value); + + /** + * Enable or disable the resolution of {@code Descriptor} type dependencies as part of the CEL + * environment setup. Defaults to disabled. + * + *

Disabling this feature should only be done when you know that only the types provided will + * be referenced within the CEL expression. This means that either the type set provided was + * complete, or that the type set is only what is referenced within expressions. + */ + public abstract Builder resolveTypeDependencies(boolean value); + + /** + * Enable tracking unknown attributes and function invocations encountered during evaluation. + * + *

When enabled, the evaluator will track unknown attributes (leaf values in the activations) + * and function results (a particular invocation that was identified as unknown). + */ + public abstract Builder enableUnknownTracking(boolean value); + + /** + * @deprecated Do not use, this flag will be removed in the future. Use the planner based + * runtime instead, which supports CelValue by default. + */ + @Deprecated + public abstract Builder enableCelValue(boolean value); + + /** + * Limit the total number of iterations permitted within comprehension loops. + * + *

If the limit is reached, then an evaluation exception will be thrown. This limit also + * affects nested comprehension interactions as well. + * + *

A negative {@code value} will disable max iteration checks. + * + *

Note: comprehension limits are not supported within the async CEL interpreter. + */ + public abstract Builder comprehensionMaxIterations(int value); + + /** + * If set, canonical CEL types such as bytes and CEL null will return their native value + * equivalents instead of protobuf based values. Specifically: + * + *

    + *
  • Bytes: {@code dev.cel.common.values.CelByteString} instead of {@code + * com.google.protobuf.ByteString}. + *
  • CEL null: {@code dev.cel.common.values.NullValue} instead of {@code + * com.google.protobuf.NullValue}. + *
  • Timestamp: {@code java.time.Instant} instead of {@code com.google.protobuf.Timestamp}. + *
  • Duration: {@code java.time.Duration} instead of {@code com.google.protobuf.Duration}. + *
+ * + * @deprecated Do not use. This flag is enabled by default and will be removed in the future. + */ + @Deprecated + public abstract Builder evaluateCanonicalTypesToNativeValues(boolean value); + + /** + * If disabled, CEL runtime will no longer adapt the function dispatch results for protobuf's + * well known types to other types. This option is enabled by default. + * + * @deprecated This will be removed in the future. Please update your codebase to be conformant + * with CEL specification. + */ + @Deprecated + public abstract Builder unwrapWellKnownTypesOnFunctionDispatch(boolean value); + + /** + * Configure how unset proto fields are handled when evaluating over a protobuf message where + * fields are intended to be treated as top-level variables. Defaults to binding all fields to + * their default value if unset. + * + * @see ProtoUnsetFieldOptions + */ + public abstract Builder fromProtoUnsetFieldOption(ProtoUnsetFieldOptions value); + + /** + * Enables comprehension (macros) for the runtime. Setting false has the same effect with + * assigning 0 for {@link #comprehensionMaxIterations()}. This option exists to maintain parity + * with cel-cpp interpreter options. + */ + public abstract Builder enableComprehension(boolean value); + + /** + * Set maximum program size for RE2J regex. + * + *

The program size is a very approximate measure of a regexp's "cost". Larger numbers are + * more expensive than smaller numbers. + * + *

A negative {@code value} will disable the check. + * + *

There's no guarantee that RE2 program size has the exact same value across other CEL + * implementations (C++ and Go). + */ + public abstract Builder maxRegexProgramSize(int value); + + /** + * Use the `json_name` field option on a protobuf message as the name of the field. + * + *

If enabled, the compiler will only accept the `json_name` and no longer recognize the + * original protobuf field name. Use with caution as this may break existing expressions during + * compilation. The runtime continues to support both names for maintaining backwards + * compatibility. + */ + public abstract Builder enableJsonFieldNames(boolean value); + + public abstract CelOptions build(); + } +} diff --git a/common/src/main/java/dev/cel/common/CelOverloadDecl.java b/common/src/main/java/dev/cel/common/CelOverloadDecl.java new file mode 100644 index 000000000..1d9c61e9d --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelOverloadDecl.java @@ -0,0 +1,265 @@ +// Copyright 2022 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; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; + +import dev.cel.expr.Decl.FunctionDecl.Overload; +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import java.util.Arrays; +import java.util.List; + +/** + * Abstract representation of a CEL function overload declaration. + * + *

An overload indicates a function's parameter types and return type, where types are specified + * via CEL native type representations (See: {@link CelType}. + * + *

An overload is declared in either a global function `Ex: f(x, ...)` or a method call style + * `Ex: x.f(...)`. + */ +@AutoValue +@Immutable +public abstract class CelOverloadDecl { + /** Required. Globally unique overload name. */ + public abstract String overloadId(); + + /** + * List of function parameter type values. + * + *

Param types are disjoint after generic type parameters have been replaced with the type + * `DYN`. Since the `DYN` type is compatible with any other type, this means that if `A` is a type + * parameter, the function types `int` and `int` are not disjoint. Likewise, `map` is not disjoint from `map`. + * + *

When the {@link #resultType} of a function is a generic type param, the type param name also + * appears as the `type` of on at least one params. + */ + public abstract ImmutableList parameterTypes(); + + /** The type param names associated with the function declaration. */ + public abstract ImmutableSet typeParameterNames(); + + /** + * Required. The result type of the function. For example, the operator `string.isEmpty()` would + * have `result_type` of `CelKind.BOOL`. + */ + public abstract CelType resultType(); + + /** + * Denotes whether the function is declared in a global function `Ex: f(x, ...)` or a method call + * style `Ex: x.f(...)`. + */ + public abstract boolean isInstanceFunction(); + + /** Documentation string for the overload. */ + public abstract String doc(); + + public abstract Builder toBuilder(); + + /** Create a new builder to construct a {@link CelOverloadDecl} instance */ + public static Builder newBuilder() { + return new AutoValue_CelOverloadDecl.Builder().setDoc(""); + } + + /** Builder for configuring the {@link CelOverloadDecl}. */ + @AutoValue.Builder + public abstract static class Builder { + /** Sets the value for {@link #overloadId()} */ + public abstract Builder setOverloadId(String overloadId); + + /** + * Sets the parameter types {@link #parameterTypes()}. Note that this will override any + * parameter types added via the accumulator methods {@link #addParameterTypes}. + */ + public abstract Builder setParameterTypes(ImmutableList value); + + public abstract CelType resultType(); + + /** Sets the result type {@link #resultType()} */ + public abstract Builder setResultType(CelType value); + + /** + * Sets the function declaration style {@link #isInstanceFunction()}. False for global function + * style, true for member call style + */ + public abstract Builder setIsInstanceFunction(boolean value); + + /** Sets the documentation for the overload */ + public abstract Builder setDoc(String value); + + public abstract boolean isInstanceFunction(); + + public abstract ImmutableList parameterTypes(); + + /** + * Not public. This is collected in {@link #build()} by visiting all the parameter types and the + * expected result type. + */ + abstract Builder setTypeParameterNames(ImmutableSet value); + + abstract ImmutableList.Builder parameterTypesBuilder(); + + /** Accumulates parameter types into {@link #parameterTypesBuilder()} */ + @CanIgnoreReturnValue + public final Builder addParameterTypes(Iterable parameterTypes) { + checkNotNull(parameterTypes); + parameterTypesBuilder().addAll(parameterTypes); + return this; + } + + /** Accumulates parameter types into {@link #parameterTypesBuilder()} */ + @CanIgnoreReturnValue + public Builder addParameterTypes(CelType... parameterTypes) { + checkNotNull(parameterTypes); + parameterTypesBuilder().add(parameterTypes); + return this; + } + + @CheckReturnValue + abstract CelOverloadDecl autoBuild(); + + /** Build a new instance of the {@link CelOverloadDecl} */ + @CheckReturnValue + public CelOverloadDecl build() { + ImmutableSet.Builder typeParamNameBuilder = new ImmutableSet.Builder<>(); + for (CelType type : parameterTypes()) { + collectParamNames(typeParamNameBuilder, type); + } + collectParamNames(typeParamNameBuilder, resultType()); + + setTypeParameterNames(typeParamNameBuilder.build()); + return autoBuild(); + } + } + + /** Helper method for declaring a member function overload */ + @CheckReturnValue + public static CelOverloadDecl newMemberOverload( + String overloadId, CelType resultType, CelType... paramTypes) { + return newMemberOverload(overloadId, resultType, Arrays.asList(paramTypes)); + } + + /** Helper method for declaring a member function overload */ + @CheckReturnValue + public static CelOverloadDecl newMemberOverload( + String overloadId, CelType resultType, List paramTypes) { + return newMemberOverload(overloadId, /* doc= */ "", resultType, paramTypes); + } + + /** Helper method for declaring a member function overload */ + @CheckReturnValue + public static CelOverloadDecl newMemberOverload( + String overloadId, String doc, CelType resultType, CelType... paramTypes) { + return newMemberOverload(overloadId, doc, resultType, Arrays.asList(paramTypes)); + } + + /** Helper method for declaring a member function overload */ + @CheckReturnValue + public static CelOverloadDecl newMemberOverload( + String overloadId, String doc, CelType resultType, List paramTypes) { + return newOverload(overloadId, doc, resultType, paramTypes, /* isInstanceFunction= */ true); + } + + /** Helper method for declaring a global function overload */ + @CheckReturnValue + public static CelOverloadDecl newGlobalOverload( + String overloadId, CelType resultType, CelType... paramTypes) { + return newGlobalOverload(overloadId, resultType, Arrays.asList(paramTypes)); + } + + /** Helper method for declaring a global function overload */ + @CheckReturnValue + public static CelOverloadDecl newGlobalOverload( + String overloadId, CelType resultType, List paramTypes) { + return newGlobalOverload(overloadId, /* doc= */ "", resultType, paramTypes); + } + + /** Helper method for declaring a global function overload */ + @CheckReturnValue + public static CelOverloadDecl newGlobalOverload( + String overloadId, String doc, CelType resultType, CelType... paramTypes) { + return newGlobalOverload(overloadId, doc, resultType, Arrays.asList(paramTypes)); + } + + /** Helper method for declaring a global function overload */ + @CheckReturnValue + public static CelOverloadDecl newGlobalOverload( + String overloadId, String doc, CelType resultType, List paramTypes) { + return newOverload(overloadId, doc, resultType, paramTypes, /* isInstanceFunction= */ false); + } + + private static CelOverloadDecl newOverload( + String overloadId, + String doc, + CelType resultType, + List paramTypes, + boolean isInstanceFunction) { + return CelOverloadDecl.newBuilder() + .setOverloadId(overloadId) + .setIsInstanceFunction(isInstanceFunction) + .setResultType(resultType) + .addParameterTypes(paramTypes) + .setDoc(doc) + .build(); + } + + /** Converts a {@link CelOverloadDecl} to a protobuf equivalent form {@link Overload} */ + public static Overload celOverloadToOverload(CelOverloadDecl overload) { + return Overload.newBuilder() + .setIsInstanceFunction(overload.isInstanceFunction()) + .setOverloadId(overload.overloadId()) + .setResultType(CelProtoTypes.celTypeToType(overload.resultType())) + .addAllParams( + overload.parameterTypes().stream() + .map(CelProtoTypes::celTypeToType) + .collect(toImmutableList())) + .addAllTypeParams(overload.typeParameterNames()) + .setDoc(overload.doc()) + .build(); + } + + public static CelOverloadDecl overloadToCelOverload(Overload overload) { + return CelOverloadDecl.newBuilder() + .setIsInstanceFunction(overload.getIsInstanceFunction()) + .setOverloadId(overload.getOverloadId()) + .setResultType(CelProtoTypes.typeToCelType(overload.getResultType())) + .setDoc(overload.getDoc()) + .addParameterTypes( + overload.getParamsList().stream() + .map(CelProtoTypes::typeToCelType) + .collect(toImmutableList())) + .build(); + } + + private static void collectParamNames(ImmutableSet.Builder typeParamNames, CelType type) { + if (type.kind().equals(CelKind.TYPE_PARAM)) { + typeParamNames.add(type.name()); + } + + for (CelType param : type.parameters()) { + collectParamNames(typeParamNames, param); + } + } +} diff --git a/common/src/main/java/dev/cel/common/CelProtoAbstractSyntaxTree.java b/common/src/main/java/dev/cel/common/CelProtoAbstractSyntaxTree.java new file mode 100644 index 000000000..7230c80af --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelProtoAbstractSyntaxTree.java @@ -0,0 +1,254 @@ +// Copyright 2022 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; + +import static com.google.common.base.Preconditions.checkState; +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableMap.toImmutableMap; + +import dev.cel.expr.CheckedExpr; +import dev.cel.expr.Expr; +import dev.cel.expr.ParsedExpr; +import dev.cel.expr.SourceInfo; +import dev.cel.expr.SourceInfo.Extension; +import dev.cel.expr.SourceInfo.Extension.Component; +import dev.cel.expr.SourceInfo.Extension.Version; +import dev.cel.expr.Type; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.ast.CelExprConverter; +import dev.cel.common.types.CelProtoTypes; +import java.util.Collection; +import java.util.Map.Entry; + +/** + * An Adapter for {@link CelAbstractSyntaxTree} constructed from Canonical Protos of {@link + * CheckedExpr} or {@link ParsedExpr} expressions. + * + *

Note: Keep this file in sync with {@link CelProtoV1Alpha1AbstractSyntaxTree} + */ +// LINT.IfChange +public final class CelProtoAbstractSyntaxTree { + private final CheckedExpr checkedExpr; + private final CelAbstractSyntaxTree ast; + + private CelProtoAbstractSyntaxTree(CheckedExpr checkedExpr) { + this.checkedExpr = checkedExpr; + this.ast = + CelAbstractSyntaxTree.newCheckedAst( + CelExprConverter.fromExpr(checkedExpr.getExpr()), + CelSource.newBuilder() + .addAllLineOffsets(checkedExpr.getSourceInfo().getLineOffsetsList()) + .addPositionsMap(checkedExpr.getSourceInfo().getPositionsMap()) + .addAllMacroCalls( + CelExprConverter.exprMacroCallsToCelExprMacroCalls( + checkedExpr.getSourceInfo().getMacroCallsMap())) + .addAllExtensions( + fromExprExtensionsToCelExtensions( + checkedExpr.getSourceInfo().getExtensionsList())) + .setDescription(checkedExpr.getSourceInfo().getLocation()) + .build(), + checkedExpr.getReferenceMapMap().entrySet().stream() + .collect( + toImmutableMap( + Entry::getKey, + v -> CelExprConverter.exprReferenceToCelReference(v.getValue()))), + checkedExpr.getTypeMapMap().entrySet().stream() + .collect( + toImmutableMap(Entry::getKey, v -> CelProtoTypes.typeToCelType(v.getValue())))); + } + + private CelProtoAbstractSyntaxTree(CelAbstractSyntaxTree ast) { + this.ast = ast; + + CheckedExpr.Builder checkedExprBuilder = + CheckedExpr.newBuilder() + .setSourceInfo( + SourceInfo.newBuilder() + .setLocation(ast.getSource().getDescription()) + .addAllLineOffsets(ast.getSource().getLineOffsets()) + .addAllExtensions( + fromCelExtensionsToExprExtensions(ast.getSource().getExtensions())) + .putAllMacroCalls( + ast.getSource().getMacroCalls().entrySet().stream() + .collect( + toImmutableMap( + Entry::getKey, + v -> CelExprConverter.fromCelExpr(v.getValue())))) + .putAllPositions(ast.getSource().getPositionsMap())) + .setExpr(CelExprConverter.fromCelExpr(ast.getExpr())); + + if (ast.isChecked()) { + checkedExprBuilder.putAllReferenceMap( + ast.getReferenceMap().entrySet().stream() + .collect( + toImmutableMap( + Entry::getKey, + v -> CelExprConverter.celReferenceToExprReference(v.getValue())))); + checkedExprBuilder.putAllTypeMap( + ast.getTypeMap().entrySet().stream() + .collect( + toImmutableMap(Entry::getKey, v -> CelProtoTypes.celTypeToType(v.getValue())))); + } + + this.checkedExpr = checkedExprBuilder.build(); + } + + /** Construct an abstract syntax tree from a {@link dev.cel.expr.CheckedExpr}. */ + public static CelProtoAbstractSyntaxTree fromCheckedExpr(CheckedExpr checkedExpr) { + return new CelProtoAbstractSyntaxTree(checkedExpr); + } + + /** Construct an abstract syntax tree from a {@link dev.cel.expr.ParsedExpr}. */ + public static CelProtoAbstractSyntaxTree fromParsedExpr(ParsedExpr parsedExpr) { + return new CelProtoAbstractSyntaxTree( + CheckedExpr.newBuilder() + .setExpr(parsedExpr.getExpr()) + .setSourceInfo(parsedExpr.getSourceInfo()) + .build()); + } + + /** Constructs CelProtoAbstractSyntaxTree from {@link CelAbstractSyntaxTree}. */ + public static CelProtoAbstractSyntaxTree fromCelAst(CelAbstractSyntaxTree ast) { + return new CelProtoAbstractSyntaxTree(ast); + } + + /** Tests whether the underlying abstract syntax tree has been type checked or not. */ + public boolean isChecked() { + return ast.isChecked(); + } + + /** + * Returns the native representation of the abstract syntax tree: {@link CelAbstractSyntaxTree}. + */ + @CheckReturnValue + public CelAbstractSyntaxTree getAst() { + return ast; + } + + /** + * Returns the underlying {@link dev.cel.expr.Expr} representation of the abstract syntax + * tree. + */ + @CheckReturnValue + public Expr getExpr() { + return checkedExpr.getExpr(); + } + + /** + * Returns the underlying {@link dev.cel.expr.CheckedExpr} representation of the abstract + * syntax tree. Throws {@link java.lang.IllegalStateException} if {@link + * CelAbstractSyntaxTree#isChecked} is false. + */ + @CheckReturnValue + public CheckedExpr toCheckedExpr() { + checkState( + isChecked(), + "CelAbstractSyntaxTree must be checked before it can be converted to CheckedExpr"); + return checkedExpr; + } + + /** + * Returns the underlying {@link dev.cel.expr.SourceInfo} representation of the abstract + * syntax tree. + */ + @CheckReturnValue + public SourceInfo getSourceInfo() { + return checkedExpr.getSourceInfo(); + } + + /** + * Returns the underlying {@link dev.cel.expr.ParsedExpr} representation of the abstract + * syntax tree. + */ + @CheckReturnValue + public ParsedExpr toParsedExpr() { + return ParsedExpr.newBuilder().setExpr(getExpr()).setSourceInfo(getSourceInfo()).build(); + } + + /** + * For a type checked abstract syntax tree the resulting type is returned in proto format + * described in checked.proto. Otherwise, the dynamic type is returned. + */ + @CheckReturnValue + public Type getProtoResultType() { + return CelProtoTypes.celTypeToType(ast.getResultType()); + } + + private static ImmutableList fromCelExtensionsToExprExtensions( + Collection extensions) { + return extensions.stream() + .map( + celSourceExtension -> + Extension.newBuilder() + .setId(celSourceExtension.id()) + .setVersion( + Version.newBuilder() + .setMajor(celSourceExtension.version().major()) + .setMinor(celSourceExtension.version().minor())) + .addAllAffectedComponents( + celSourceExtension.affectedComponents().stream() + .map( + component -> { + switch (component) { + case COMPONENT_UNSPECIFIED: + return Component.COMPONENT_UNSPECIFIED; + case COMPONENT_PARSER: + return Component.COMPONENT_PARSER; + case COMPONENT_TYPE_CHECKER: + return Component.COMPONENT_TYPE_CHECKER; + case COMPONENT_RUNTIME: + return Component.COMPONENT_RUNTIME; + } + throw new AssertionError( + "Unexpected component kind: " + component); + }) + .collect(toImmutableList())) + .build()) + .collect(toImmutableList()); + } + + private static ImmutableList fromExprExtensionsToCelExtensions( + Collection extensions) { + return extensions.stream() + .map( + exprExtension -> + CelSource.Extension.create( + exprExtension.getId(), + CelSource.Extension.Version.of( + exprExtension.getVersion().getMajor(), + exprExtension.getVersion().getMinor()), + exprExtension.getAffectedComponentsList().stream() + .map( + component -> { + switch (component) { + case COMPONENT_UNSPECIFIED: + return CelSource.Extension.Component.COMPONENT_UNSPECIFIED; + case COMPONENT_PARSER: + return CelSource.Extension.Component.COMPONENT_PARSER; + case COMPONENT_TYPE_CHECKER: + return CelSource.Extension.Component.COMPONENT_TYPE_CHECKER; + case COMPONENT_RUNTIME: + return CelSource.Extension.Component.COMPONENT_RUNTIME; + case UNRECOGNIZED: + // fall-through + } + throw new AssertionError("Unexpected component kind: " + component); + }) + .collect(toImmutableList()))) + .collect(toImmutableList()); + } +} +// LINT.ThenChange(CelProtoV1Alpha1AbstractSyntaxTree.java) diff --git a/common/src/main/java/dev/cel/common/CelProtoJsonAdapter.java b/common/src/main/java/dev/cel/common/CelProtoJsonAdapter.java new file mode 100644 index 000000000..e74d52f7a --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelProtoJsonAdapter.java @@ -0,0 +1,176 @@ +// Copyright 2024 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; + +import com.google.common.base.CaseFormat; +import com.google.common.base.Joiner; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Duration; +import com.google.protobuf.Empty; +import com.google.protobuf.FieldMask; +import com.google.protobuf.ListValue; +import com.google.protobuf.NullValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.Value; +import dev.cel.common.internal.DateTimeHelpers; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.values.CelByteString; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Base64; +import java.util.List; +import java.util.Map; + +/** + * {@code CelProtoJsonAdapter} is a utility to handle conversion from Java native objects + * representing CEL values to Protobuf's structured value which maps to JSON object schema. + */ +@Immutable +public final class CelProtoJsonAdapter { + private static final long JSON_MAX_INT_VALUE = (1L << 53) - 1; + private static final long JSON_MIN_INT_VALUE = -JSON_MAX_INT_VALUE; + private static final UnsignedLong JSON_MAX_UINT_VALUE = + UnsignedLong.fromLongBits(JSON_MAX_INT_VALUE); + + /** + * Adapts a map to a JSON Struct. + * + * @throws ClassCastException If the key is not a string literal + * @throws IllegalArgumentException If any of the map's value is not convertible to a canonical + * JSON representation defined by protobuf. + */ + public static Struct adaptToJsonStructValue(Map map) { + Struct.Builder struct = Struct.newBuilder(); + for (Map.Entry entry : map.entrySet()) { + String key = entry.getKey(); + Object keyValue = entry.getValue(); + + struct.putFields(key, adaptValueToJsonValue(keyValue)); + } + return struct.build(); + } + + /** + * Adapts a native Java object to a JSON value. + * + * @throws IllegalArgumentException If the value is not convertible to a canonical JSON * + * representation defined by protobuf. + */ + @SuppressWarnings("unchecked") + public static Value adaptValueToJsonValue(Object value) { + Value.Builder json = Value.newBuilder(); + if (value == null || value instanceof dev.cel.common.values.NullValue) { + return json.setNullValue(NullValue.NULL_VALUE).build(); + } + if (value instanceof Boolean) { + return json.setBoolValue((Boolean) value).build(); + } + if (value instanceof Integer || value instanceof Long) { + long longValue = ((Number) value).longValue(); + if (longValue < JSON_MIN_INT_VALUE || longValue > JSON_MAX_INT_VALUE) { + return json.setStringValue(Long.toString(longValue)).build(); + } + return json.setNumberValue((double) longValue).build(); + } + if (value instanceof UnsignedLong) { + if (((UnsignedLong) value).compareTo(JSON_MAX_UINT_VALUE) > 0) { + return json.setStringValue(((UnsignedLong) value).toString()).build(); + } + return json.setNumberValue((double) ((UnsignedLong) value).longValue()).build(); + } + if (value instanceof Float || value instanceof Double) { + return json.setNumberValue(((Number) value).doubleValue()).build(); + } + if (value instanceof CelByteString) { + return json.setStringValue( + Base64.getEncoder().encodeToString(((CelByteString) value).toByteArray())) + .build(); + } + if (value instanceof String) { + return json.setStringValue((String) value).build(); + } + if (value instanceof Map) { + Struct struct = adaptToJsonStructValue((Map) value); + return json.setStructValue(struct).build(); + } + if (value instanceof Iterable) { + ListValue listValue = adaptToJsonListValue((Iterable) value); + return json.setListValue(listValue).build(); + } + if (value instanceof Timestamp) { + // CEL follows the proto3 to JSON conversion which formats as an RFC 3339 encoded JSON string. + String ts = ProtoTimeUtils.toString((Timestamp) value); + return json.setStringValue(ts).build(); + } + if (value instanceof Duration) { + String duration = ProtoTimeUtils.toString((Duration) value); + return json.setStringValue(duration).build(); + } + if (value instanceof Instant) { + // Instant's toString follows RFC 3339 + return json.setStringValue(value.toString()).build(); + } + if (value instanceof java.time.Duration) { + String duration = DateTimeHelpers.toString((java.time.Duration) value); + return json.setStringValue(duration).build(); + } + if (value instanceof FieldMask) { + String fieldMaskStr = toJsonString((FieldMask) value); + return json.setStringValue(fieldMaskStr).build(); + } + if (value instanceof Empty) { + // google.protobuf.Empty is just an empty json map {} + return json.setStructValue(Struct.getDefaultInstance()).build(); + } + + throw new IllegalArgumentException( + String.format("Value %s cannot be adapted to a JSON Value.", value)); + } + + /** + * Joins the field mask's paths into a single string with commas. This logic is copied from + * Protobuf's FieldMaskUtil.java, which we cannot directly use here due to its dependency to + * descriptors. + */ + private static String toJsonString(FieldMask fieldMask) { + List paths = new ArrayList<>(fieldMask.getPathsCount()); + + for (String path : fieldMask.getPathsList()) { + if (!path.isEmpty()) { + paths.add(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, path)); + } + } + + return Joiner.on(",").join(paths); + } + + /** + * Adapts an iterable to a JSON list value. + * + * @throws IllegalArgumentException If any of the map's value is not convertible to a canonical + * JSON representation defined by protobuf. + */ + public static ListValue adaptToJsonListValue(Iterable value) { + ListValue.Builder jsonList = ListValue.newBuilder(); + for (Object elem : value) { + jsonList.addValues(adaptValueToJsonValue(elem)); + } + return jsonList.build(); + } + + private CelProtoJsonAdapter() {} +} diff --git a/common/src/main/java/dev/cel/common/CelProtoV1Alpha1AbstractSyntaxTree.java b/common/src/main/java/dev/cel/common/CelProtoV1Alpha1AbstractSyntaxTree.java new file mode 100644 index 000000000..80fa58f3a --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelProtoV1Alpha1AbstractSyntaxTree.java @@ -0,0 +1,173 @@ +// Copyright 2022 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; + +import static com.google.common.base.Preconditions.checkState; +import static com.google.common.collect.ImmutableMap.toImmutableMap; + +import com.google.api.expr.v1alpha1.CheckedExpr; +import com.google.api.expr.v1alpha1.Expr; +import com.google.api.expr.v1alpha1.ParsedExpr; +import com.google.api.expr.v1alpha1.SourceInfo; +import com.google.api.expr.v1alpha1.Type; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.ast.CelExprV1Alpha1Converter; +import dev.cel.common.types.CelV1AlphaTypes; +import java.util.Map.Entry; + +/** + * An Adapter for {@link CelAbstractSyntaxTree} constructed from v1alpha1 Protos of {@link + * CheckedExpr} or {@link ParsedExpr} expressions. + * + *

Note: Clients should prefer using {@link CelProtoAbstractSyntaxTree} instead. This only exists + * to maintain compatibility with the deprecated v1alpha1 protos. + * + *

Note: Keep this file in sync with {@link CelProtoAbstractSyntaxTree} + */ +// LINT.IfChange +public final class CelProtoV1Alpha1AbstractSyntaxTree { + private final CheckedExpr checkedExpr; + private final CelAbstractSyntaxTree ast; + + private CelProtoV1Alpha1AbstractSyntaxTree(CheckedExpr checkedExpr) { + this.checkedExpr = checkedExpr; + this.ast = + CelAbstractSyntaxTree.newCheckedAst( + CelExprV1Alpha1Converter.fromExpr(checkedExpr.getExpr()), + CelSource.newBuilder() + .addAllLineOffsets(checkedExpr.getSourceInfo().getLineOffsetsList()) + .addPositionsMap(checkedExpr.getSourceInfo().getPositionsMap()) + .addAllMacroCalls( + CelExprV1Alpha1Converter.exprMacroCallsToCelExprMacroCalls( + checkedExpr.getSourceInfo().getMacroCallsMap())) + .setDescription(checkedExpr.getSourceInfo().getLocation()) + .build(), + checkedExpr.getReferenceMapMap().entrySet().stream() + .collect( + toImmutableMap( + Entry::getKey, + v -> CelExprV1Alpha1Converter.exprReferenceToCelReference(v.getValue()))), + checkedExpr.getTypeMapMap().entrySet().stream() + .collect( + toImmutableMap( + Entry::getKey, v -> CelV1AlphaTypes.typeToCelType(v.getValue())))); + } + + private CelProtoV1Alpha1AbstractSyntaxTree(CelAbstractSyntaxTree ast) { + this.ast = ast; + + CheckedExpr.Builder checkedExprBuilder = + CheckedExpr.newBuilder() + .setSourceInfo( + SourceInfo.newBuilder() + .setLocation(ast.getSource().getDescription()) + .addAllLineOffsets(ast.getSource().getLineOffsets()) + .putAllMacroCalls( + ast.getSource().getMacroCalls().entrySet().stream() + .collect( + toImmutableMap( + Entry::getKey, + v -> CelExprV1Alpha1Converter.fromCelExpr(v.getValue())))) + .putAllPositions(ast.getSource().getPositionsMap())) + .setExpr(CelExprV1Alpha1Converter.fromCelExpr(ast.getExpr())); + + if (ast.isChecked()) { + checkedExprBuilder.putAllReferenceMap( + ast.getReferenceMap().entrySet().stream() + .collect( + toImmutableMap( + Entry::getKey, + v -> CelExprV1Alpha1Converter.celReferenceToExprReference(v.getValue())))); + checkedExprBuilder.putAllTypeMap( + ast.getTypeMap().entrySet().stream() + .collect( + toImmutableMap(Entry::getKey, v -> CelV1AlphaTypes.celTypeToType(v.getValue())))); + } + + this.checkedExpr = checkedExprBuilder.build(); + } + + /** Construct an abstract syntax tree from a {@link com.google.api.expr.v1alpha1.CheckedExpr}. */ + public static CelProtoV1Alpha1AbstractSyntaxTree fromCheckedExpr(CheckedExpr checkedExpr) { + return new CelProtoV1Alpha1AbstractSyntaxTree(checkedExpr); + } + + /** Construct an abstract syntax tree from a {@link com.google.api.expr.v1alpha1.ParsedExpr}. */ + public static CelProtoV1Alpha1AbstractSyntaxTree fromParsedExpr(ParsedExpr parsedExpr) { + return new CelProtoV1Alpha1AbstractSyntaxTree( + CheckedExpr.newBuilder() + .setExpr(parsedExpr.getExpr()) + .setSourceInfo(parsedExpr.getSourceInfo()) + .build()); + } + + /** Constructs CelProtoAbstractSyntaxTree from {@link CelAbstractSyntaxTree}. */ + public static CelProtoV1Alpha1AbstractSyntaxTree fromCelAst(CelAbstractSyntaxTree ast) { + return new CelProtoV1Alpha1AbstractSyntaxTree(ast); + } + + /** Tests whether the underlying abstract syntax tree has been type checked or not. */ + public boolean isChecked() { + return ast.isChecked(); + } + + /** + * Returns the native representation of the abstract syntax tree: {@link CelAbstractSyntaxTree}. + */ + @CheckReturnValue + public CelAbstractSyntaxTree getAst() { + return ast; + } + + /** Returns the underlying {@link Expr} representation of the abstract syntax tree. */ + @CheckReturnValue + public Expr getExpr() { + return checkedExpr.getExpr(); + } + + /** + * Returns the underlying {@link CheckedExpr} representation of the abstract syntax tree. Throws + * {@link IllegalStateException} if {@link CelAbstractSyntaxTree#isChecked} is false. + */ + @CheckReturnValue + public CheckedExpr toCheckedExpr() { + checkState( + isChecked(), + "CelAbstractSyntaxTree must be checked before it can be converted to CheckedExpr"); + return checkedExpr; + } + + /** Returns the underlying {@link SourceInfo} representation of the abstract syntax tree. */ + @CheckReturnValue + public SourceInfo getSourceInfo() { + return checkedExpr.getSourceInfo(); + } + + /** Returns the underlying {@link ParsedExpr} representation of the abstract syntax tree. */ + @CheckReturnValue + public ParsedExpr toParsedExpr() { + return ParsedExpr.newBuilder().setExpr(getExpr()).setSourceInfo(getSourceInfo()).build(); + } + + /** + * For a type checked abstract syntax tree the resulting type is returned in proto format + * described in checked.proto. Otherwise, the dynamic type is returned. + */ + @CheckReturnValue + public Type getProtoResultType() { + return CelV1AlphaTypes.celTypeToType(ast.getResultType()); + } +} +// LINT.ThenChange(CelProtoAbstractSyntaxTree.java) diff --git a/common/src/main/java/dev/cel/common/CelSource.java b/common/src/main/java/dev/cel/common/CelSource.java new file mode 100644 index 000000000..d64049f61 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelSource.java @@ -0,0 +1,389 @@ +// Copyright 2022 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; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.internal.CelCodePointArray; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** Represents the source content of an expression and related metadata. */ +@Immutable +@AutoValue +public abstract class CelSource implements Source { + + abstract CelCodePointArray codePoints(); + + abstract String description(); + + abstract ImmutableList lineOffsets(); + + abstract ImmutableMap positions(); + + abstract ImmutableMap macroCalls(); + + abstract ImmutableSet extensions(); + + @Override + public CelCodePointArray getContent() { + return codePoints(); + } + + @Override + public String getDescription() { + return description(); + } + + @Override + public ImmutableMap getPositionsMap() { + return positions(); + } + + /** + * Get the code point offsets (NOT code unit offsets) for new line characters '\n' within the + * source expression text. + * + *

NOTE: The indices point to the index just after the '\n' not the index of '\n' itself. + */ + public ImmutableList getLineOffsets() { + return lineOffsets(); + } + + public ImmutableMap getMacroCalls() { + return macroCalls(); + } + + public ImmutableSet getExtensions() { + return extensions(); + } + + /** See {@link #getLocationOffset(int, int)}. */ + public Optional getLocationOffset(CelSourceLocation location) { + checkNotNull(location); + return getLocationOffset(location.getLine(), location.getColumn()); + } + + /** + * Get the code point offset within the source expression text that corresponds with the {@code + * line} and {@code column}. + * + * @param line the line number starting from 1 + * @param column the column number starting from 0 + */ + public Optional getLocationOffset(int line, int column) { + return getLocationOffsetImpl(lineOffsets(), line, column); + } + + /** + * Get the line and column in the source expression text for the given code point {@code offset}. + */ + public Optional getOffsetLocation(int offset) { + return CelSourceHelper.getOffsetLocation(codePoints(), offset); + } + + @Override + public Optional getSnippet(int line) { + return CelSourceHelper.getSnippet(codePoints(), line); + } + + /** + * Get the code point offset within the source expression text that corresponds with the {@code + * line} and {@code column}. + * + * @param line the line number starting from 1 + * @param column the column number starting from 0 + */ + private static Optional getLocationOffsetImpl( + List lineOffsets, int line, int column) { + if (line <= 0 || column < 0) { + return Optional.empty(); + } + int offset = CelSourceHelper.findLineOffset(lineOffsets, line); + if (offset == -1) { + return Optional.empty(); + } + return Optional.of(offset + column); + } + + public Builder toBuilder() { + return new Builder(codePoints(), lineOffsets()) + .setDescription(description()) + .addPositionsMap(positions()) + .addAllExtensions(extensions()) + .addAllMacroCalls(macroCalls()); + } + + public static Builder newBuilder() { + return new Builder(); + } + + public static Builder newBuilder(String text) { + return newBuilder(CelCodePointArray.fromString(text)); + } + + public static Builder newBuilder(CelCodePointArray codePoints) { + return newBuilder(codePoints, codePoints.lineOffsets()); + } + + public static Builder newBuilder( + CelCodePointArray codePoints, ImmutableList lineOffsets) { + return new Builder(codePoints, lineOffsets); + } + + /** Builder for {@link CelSource}. */ + public static final class Builder { + + private final CelCodePointArray codePoints; + private final List lineOffsets; + private final Map positions; + private final Map macroCalls; + private final ImmutableSet.Builder extensions; + + private final boolean lineOffsetsAlreadyComputed; + private String description; + + private Builder() { + this(CelCodePointArray.fromString(""), new ArrayList<>()); + } + + private Builder(CelCodePointArray codePoints, List lineOffsets) { + this.codePoints = checkNotNull(codePoints); + this.lineOffsets = checkNotNull(lineOffsets); + this.positions = new HashMap<>(); + this.macroCalls = new HashMap<>(); + this.extensions = ImmutableSet.builder(); + this.description = ""; + this.lineOffsetsAlreadyComputed = !lineOffsets.isEmpty(); + } + + @CanIgnoreReturnValue + public Builder setDescription(String description) { + this.description = checkNotNull(description); + return this; + } + + @CanIgnoreReturnValue + public Builder addLineOffsets(int lineOffset) { + checkArgument(lineOffset >= 0); + checkState( + !lineOffsetsAlreadyComputed, + "Line offsets were already been computed through the provided code points."); + lineOffsets.add(lineOffset); + return this; + } + + @CanIgnoreReturnValue + public Builder addAllLineOffsets(Iterable lineOffsets) { + for (int lineOffset : lineOffsets) { + addLineOffsets(lineOffset); + } + return this; + } + + @CanIgnoreReturnValue + public Builder addPositionsMap(Map positionsMap) { + checkNotNull(positionsMap); + this.positions.putAll(positionsMap); + return this; + } + + @CanIgnoreReturnValue + public Builder addPositions(long exprId, int position) { + this.positions.put(exprId, position); + return this; + } + + @CanIgnoreReturnValue + public Builder removePositions(long exprId) { + this.positions.remove(exprId); + return this; + } + + @CanIgnoreReturnValue + public Builder addMacroCalls(long exprId, CelExpr expr) { + this.macroCalls.put(exprId, expr); + return this; + } + + @CanIgnoreReturnValue + public Builder addAllMacroCalls(Map macroCalls) { + this.macroCalls.putAll(macroCalls); + return this; + } + + public ImmutableSet getExtensions() { + return extensions.build(); + } + + /** + * Adds one or more {@link Extension}s to the source information. Extensions implement set + * semantics and deduped if same ones are provided. + */ + @CanIgnoreReturnValue + public Builder addAllExtensions(Iterable extensions) { + checkNotNull(extensions); + this.extensions.addAll(extensions); + return this; + } + + /** + * Adds one or more {@link Extension}s to the source information. Extensions implement set + * semantics and deduped if same ones are provided. + */ + @CanIgnoreReturnValue + public Builder addAllExtensions(Extension... extensions) { + return addAllExtensions(Arrays.asList(extensions)); + } + + /** See {@link #getLocationOffset(int, int)}. */ + public Optional getLocationOffset(CelSourceLocation location) { + checkNotNull(location); + return getLocationOffset(location.getLine(), location.getColumn()); + } + + /** + * Get the code point offset within the source expression text that corresponds with the {@code + * line} and {@code column}. + * + * @param line the line number starting from 1 + * @param column the column number starting from 0 + */ + public Optional getLocationOffset(int line, int column) { + return getLocationOffsetImpl(lineOffsets, line, column); + } + + /** + * Get the line and column in the source expression text for the given code point {@code + * offset}. + */ + public Optional getOffsetLocation(int offset) { + return CelSourceHelper.getOffsetLocation(codePoints, offset); + } + + @CheckReturnValue + public Map getPositionsMap() { + return this.positions; + } + + @CheckReturnValue + public Map getMacroCalls() { + return macroCalls; + } + + @CheckReturnValue + public boolean containsMacroCalls(long exprId) { + return this.macroCalls.containsKey(exprId); + } + + @CheckReturnValue + public CelSource build() { + return new AutoValue_CelSource( + codePoints, + description, + ImmutableList.copyOf(lineOffsets), + ImmutableMap.copyOf(positions), + ImmutableMap.copyOf(macroCalls), + extensions.build()); + } + } + + /** + * Tag for an extension that were used while parsing or type checking the source expression. For + * example, optimizations that require special runtime support may be specified. These are used to + * check feature support between components in separate implementations. This can be used to + * either skip redundant work or report an error if the extension is unsupported. + */ + @AutoValue + @Immutable + public abstract static class Extension { + + /** Identifier for the extension. Example: constant_folding */ + abstract String id(); + + /** + * Version info. May be skipped if it isn't meaningful for the extension. (for example + * constant_folding might always be v0.0). + */ + abstract Version version(); + + /** + * If set, the listed components must understand the extension for the expression to evaluate + * correctly. + */ + abstract ImmutableList affectedComponents(); + + /** Version of the extension */ + @AutoValue + @Immutable + public abstract static class Version { + + /** + * Major version changes indicate different required support level from the required + * components. + */ + abstract long major(); + + /** + * Minor version changes must not change the observed behavior from existing implementations, + * but may be provided informational. + */ + abstract long minor(); + + /** Create a new instance of Version with the provided major and minor values. */ + public static Version of(long major, long minor) { + return new AutoValue_CelSource_Extension_Version(major, minor); + } + } + + /** CEL component specifier. */ + public enum Component { + /** Unspecified, default. */ + COMPONENT_UNSPECIFIED, + /** Parser. Converts a CEL string to an AST. */ + COMPONENT_PARSER, + /** Type checker. Checks that references in an AST are defined and types agree. */ + COMPONENT_TYPE_CHECKER, + /** Runtime. Evaluates a parsed and optionally checked CEL AST against a context. */ + COMPONENT_RUNTIME + } + + @CheckReturnValue + public static Extension create(String id, Version version, Iterable components) { + checkNotNull(version); + checkNotNull(components); + return new AutoValue_CelSource_Extension(id, version, ImmutableList.copyOf(components)); + } + + @CheckReturnValue + public static Extension create(String id, Version version, Component... components) { + return create(id, version, Arrays.asList(components)); + } + } +} diff --git a/common/src/main/java/dev/cel/common/CelSourceHelper.java b/common/src/main/java/dev/cel/common/CelSourceHelper.java new file mode 100644 index 000000000..13168edbe --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelSourceHelper.java @@ -0,0 +1,95 @@ +// Copyright 2024 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; + +import static com.google.common.base.Preconditions.checkArgument; + +import com.google.common.collect.ImmutableList; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.CelCodePointArray; +import java.util.List; +import java.util.Optional; + +/** + * Helper methods for common source handling in CEL. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class CelSourceHelper { + + /** Extract the snippet text that corresponds to {@code line}. */ + public static Optional getSnippet(CelCodePointArray content, int line) { + checkArgument(line > 0); + ImmutableList lineOffsets = content.lineOffsets(); + int start = findLineOffset(lineOffsets, line); + if (start == -1) { + return Optional.empty(); + } + int end = findLineOffset(lineOffsets, line + 1); + if (end == -1) { + end = content.size(); + } else { + end--; + } + return Optional.of(end != start ? content.slice(start, end).toString() : ""); + } + + /** + * Get the line and column in the source expression text for the given code point {@code offset}. + */ + public static Optional getOffsetLocation( + CelCodePointArray content, int offset) { + checkArgument(offset >= 0); + LineAndOffset lineAndOffset = findLine(content.lineOffsets(), offset); + return Optional.of(CelSourceLocation.of(lineAndOffset.line, offset - lineAndOffset.offset)); + } + + private static LineAndOffset findLine(List lineOffsets, int offset) { + int line = 1; + for (Integer lineOffset : lineOffsets) { + if (lineOffset > offset) { + break; + } + line++; + } + if (line == 1) { + return new LineAndOffset(line, 0); + } + return new LineAndOffset(line, lineOffsets.get(line - 2)); + } + + private static final class LineAndOffset { + private LineAndOffset(int line, int offset) { + this.line = line; + this.offset = offset; + } + + private final int line; + private final int offset; + } + + static int findLineOffset(List lineOffsets, int line) { + if (line == 1) { + return 0; + } + if (line > 1 && line <= lineOffsets.size()) { + return lineOffsets.get(line - 2); + } + return -1; + } + + private CelSourceHelper() {} +} diff --git a/common/src/main/java/dev/cel/common/CelSourceLocation.java b/common/src/main/java/dev/cel/common/CelSourceLocation.java new file mode 100644 index 000000000..1cce23e08 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelSourceLocation.java @@ -0,0 +1,80 @@ +// Copyright 2022 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; + +import static com.google.common.base.Preconditions.checkArgument; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; + +/** Represents a location within {@link CelSource}. */ +@AutoValue +@Immutable +public abstract class CelSourceLocation implements Comparable { + + public static final CelSourceLocation NONE = CelSourceLocation.of(-1, -1); + + // Package-private default constructor to prevent unexpected extensions outside of this codebase. + CelSourceLocation() {} + + public abstract int getLine(); + + public abstract int getColumn(); + + @Override + public final int compareTo(CelSourceLocation other) { + int otherLine; + int otherColumn; + if (other != null) { + otherLine = positiveOrMax(other.getLine()); + otherColumn = positiveOrMax(other.getColumn()); + } else { + otherLine = Integer.MAX_VALUE; + otherColumn = Integer.MAX_VALUE; + } + int diff = Integer.compare(positiveOrMax(getLine()), otherLine); + if (diff != 0) { + return diff; + } + return Integer.compare(positiveOrMax(getColumn()), otherColumn); + } + + static Builder newBuilder() { + return new AutoValue_CelSourceLocation.Builder(); + } + + public static CelSourceLocation of(int line, int column) { + checkArgument(line >= -1 && line < Integer.MAX_VALUE); + checkArgument(column >= -1 && column < Integer.MAX_VALUE); + return newBuilder().setLine(line).setColumn(column).build(); + } + + /** Package-private builder for {@link CelSourceLocation}. */ + @AutoValue.Builder + abstract static class Builder { + + abstract Builder setLine(int line); + + abstract Builder setColumn(int column); + + @CheckReturnValue + abstract CelSourceLocation build(); + } + + private static int positiveOrMax(int value) { + return value >= 0 ? value : Integer.MAX_VALUE; + } +} diff --git a/common/src/main/java/dev/cel/common/CelValidationException.java b/common/src/main/java/dev/cel/common/CelValidationException.java new file mode 100644 index 000000000..18bec2fe6 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelValidationException.java @@ -0,0 +1,65 @@ +// Copyright 2022 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; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; +import java.util.List; + +/** Base class for all checked exceptions explicitly thrown by the library during parsing. */ +public final class CelValidationException extends CelException { + + // Truncates all errors beyond this limit in the message. + private static final int MAX_ERRORS_TO_REPORT = 100; + + private final CelSource source; + private final ImmutableList errors; + + @VisibleForTesting + public CelValidationException(CelSource source, List errors) { + super(safeJoinErrorMessage(source, errors)); + this.source = source; + this.errors = ImmutableList.copyOf(errors); + } + + CelValidationException( + CelSource source, Iterable errors, String message, Throwable cause) { + super(message, cause); + this.source = source; + this.errors = ImmutableList.copyOf(errors); + } + + private static String safeJoinErrorMessage(CelSource source, List errors) { + if (errors.size() <= MAX_ERRORS_TO_REPORT) { + return CelIssue.toDisplayString(errors, source); + } + + List truncatedErrors = errors.subList(0, MAX_ERRORS_TO_REPORT); + + return CelIssue.toDisplayString(truncatedErrors, source) + + String.format( + "%n...and %d more errors (truncated)", errors.size() - MAX_ERRORS_TO_REPORT); + } + + /** Returns the {@link CelSource} that was being validated. */ + public CelSource getSource() { + return source; + } + + /** Returns a list of {@link CelIssue} with error severity that occurred during validation. */ + public ImmutableList getErrors() { + return errors; + } +} diff --git a/common/src/main/java/dev/cel/common/CelValidationResult.java b/common/src/main/java/dev/cel/common/CelValidationResult.java new file mode 100644 index 000000000..61152c493 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelValidationResult.java @@ -0,0 +1,136 @@ +// Copyright 2022 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; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static java.util.Comparator.comparing; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.errorprone.annotations.InlineMe; +import dev.cel.common.annotations.Internal; +import org.jspecify.annotations.Nullable; + +/** + * CelValidationResult encapsulates the {@code CelAbstractSyntaxTree} and {@code CelIssue} set which + * may be generated during the parse and check phases. + */ +@Immutable +public final class CelValidationResult { + + @SuppressWarnings("Immutable") + private final @Nullable Throwable failure; + + private final @Nullable CelAbstractSyntaxTree ast; + private final CelSource source; + private final ImmutableList issues; + private final boolean hasError; + + /** Internal: Consumers should not be creating an instance of this class directly. */ + @Internal + public CelValidationResult(CelSource source, ImmutableList issues) { + this(/* ast= */ null, source, issues, /* failure= */ null); + } + + /** Internal: Consumers should not be creating an instance of this class directly. */ + @Internal + public CelValidationResult(CelSource source, Throwable failure, ImmutableList issues) { + this(/* ast= */ null, source, issues, failure); + } + + /** Internal: Consumers should not be creating an instance of this class on their own */ + @Internal + public CelValidationResult(CelAbstractSyntaxTree ast, ImmutableList issues) { + this(ast, ast.getSource(), issues, /* failure= */ null); + } + + private CelValidationResult( + @Nullable CelAbstractSyntaxTree ast, + CelSource source, + ImmutableList issues, + @Nullable Throwable failure) { + this.ast = ast; + this.source = source; + this.issues = ImmutableList.sortedCopyOf(comparing(CelIssue::getSourceLocation), issues); + this.hasError = issues.stream().anyMatch(CelValidationResult::issueIsError) || failure != null; + this.failure = failure; + } + + /** + * Returns the validated {@code CelAbstractSyntaxTree} if one exists. + * + *

When {@link #hasError} returns {@code true}, this accessor will throw a {@link + * CelValidationException} containing the error set which prevented AST generation. + */ + @CanIgnoreReturnValue + public CelAbstractSyntaxTree getAst() throws CelValidationException { + if (hasError) { + if (failure != null) { + throw new CelValidationException(source, getErrors(), failure.getMessage(), failure); + } + throw new CelValidationException(source, getErrors()); + } + return ast; + } + + /** Return the {@code CelSource} associated with the result. */ + public CelSource getSource() { + return source; + } + + /** + * Whether a {@code CelIssue} with an {@link CelIssue.Severity#ERROR} severity was encountered + * during validation. + */ + public boolean hasError() { + return hasError; + } + + /** Return the set of {@code CelIssue}s with an {@code ERROR} severity. */ + public ImmutableList getErrors() { + return issues.stream().filter(CelValidationResult::issueIsError).collect(toImmutableList()); + } + + /** Return all {@code CelIssue}s encountered durint validation. */ + public ImmutableList getAllIssues() { + return issues; + } + + /** Convert all issues to a human-readable string. */ + public String getIssueString() { + return CelIssue.toDisplayString(issues, source); + } + + /** + * Convert the {@code CelIssue} set to a debug string. + * + * @deprecated Use {@link #getIssueString()} instead. + */ + @Deprecated + @InlineMe(replacement = "this.getIssueString()") + public String getDebugString() { + return getIssueString(); + } + + /** Convert the {@code CelIssue}s with {@code ERROR} severity to an error string. */ + public String getErrorString() { + return CelIssue.toDisplayString(getErrors(), source); + } + + private static boolean issueIsError(CelIssue iss) { + return iss.getSeverity() == CelIssue.Severity.ERROR; + } +} diff --git a/common/src/main/java/dev/cel/common/CelVarDecl.java b/common/src/main/java/dev/cel/common/CelVarDecl.java new file mode 100644 index 000000000..0543ed225 --- /dev/null +++ b/common/src/main/java/dev/cel/common/CelVarDecl.java @@ -0,0 +1,36 @@ +// Copyright 2022 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; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.types.CelType; + +/** Abstract representation of a CEL variable declaration. */ +@AutoValue +public abstract class CelVarDecl { + + /** Fully qualified variable name. */ + public abstract String name(); + + /** The type of the variable. */ + public abstract CelType type(); + + /** Create a new {@code CelVarDecl} with a given {@code name} and {@code type}. */ + @CheckReturnValue + public static CelVarDecl newVarDeclaration(String name, CelType type) { + return new AutoValue_CelVarDecl(name, type); + } +} diff --git a/common/src/main/java/dev/cel/common/Operator.java b/common/src/main/java/dev/cel/common/Operator.java new file mode 100644 index 000000000..c49c78267 --- /dev/null +++ b/common/src/main/java/dev/cel/common/Operator.java @@ -0,0 +1,218 @@ +// Copyright 2025 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; + +import com.google.common.collect.ImmutableMap; +import java.util.Objects; +import java.util.Optional; + +/** + * Package-private enumeration of Common Expression Language operators. + * + *

Equivalent to operators. + */ +public enum Operator { + CONDITIONAL("_?_:_"), + LOGICAL_AND("_&&_", "&&"), + LOGICAL_OR("_||_", "||"), + LOGICAL_NOT("!_", "!"), + EQUALS("_==_", "=="), + NOT_EQUALS("_!=_", "!="), + LESS("_<_", "<"), + LESS_EQUALS("_<=_", "<="), + GREATER("_>_", ">"), + GREATER_EQUALS("_>=_", ">="), + ADD("_+_", "+"), + SUBTRACT("_-_", "-"), + MULTIPLY("_*_", "*"), + DIVIDE("_/_", "/"), + MODULO("_%_", "%"), + NEGATE("-_", "-"), + INDEX("_[_]"), + HAS("has"), + ALL("all"), + EXISTS("exists"), + @Deprecated // Prefer EXISTS_ONE_NEW. + EXISTS_ONE("exists_one"), + EXISTS_ONE_NEW("existsOne"), + MAP("map"), + FILTER("filter"), + NOT_STRICTLY_FALSE("@not_strictly_false"), + IN("@in", "in"), + OPTIONAL_INDEX("_[?_]"), + OPTIONAL_SELECT("_?._"), + @Deprecated // Prefer NOT_STRICTLY_FALSE. + OLD_NOT_STRICTLY_FALSE("__not_strictly_false__"), + @Deprecated // Prefer IN. + OLD_IN("_in_"); + + private final String functionName; + private final String displayName; + + Operator(String functionName) { + this(functionName, ""); + } + + Operator(String functionName, String displayName) { + this.functionName = functionName; + this.displayName = displayName; + } + + /** Returns the mangled operator name, as used within the AST. */ + public String getFunction() { + return functionName; + } + + /** Returns the unmangled operator name, as used within the source text of an expression. */ + String getSymbol() { + return displayName; + } + + private static final ImmutableMap OPERATORS = + ImmutableMap.builder() + .put(ADD.getSymbol(), ADD) + .put(DIVIDE.getSymbol(), DIVIDE) + .put(EQUALS.getSymbol(), EQUALS) + .put(GREATER.getSymbol(), GREATER) + .put(GREATER_EQUALS.getSymbol(), GREATER_EQUALS) + .put(IN.getSymbol(), IN) + .put(LESS.getSymbol(), LESS) + .put(LESS_EQUALS.getSymbol(), LESS_EQUALS) + .put(MODULO.getSymbol(), MODULO) + .put(MULTIPLY.getSymbol(), MULTIPLY) + .put(NOT_EQUALS.getSymbol(), NOT_EQUALS) + .put(SUBTRACT.getSymbol(), SUBTRACT) + .buildOrThrow(); + + /** Lookup an operator by its unmangled name, as used with the source text of an expression. */ + public static Optional find(String text) { + return Optional.ofNullable(OPERATORS.get(text)); + } + + private static final ImmutableMap REVERSE_OPERATORS = + ImmutableMap.builder() + .put(ADD.getFunction(), ADD) + .put(ALL.getFunction(), ALL) + .put(CONDITIONAL.getFunction(), CONDITIONAL) + .put(DIVIDE.getFunction(), DIVIDE) + .put(EQUALS.getFunction(), EQUALS) + .put(EXISTS.getFunction(), EXISTS) + .put(EXISTS_ONE.getFunction(), EXISTS_ONE) + .put(EXISTS_ONE_NEW.getFunction(), EXISTS_ONE_NEW) + .put(FILTER.getFunction(), FILTER) + .put(GREATER.getFunction(), GREATER) + .put(GREATER_EQUALS.getFunction(), GREATER_EQUALS) + .put(HAS.getFunction(), HAS) + .put(IN.getFunction(), IN) + .put(INDEX.getFunction(), INDEX) + .put(LESS.getFunction(), LESS) + .put(LESS_EQUALS.getFunction(), LESS_EQUALS) + .put(LOGICAL_AND.getFunction(), LOGICAL_AND) + .put(LOGICAL_NOT.getFunction(), LOGICAL_NOT) + .put(LOGICAL_OR.getFunction(), LOGICAL_OR) + .put(MAP.getFunction(), MAP) + .put(MODULO.getFunction(), MODULO) + .put(MULTIPLY.getFunction(), MULTIPLY) + .put(NEGATE.getFunction(), NEGATE) + .put(NOT_EQUALS.getFunction(), NOT_EQUALS) + .put(NOT_STRICTLY_FALSE.getFunction(), NOT_STRICTLY_FALSE) + .put(OLD_IN.getFunction(), OLD_IN) + .put(OLD_NOT_STRICTLY_FALSE.getFunction(), OLD_NOT_STRICTLY_FALSE) + .put(OPTIONAL_INDEX.getFunction(), OPTIONAL_INDEX) + .put(OPTIONAL_SELECT.getFunction(), OPTIONAL_SELECT) + .put(SUBTRACT.getFunction(), SUBTRACT) + .buildOrThrow(); + + // precedence of the operator, where the higher value means higher. + private static final ImmutableMap PRECEDENCES = + ImmutableMap.builder() + .put(CONDITIONAL.getFunction(), 8) + .put(LOGICAL_OR.getFunction(), 7) + .put(LOGICAL_AND.getFunction(), 6) + .put(EQUALS.getFunction(), 5) + .put(GREATER.getFunction(), 5) + .put(GREATER_EQUALS.getFunction(), 5) + .put(IN.getFunction(), 5) + .put(LESS.getFunction(), 5) + .put(LESS_EQUALS.getFunction(), 5) + .put(NOT_EQUALS.getFunction(), 5) + .put(ADD.getFunction(), 4) + .put(SUBTRACT.getFunction(), 4) + .put(DIVIDE.getFunction(), 3) + .put(MODULO.getFunction(), 3) + .put(MULTIPLY.getFunction(), 3) + .put(LOGICAL_NOT.getFunction(), 2) + .put(NEGATE.getFunction(), 2) + .put(INDEX.getFunction(), 1) + .buildOrThrow(); + + private static final ImmutableMap UNARY_OPERATORS = + ImmutableMap.builder() + .put(NEGATE.getFunction(), "-") + .put(LOGICAL_NOT.getFunction(), "!") + .buildOrThrow(); + + private static final ImmutableMap BINARY_OPERATORS = + ImmutableMap.builder() + .put(LOGICAL_OR.getFunction(), "||") + .put(LOGICAL_AND.getFunction(), "&&") + .put(LESS_EQUALS.getFunction(), "<=") + .put(LESS.getFunction(), "<") + .put(GREATER_EQUALS.getFunction(), ">=") + .put(GREATER.getFunction(), ">") + .put(EQUALS.getFunction(), "==") + .put(NOT_EQUALS.getFunction(), "!=") + .put(IN.getFunction(), "in") + .put(ADD.getFunction(), "+") + .put(SUBTRACT.getFunction(), "-") + .put(MULTIPLY.getFunction(), "*") + .put(DIVIDE.getFunction(), "/") + .put(MODULO.getFunction(), "%") + .buildOrThrow(); + + /** Lookup an operator by its mangled name (ex: _&&_), as used within the AST. */ + public static Optional findReverse(String op) { + return Optional.ofNullable(REVERSE_OPERATORS.get(op)); + } + + /** Lookup a binary operator by its mangled name, as used within the AST. */ + static Optional findReverseBinaryOperator(String op) { + if (Objects.equals(op, LOGICAL_NOT.getFunction()) || Objects.equals(op, NEGATE.getFunction())) { + return Optional.empty(); + } + return Optional.ofNullable(REVERSE_OPERATORS.get(op)); + } + + /** + * Returns the precedence of the operator. + * + * @return Integer value describing precedence. Higher value means higher precedence. Returns 0 if + * the operator is not found. + */ + public static int lookupPrecedence(String op) { + return PRECEDENCES.getOrDefault(op, 0); + } + + /** Looks up the associated unary operator based on its function name (Ex: !_ -> !) */ + public static Optional lookupUnaryOperator(String op) { + return Optional.ofNullable(UNARY_OPERATORS.get(op)); + } + + /** Looks up the associated binary operator based on its function name (Ex: _||_ -> ||) */ + public static Optional lookupBinaryOperator(String op) { + return Optional.ofNullable(BINARY_OPERATORS.get(op)); + } +} diff --git a/common/src/main/java/dev/cel/common/Source.java b/common/src/main/java/dev/cel/common/Source.java new file mode 100644 index 000000000..2d43a9581 --- /dev/null +++ b/common/src/main/java/dev/cel/common/Source.java @@ -0,0 +1,52 @@ +// Copyright 2024 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; + +import com.google.common.collect.ImmutableMap; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.CelCodePointArray; +import java.util.Optional; + +/** + * Common interface definition for source properties. + * + *

CEL Library Internals. Do Not Use. Consumers should instead use the canonical implementations + * such as CelSource. + */ +@Internal +public interface Source { + + /** Gets the original textual content of this source, represented in an array of code points. */ + CelCodePointArray getContent(); + + /** + * Gets the description of this source that may optionally be set (example: location of the file + * containing the source). + */ + String getDescription(); + + /** + * Gets the map of each parsed node ID (ex: expression ID, policy ID) to their source positions. + */ + ImmutableMap getPositionsMap(); + + /** + * Get the text from the source text that corresponds to {@code line}. Snippets are split based on + * the newline ('\n'). + * + * @param line the line number starting from 1. + */ + Optional getSnippet(int line); +} diff --git a/common/src/main/java/dev/cel/common/annotations/BUILD.bazel b/common/src/main/java/dev/cel/common/annotations/BUILD.bazel new file mode 100644 index 000000000..6188b7e96 --- /dev/null +++ b/common/src/main/java/dev/cel/common/annotations/BUILD.bazel @@ -0,0 +1,25 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//common/annotations:__pkg__", + ], +) + +# keep sorted +ANNOTATION_SOURCES = [ + "Beta.java", + "Generated.java", + "Internal.java", +] + +java_library( + name = "annotations", + srcs = ANNOTATION_SOURCES, + # used_by_android + tags = [ + ], +) diff --git a/common/src/main/java/dev/cel/common/annotations/Beta.java b/common/src/main/java/dev/cel/common/annotations/Beta.java new file mode 100644 index 000000000..dc2ed809b --- /dev/null +++ b/common/src/main/java/dev/cel/common/annotations/Beta.java @@ -0,0 +1,38 @@ +// Copyright 2025 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.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Indicates a public API that can change at any time, and has no guarantee of API stability and + * backward-compatibility. + * + *

Note: This annotation is intended only for CEL library code. Users should not attach this + * annotation to their own code. + */ +@Retention(RetentionPolicy.CLASS) +@Target({ + ElementType.ANNOTATION_TYPE, + ElementType.CONSTRUCTOR, + ElementType.FIELD, + ElementType.METHOD, + ElementType.PACKAGE, + ElementType.TYPE +}) +public @interface Beta {} diff --git a/common/src/main/java/dev/cel/common/annotations/Generated.java b/common/src/main/java/dev/cel/common/annotations/Generated.java new file mode 100644 index 000000000..74c782d80 --- /dev/null +++ b/common/src/main/java/dev/cel/common/annotations/Generated.java @@ -0,0 +1,40 @@ +// Copyright 2025 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.annotations; + +import static java.lang.annotation.ElementType.ANNOTATION_TYPE; +import static java.lang.annotation.ElementType.CONSTRUCTOR; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PACKAGE; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.SOURCE; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * Annotates that the source code is generated by CEL. + * + *

Note: This annotation is intended only for CEL library code. Users should not attach this + * annotation to their own code. + */ +@Retention(SOURCE) +@Target({PACKAGE, TYPE, ANNOTATION_TYPE, METHOD, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, PARAMETER}) +public @interface Generated { + String[] value(); +} diff --git a/common/src/main/java/dev/cel/common/annotations/Internal.java b/common/src/main/java/dev/cel/common/annotations/Internal.java new file mode 100644 index 000000000..60dd071bb --- /dev/null +++ b/common/src/main/java/dev/cel/common/annotations/Internal.java @@ -0,0 +1,40 @@ +// Copyright 2022 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.annotations; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Annotates a program element (class, method, package, etc) which is internal to CEL, not part of + * the public API, and should not be used by users of CEL. + * + *

Note: This annotation is intended only for CEL library code. Users should not attach this + * annotation to their own code. + */ +@Retention(RetentionPolicy.CLASS) +@Target({ + ElementType.ANNOTATION_TYPE, + ElementType.CONSTRUCTOR, + ElementType.FIELD, + ElementType.METHOD, + ElementType.PACKAGE, + ElementType.TYPE +}) +@Documented +public @interface Internal {} diff --git a/common/src/main/java/dev/cel/common/ast/BUILD.bazel b/common/src/main/java/dev/cel/common/ast/BUILD.bazel new file mode 100644 index 000000000..3fc709a07 --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/BUILD.bazel @@ -0,0 +1,156 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//common/ast:__pkg__", + ], +) + +# keep sorted +AST_SOURCES = [ + "CelConstant.java", + "CelExpr.java", + "CelExprFormatter.java", + "CelReference.java", + "Expression.java", +] + +# keep sorted +EXPR_CONVERTER_SOURCES = [ + "CelExprConverter.java", +] + +# keep sorted +EXPR_V1ALPHA1_CONVERTER_SOURCES = [ + "CelExprV1Alpha1Converter.java", +] + +# keep sorted +EXPR_FACTORY_SOURCES = [ + "CelExprFactory.java", + "CelExprIdGeneratorFactory.java", +] + +# keep sorted +MUTABLE_EXPR_SOURCES = [ + "CelMutableExpr.java", + "CelMutableExprConverter.java", +] + +java_library( + name = "ast", + srcs = AST_SOURCES, + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "//common/values", + "//common/values:cel_byte_string", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "expr_converter", + srcs = EXPR_CONVERTER_SOURCES, + tags = [ + ], + deps = [ + ":ast", + "//common/values", + "//common/values:cel_byte_string", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "expr_converter_android", + srcs = EXPR_CONVERTER_SOURCES, + tags = [ + ], + deps = [ + ":ast_android", + "//common/values:cel_byte_string", + "//common/values:values_android", + "@cel_spec//proto/cel/expr:checked_java_proto_lite", + "@cel_spec//proto/cel/expr:syntax_java_proto_lite", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "expr_v1alpha1_converter", + srcs = EXPR_V1ALPHA1_CONVERTER_SOURCES, + tags = [ + ], + deps = [ + ":ast", + "//common/values", + "//common/values:cel_byte_string", + "@com_google_googleapis//google/api/expr/v1alpha1:expr_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "cel_expr_visitor", + srcs = ["CelExprVisitor.java"], + tags = [ + ], + deps = [ + ":ast", + "//common:cel_ast", + ], +) + +java_library( + name = "expr_factory", + srcs = EXPR_FACTORY_SOURCES, + tags = [ + ], + deps = [ + ":ast", + "//common/annotations", + "//common/values:cel_byte_string", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "mutable_expr", + srcs = MUTABLE_EXPR_SOURCES, + tags = [ + ], + deps = [ + ":ast", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "ast_android", + srcs = AST_SOURCES, + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "//common/values:cel_byte_string", + "//common/values:values_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) diff --git a/common/src/main/java/dev/cel/common/ast/CelConstant.java b/common/src/main/java/dev/cel/common/ast/CelConstant.java new file mode 100644 index 000000000..c27f4ff8f --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelConstant.java @@ -0,0 +1,210 @@ +// Copyright 2023 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.ast; + +import com.google.auto.value.AutoOneOf; +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import com.google.errorprone.annotations.InlineMe; +import com.google.protobuf.ByteString; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.annotations.Internal; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; + +/** + * Represents a primitive literal. + * + *

This is the CEL-Java native type equivalent of Constant message type from syntax.proto. + */ +@AutoOneOf(CelConstant.Kind.class) +@Internal +@Immutable +public abstract class CelConstant { + private static final ImmutableSet> CONSTANT_CLASSES = + ImmutableSet.of( + NullValue.class, + Boolean.class, + Long.class, + UnsignedLong.class, + Double.class, + String.class, + CelByteString.class); + + /** Represents the type of the Constant */ + public enum Kind { + NOT_SET, + NULL_VALUE, + BOOLEAN_VALUE, + INT64_VALUE, + UINT64_VALUE, + DOUBLE_VALUE, + STRING_VALUE, + BYTES_VALUE, + /** + * @deprecated Do not use. Timestamp is no longer built-in CEL type. + */ + @Deprecated + TIMESTAMP_VALUE, + /** + * @deprecated Do not use. Duration is no longer built-in CEL type. + */ + @Deprecated + DURATION_VALUE + } + + public abstract Kind getKind(); + + /** + * An unset constant. + * + *

As the name implies, this constant does nothing. This is used to represent a default + * instance of CelConstant. + */ + @AutoValue + @Immutable + public abstract static class CelConstantNotSet {} + + public abstract CelConstantNotSet notSet(); + + public abstract NullValue nullValue(); + + public abstract boolean booleanValue(); + + public abstract long int64Value(); + + public abstract UnsignedLong uint64Value(); + + public abstract double doubleValue(); + + public abstract String stringValue(); + + public abstract CelByteString bytesValue(); + + /** + * @deprecated Do not use. Timestamp is no longer built-in CEL type. + */ + @Deprecated + public abstract Timestamp timestampValue(); + + /** + * @deprecated Do not use. Duration is no longer built-in CEL type. + */ + @Deprecated + public abstract Duration durationValue(); + + public static CelConstant ofNotSet() { + return AutoOneOf_CelConstant.notSet(new AutoValue_CelConstant_CelConstantNotSet()); + } + + public static CelConstant ofValue(NullValue value) { + return AutoOneOf_CelConstant.nullValue(value); + } + + public static CelConstant ofValue(boolean value) { + return AutoOneOf_CelConstant.booleanValue(value); + } + + public static CelConstant ofValue(long value) { + return AutoOneOf_CelConstant.int64Value(value); + } + + public static CelConstant ofValue(UnsignedLong value) { + return AutoOneOf_CelConstant.uint64Value(value); + } + + public static CelConstant ofValue(double value) { + return AutoOneOf_CelConstant.doubleValue(value); + } + + public static CelConstant ofValue(String value) { + return AutoOneOf_CelConstant.stringValue(value); + } + + public static CelConstant ofValue(CelByteString value) { + return AutoOneOf_CelConstant.bytesValue(value); + } + + /** + * @deprecated Use native type equivalent {@link #ofValue(NullValue)} instead. + */ + @InlineMe( + replacement = "CelConstant.ofValue(NullValue.NULL_VALUE)", + imports = {"dev.cel.common.ast.CelConstant", "dev.cel.common.values.NullValue"}) + @Deprecated + public static CelConstant ofValue(com.google.protobuf.NullValue unused) { + return ofValue(NullValue.NULL_VALUE); + } + + /** + * @deprecated Use native type equivalent {@link #ofValue(CelByteString)} instead. + */ + @Deprecated + public static CelConstant ofValue(ByteString value) { + CelByteString celByteString = CelByteString.of(value.toByteArray()); + return ofValue(celByteString); + } + + /** + * @deprecated Do not use. Duration is no longer built-in CEL type. + */ + @Deprecated + public static CelConstant ofValue(Duration value) { + return AutoOneOf_CelConstant.durationValue(value); + } + + /** + * @deprecated Do not use. Timestamp is no longer built-in CEL type. + */ + @Deprecated + public static CelConstant ofValue(Timestamp value) { + return AutoOneOf_CelConstant.timestampValue(value); + } + + /** Checks whether the provided Java object is a valid CelConstant value. */ + public static boolean isConstantValue(Object value) { + return CONSTANT_CLASSES.contains(value.getClass()); + } + + /** + * Converts the given Java object into a CelConstant value. This is equivalent of calling {@link + * CelConstant#ofValue} with concrete types. + * + * @throws IllegalArgumentException If the value is not a supported CelConstant. This includes the + * deprecated duration and timestamp values. + */ + public static CelConstant ofObjectValue(Object value) { + if (value instanceof NullValue) { + return ofValue((NullValue) value); + } else if (value instanceof Boolean) { + return ofValue((boolean) value); + } else if (value instanceof Long) { + return ofValue((long) value); + } else if (value instanceof UnsignedLong) { + return ofValue((UnsignedLong) value); + } else if (value instanceof Double) { + return ofValue((double) value); + } else if (value instanceof String) { + return ofValue((String) value); + } else if (value instanceof CelByteString) { + return ofValue((CelByteString) value); + } + + throw new IllegalArgumentException("Value is not a CelConstant: " + value); + } +} diff --git a/common/src/main/java/dev/cel/common/ast/CelExpr.java b/common/src/main/java/dev/cel/common/ast/CelExpr.java new file mode 100644 index 000000000..cac968686 --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelExpr.java @@ -0,0 +1,1125 @@ +// Copyright 2023 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.ast; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.auto.value.AutoOneOf; +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Optional; + +/** + * An abstract representation of a common expression. Refer to {@link Expression} for details. + * + *

This is the native type equivalent of Expr message in syntax.proto. + */ +@AutoValue +@AutoValue.CopyAnnotations +@Immutable +@SuppressWarnings("unchecked") // Class ensures only the super type is used +public abstract class CelExpr implements Expression { + + @Override + public abstract long id(); + + /** Represents the variant of the expression. */ + public abstract ExprKind exprKind(); + + @Override + public ExprKind.Kind getKind() { + return exprKind().getKind(); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException if expression is not {@link Kind#CONSTANT}. + */ + @Override + public CelConstant constant() { + return exprKind().constant(); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException if expression is not {@link Kind#IDENT}. + */ + @Override + public CelIdent ident() { + return exprKind().ident(); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException if expression is not {@link Kind#SELECT}. + */ + @Override + public CelSelect select() { + return exprKind().select(); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException if expression is not {@link Kind#CALL}. + */ + @Override + public CelCall call() { + return exprKind().call(); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException if expression is not {@link Kind#LIST}. + */ + @Override + public CelList list() { + return exprKind().list(); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException if expression is not {@link Kind#STRUCT}. + */ + @Override + public CelStruct struct() { + return exprKind().struct(); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException if expression is not {@link Kind#MAP}. + */ + @Override + public CelMap map() { + return exprKind().map(); + } + + /** + * {@inheritDoc} + * + * @throws UnsupportedOperationException if expression is not {@link Kind#COMPREHENSION}. + */ + @Override + public CelComprehension comprehension() { + return exprKind().comprehension(); + } + + /** + * Gets the underlying constant expression or a default instance of one if expression is not + * {@link Kind#CONSTANT}. + */ + public CelConstant constantOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.CONSTANT) + ? exprKind().constant() + : CelConstant.ofNotSet(); + } + + /** + * Gets the underlying identifier expression or a default instance of one if expression is not + * {@link Kind#IDENT}. + */ + public CelIdent identOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.IDENT) + ? exprKind().ident() + : CelIdent.newBuilder().build(); + } + + /** + * Gets the underlying select expression or a default instance of one if expression is not {@link + * Kind#SELECT}. + */ + public CelSelect selectOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.SELECT) + ? exprKind().select() + : CelSelect.newBuilder().build(); + } + + /** + * Gets the underlying call expression or a default instance of one if expression is not {@link + * Kind#CALL}. + */ + public CelCall callOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.CALL) + ? exprKind().call() + : CelCall.newBuilder().build(); + } + + /** + * Gets the underlying list expression or a default instance of one if expression is not {@link + * Kind#LIST}. + */ + public CelList listOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.LIST) + ? exprKind().list() + : CelList.newBuilder().build(); + } + + /** + * Gets the underlying struct expression or a default instance of one if expression is not {@link + * Kind#STRUCT}. + */ + public CelStruct structOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.STRUCT) + ? exprKind().struct() + : CelStruct.newBuilder().build(); + } + + /** + * Gets the underlying map expression or a default instance of one if expression is not {@link + * Kind#MAP}. + */ + public CelMap mapOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.MAP) + ? exprKind().map() + : CelMap.newBuilder().build(); + } + + /** + * Gets the underlying comprehension expression or a default instance of one if expression is not + * {@link Kind#COMPREHENSION}. + */ + public CelComprehension comprehensionOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.COMPREHENSION) + ? exprKind().comprehension() + : CelComprehension.newBuilder().build(); + } + + /** Builder for CelExpr. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract long id(); + + public abstract Builder setId(long value); + + public abstract Builder setExprKind(ExprKind value); + + public abstract ExprKind exprKind(); + + /** + * Gets the underlying constant expression. + * + * @throws UnsupportedOperationException if expression is not {@link Kind#CONSTANT}. + */ + public CelConstant constant() { + return exprKind().constant(); + } + + /** + * Gets the underlying identifier expression. + * + * @throws UnsupportedOperationException if expression is not {@link Kind#IDENT}. + */ + public CelIdent ident() { + return exprKind().ident(); + } + + /** + * Gets the underlying select expression. + * + * @throws UnsupportedOperationException if expression is not {@link Kind#SELECT}. + */ + public CelSelect select() { + return exprKind().select(); + } + + /** + * Gets the underlying call expression. + * + * @throws UnsupportedOperationException if expression is not {@link Kind#CALL}. + */ + public CelCall call() { + return exprKind().call(); + } + + /** + * Gets the underlying list expression. + * + * @throws UnsupportedOperationException if expression is not {@link Kind#LIST}. + */ + public CelList list() { + return exprKind().list(); + } + + /** + * Gets the underlying struct expression. + * + * @throws UnsupportedOperationException if expression is not {@link Kind#STRUCT}. + */ + public CelStruct struct() { + return exprKind().struct(); + } + + /** + * Gets the underlying map expression. + * + * @throws UnsupportedOperationException if expression is not {@link Kind#MAP}. + */ + public CelMap map() { + return exprKind().map(); + } + + /** + * Gets the underlying comprehension expression. + * + * @throws UnsupportedOperationException if expression is not {@link Kind#COMPREHENSION}. + */ + public CelComprehension comprehension() { + return exprKind().comprehension(); + } + + @CanIgnoreReturnValue + public Builder setConstant(CelConstant constant) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.constant(constant)); + } + + @CanIgnoreReturnValue + public Builder setIdent(CelIdent ident) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.ident(ident)); + } + + @CanIgnoreReturnValue + public Builder setCall(CelCall call) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.call(call)); + } + + @CanIgnoreReturnValue + public Builder setSelect(CelSelect select) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.select(select)); + } + + @CanIgnoreReturnValue + public Builder setList(CelList list) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.list(list)); + } + + @CanIgnoreReturnValue + public Builder setStruct(CelStruct struct) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.struct(struct)); + } + + @CanIgnoreReturnValue + public Builder setMap(CelMap map) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.map(map)); + } + + @CanIgnoreReturnValue + public Builder setComprehension(CelComprehension comprehension) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.comprehension(comprehension)); + } + + @CheckReturnValue + public abstract CelExpr build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder() { + return new AutoValue_CelExpr.Builder() + .setId(0) + .setExprKind(AutoOneOf_CelExpr_ExprKind.notSet(new AutoValue_CelExpr_CelNotSet())); + } + + /** Denotes the kind of the expression. An expression can only be of one kind. */ + @AutoOneOf(CelExpr.ExprKind.Kind.class) + @Immutable + public abstract static class ExprKind { + + /** Expression kind. */ + public enum Kind { + NOT_SET, + CONSTANT, + IDENT, + SELECT, + CALL, + LIST, + STRUCT, + MAP, + COMPREHENSION, + } + + public abstract ExprKind.Kind getKind(); + + public abstract CelNotSet notSet(); + + public abstract CelConstant constant(); + + public abstract CelIdent ident(); + + public abstract CelSelect select(); + + public abstract CelCall call(); + + public abstract CelList list(); + + public abstract CelStruct struct(); + + public abstract CelMap map(); + + public abstract CelComprehension comprehension(); + } + + /** + * An unset expression. + * + *

As the name implies, this expression does nothing. This only exists to maintain + * compatibility between Expr proto to native CelExpr conversion + */ + @AutoValue + @Immutable + public abstract static class CelNotSet {} + + /** An identifier expression. e.g. `request`. */ + @AutoValue + @Immutable + public abstract static class CelIdent implements Ident { + + @Override + public abstract String name(); + + /** Builder for CelIdent. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setName(String value); + + @CheckReturnValue + public abstract CelIdent build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder() { + return new AutoValue_CelExpr_CelIdent.Builder().setName(""); + } + } + + /** A field selection expression. e.g. `request.auth`. */ + @AutoValue + @Immutable + public abstract static class CelSelect implements Expression.Select { + + @Override + public abstract CelExpr operand(); + + @Override + public abstract String field(); + + @Override + public abstract boolean testOnly(); + + /** Builder for CelSelect. */ + @AutoValue.Builder + public abstract static class Builder { + public abstract CelExpr operand(); + + public abstract String field(); + + public abstract boolean testOnly(); + + public abstract Builder setOperand(CelExpr value); + + public abstract Builder setField(String value); + + public abstract Builder setTestOnly(boolean value); + + @CheckReturnValue + public abstract CelSelect build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder() { + return new AutoValue_CelExpr_CelSelect.Builder() + .setField("") + .setOperand(CelExpr.newBuilder().build()) + .setTestOnly(false); + } + } + + /** A call expression. See {@link Expression.Call} */ + @AutoValue + @Immutable + public abstract static class CelCall implements Expression.Call { + + @Override + public abstract Optional target(); + + @Override + public abstract String function(); + + @Override + public abstract ImmutableList args(); + + /** Builder for CelCall. */ + @AutoValue.Builder + public abstract static class Builder { + private java.util.List mutableArgs = new ArrayList<>(); + + // Not public. This only exists to make AutoValue.Builder work. + abstract ImmutableList args(); + + public abstract Builder setTarget(CelExpr value); + + public abstract Builder setTarget(Optional value); + + public abstract Builder setFunction(String value); + + public abstract Optional target(); + + // Not public. This only exists to make AutoValue.Builder work. + abstract Builder setArgs(ImmutableList value); + + /** Returns an immutable copy of the current mutable arguments present in the builder. */ + public ImmutableList getArgs() { + return ImmutableList.copyOf(mutableArgs); + } + + /** Returns an immutable copy of the builders from the current mutable arguments. */ + public ImmutableList getArgsBuilders() { + return mutableArgs.stream().map(CelExpr::toBuilder).collect(toImmutableList()); + } + + @CanIgnoreReturnValue + public Builder clearArgs() { + mutableArgs.clear(); + return this; + } + + @CanIgnoreReturnValue + public Builder setArg(int index, CelExpr arg) { + checkNotNull(arg); + mutableArgs.set(index, arg); + return this; + } + + public Builder clearTarget() { + return setTarget(Optional.empty()); + } + + @CanIgnoreReturnValue + public Builder addArgs(CelExpr... args) { + checkNotNull(args); + return addArgs(Arrays.asList(args)); + } + + @CanIgnoreReturnValue + public Builder addArgs(Iterable args) { + checkNotNull(args); + args.forEach(mutableArgs::add); + return this; + } + + @CheckReturnValue + // Not public due to overridden build logic. + abstract CelCall autoBuild(); + + public CelCall build() { + setArgs(ImmutableList.copyOf(mutableArgs)); + return autoBuild(); + } + } + + // Not public due to overridden build logic. + abstract Builder autoToBuilder(); + + public Builder toBuilder() { + Builder builder = autoToBuilder(); + builder.mutableArgs = new ArrayList<>(builder.args()); + return builder; + } + + public static Builder newBuilder() { + return new AutoValue_CelExpr_CelCall.Builder().setFunction(""); + } + } + + /** A list creation expression. See {@link List} */ + @AutoValue + @Immutable + public abstract static class CelList implements List { + @Override + public abstract ImmutableList elements(); + + @Override + public abstract ImmutableList optionalIndices(); + + /** Builder for CelList. */ + @AutoValue.Builder + public abstract static class Builder { + private java.util.List mutableElements = new ArrayList<>(); + + // Not public. This only exists to make AutoValue.Builder work. + abstract ImmutableList elements(); + + // Not public. This only exists to make AutoValue.Builder work. + abstract ImmutableList.Builder optionalIndicesBuilder(); + + // Not public. This only exists to make AutoValue.Builder work. + @CanIgnoreReturnValue + abstract Builder setElements(ImmutableList elements); + + /** Returns an immutable copy of the current mutable elements present in the builder. */ + public ImmutableList getElements() { + return ImmutableList.copyOf(mutableElements); + } + + /** Returns an immutable copy of the builders from the current mutable elements. */ + public ImmutableList getElementsBuilders() { + return mutableElements.stream().map(CelExpr::toBuilder).collect(toImmutableList()); + } + + @CanIgnoreReturnValue + public Builder setElement(int index, CelExpr element) { + checkNotNull(element); + mutableElements.set(index, element); + return this; + } + + @CanIgnoreReturnValue + public Builder addElements(CelExpr... elements) { + checkNotNull(elements); + return addElements(Arrays.asList(elements)); + } + + @CanIgnoreReturnValue + public Builder addElements(Iterable elements) { + checkNotNull(elements); + elements.forEach(mutableElements::add); + return this; + } + + @CanIgnoreReturnValue + public Builder addOptionalIndices(Integer... indices) { + checkNotNull(indices); + return addOptionalIndices(Arrays.asList(indices)); + } + + @CanIgnoreReturnValue + public Builder addOptionalIndices(Iterable indices) { + checkNotNull(indices); + this.optionalIndicesBuilder().addAll(indices); + return this; + } + + // Not public due to overridden build logic. + abstract CelList autoBuild(); + + @CheckReturnValue + public CelList build() { + setElements(ImmutableList.copyOf(mutableElements)); + return autoBuild(); + } + } + + // Not public due to overridden build logic. + abstract Builder autoToBuilder(); + + public Builder toBuilder() { + Builder builder = autoToBuilder(); + builder.mutableElements = new ArrayList<>(builder.elements()); + return builder; + } + + public static Builder newBuilder() { + return new AutoValue_CelExpr_CelList.Builder(); + } + } + + /** A message creation expression. See {@link Expression.Struct} */ + @AutoValue + @Immutable + public abstract static class CelStruct implements Expression.Struct { + @Override + public abstract String messageName(); + + @Override + public abstract ImmutableList entries(); + + /** Builder for CelStruct. */ + @AutoValue.Builder + public abstract static class Builder { + private java.util.List mutableEntries = new ArrayList<>(); + + // Not public. This only exists to make AutoValue.Builder work. + abstract ImmutableList entries(); + + @CanIgnoreReturnValue + public abstract Builder setMessageName(String value); + + // Not public. This only exists to make AutoValue.Builder work. + @CanIgnoreReturnValue + abstract Builder setEntries(ImmutableList entries); + + /** Returns an immutable copy of the current mutable entries present in the builder. */ + public ImmutableList getEntries() { + return ImmutableList.copyOf(mutableEntries); + } + + /** Returns an immutable copy of the builders from the current mutable entries. */ + public ImmutableList getEntriesBuilders() { + return mutableEntries.stream().map(CelStruct.Entry::toBuilder).collect(toImmutableList()); + } + + @CanIgnoreReturnValue + public Builder setEntry(int index, CelStruct.Entry entry) { + checkNotNull(entry); + mutableEntries.set(index, entry); + return this; + } + + @CanIgnoreReturnValue + public Builder addEntries(CelStruct.Entry... entries) { + checkNotNull(entries); + return addEntries(Arrays.asList(entries)); + } + + @CanIgnoreReturnValue + public Builder addEntries(Iterable entries) { + checkNotNull(entries); + entries.forEach(mutableEntries::add); + return this; + } + + // Not public due to overridden build logic. + abstract CelStruct autoBuild(); + + @CheckReturnValue + public CelStruct build() { + setEntries(ImmutableList.copyOf(mutableEntries)); + return autoBuild(); + } + } + + // Not public due to overridden build logic. + abstract Builder autoToBuilder(); + + public Builder toBuilder() { + Builder builder = autoToBuilder(); + builder.mutableEntries = new ArrayList<>(builder.entries()); + return builder; + } + + public static Builder newBuilder() { + return new AutoValue_CelExpr_CelStruct.Builder().setMessageName(""); + } + + /** Represents an entry of the struct */ + @AutoValue + @Immutable + public abstract static class Entry implements Expression.Struct.Entry { + + @Override + public abstract long id(); + + @Override + public abstract String fieldKey(); + + @Override + public abstract CelExpr value(); + + @Override + public abstract boolean optionalEntry(); + + /** Builder for CelStruct.Entry. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract long id(); + + public abstract CelExpr value(); + + public abstract Builder setId(long value); + + public abstract Builder setFieldKey(String value); + + public abstract Builder setValue(CelExpr value); + + public abstract Builder setOptionalEntry(boolean value); + + @CheckReturnValue + public abstract CelStruct.Entry build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder() { + return new AutoValue_CelExpr_CelStruct_Entry.Builder().setId(0).setOptionalEntry(false); + } + } + } + + /** A map creation expression. See {@link Expression.Map} */ + @AutoValue + @Immutable + public abstract static class CelMap implements Expression.Map { + /** The entries in the creation expression. */ + @Override + public abstract ImmutableList entries(); + + /** Builder for CelMap. */ + @AutoValue.Builder + public abstract static class Builder { + + private java.util.List mutableEntries = new ArrayList<>(); + + // Not public. This only exists to make AutoValue.Builder work. + abstract ImmutableList entries(); + + // Not public. This only exists to make AutoValue.Builder work. + @CanIgnoreReturnValue + abstract Builder setEntries(ImmutableList entries); + + /** Returns an immutable copy of the current mutable entries present in the builder. */ + public ImmutableList getEntries() { + return ImmutableList.copyOf(mutableEntries); + } + + /** Returns an immutable copy of the builders from the current mutable entries. */ + public ImmutableList getEntriesBuilders() { + return mutableEntries.stream().map(CelMap.Entry::toBuilder).collect(toImmutableList()); + } + + @CanIgnoreReturnValue + public Builder setEntry(int index, CelMap.Entry entry) { + checkNotNull(entry); + mutableEntries.set(index, entry); + return this; + } + + @CanIgnoreReturnValue + public Builder addEntries(CelMap.Entry... entries) { + checkNotNull(entries); + return addEntries(Arrays.asList(entries)); + } + + @CanIgnoreReturnValue + public Builder addEntries(Iterable entries) { + checkNotNull(entries); + entries.forEach(mutableEntries::add); + return this; + } + + // Not public due to overridden build logic. + abstract CelMap autoBuild(); + + @CheckReturnValue + public CelMap build() { + setEntries(ImmutableList.copyOf(mutableEntries)); + return autoBuild(); + } + } + + // Not public due to overridden build logic. + abstract Builder autoToBuilder(); + + public Builder toBuilder() { + Builder builder = autoToBuilder(); + builder.mutableEntries = new ArrayList<>(builder.entries()); + return builder; + } + + public static Builder newBuilder() { + return new AutoValue_CelExpr_CelMap.Builder(); + } + + /** Represents an entry of the map. */ + @AutoValue + @Immutable + public abstract static class Entry implements Expression.Map.Entry { + + @Override + public abstract long id(); + + @Override + public abstract CelExpr key(); + + @Override + public abstract CelExpr value(); + + @Override + public abstract boolean optionalEntry(); + + /** Builder for CelMap.Entry. */ + @AutoValue.Builder + public abstract static class Builder { + public abstract long id(); + + public abstract CelExpr key(); + + public abstract CelExpr value(); + + public abstract CelMap.Entry.Builder setId(long value); + + public abstract CelMap.Entry.Builder setKey(CelExpr value); + + public abstract CelMap.Entry.Builder setValue(CelExpr value); + + public abstract CelMap.Entry.Builder setOptionalEntry(boolean value); + + @CheckReturnValue + public abstract CelMap.Entry build(); + } + + public abstract CelMap.Entry.Builder toBuilder(); + + public static CelMap.Entry.Builder newBuilder() { + return new AutoValue_CelExpr_CelMap_Entry.Builder().setId(0).setOptionalEntry(false); + } + } + } + + /** A comprehension expression applied to a list or map. See {@link Expression.Comprehension} */ + @AutoValue + @Immutable + public abstract static class CelComprehension implements Expression.Comprehension { + @Override + public abstract String iterVar(); + + @Override + public abstract String iterVar2(); + + @Override + public abstract CelExpr iterRange(); + + @Override + public abstract String accuVar(); + + @Override + public abstract CelExpr accuInit(); + + @Override + public abstract CelExpr loopCondition(); + + @Override + public abstract CelExpr loopStep(); + + @Override + public abstract CelExpr result(); + + /** Builder for Comprehension. */ + @AutoValue.Builder + public abstract static class Builder { + public abstract String accuVar(); + + public abstract CelExpr iterRange(); + + public abstract CelExpr accuInit(); + + public abstract CelExpr loopCondition(); + + public abstract CelExpr loopStep(); + + public abstract CelExpr result(); + + public abstract Builder setIterVar(String value); + + public abstract Builder setIterVar2(String value); + + public abstract Builder setIterRange(CelExpr value); + + public abstract Builder setAccuVar(String value); + + public abstract Builder setAccuInit(CelExpr value); + + public abstract Builder setLoopCondition(CelExpr value); + + public abstract Builder setLoopStep(CelExpr value); + + public abstract Builder setResult(CelExpr value); + + @CheckReturnValue + public abstract CelComprehension build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder() { + return new AutoValue_CelExpr_CelComprehension.Builder() + .setIterVar("") + .setIterVar2("") + .setIterRange(CelExpr.newBuilder().build()) + .setAccuVar("") + .setAccuInit(CelExpr.newBuilder().build()) + .setLoopCondition(CelExpr.newBuilder().build()) + .setLoopStep(CelExpr.newBuilder().build()) + .setResult(CelExpr.newBuilder().build()); + } + } + + public static CelExpr ofNotSet(long id) { + return newBuilder() + .setId(id) + .setExprKind(AutoOneOf_CelExpr_ExprKind.notSet(new AutoValue_CelExpr_CelNotSet())) + .build(); + } + + public static CelExpr ofConstant(long id, CelConstant celConstant) { + return newBuilder() + .setId(id) + .setExprKind(AutoOneOf_CelExpr_ExprKind.constant(celConstant)) + .build(); + } + + public static CelExpr ofIdent(long id, String identName) { + return newBuilder() + .setId(id) + .setExprKind( + AutoOneOf_CelExpr_ExprKind.ident(CelIdent.newBuilder().setName(identName).build())) + .build(); + } + + public static CelExpr ofSelect(long id, CelExpr operandExpr, String field, boolean isTestOnly) { + return newBuilder() + .setId(id) + .setExprKind( + AutoOneOf_CelExpr_ExprKind.select( + CelSelect.newBuilder() + .setOperand(operandExpr) + .setField(field) + .setTestOnly(isTestOnly) + .build())) + .build(); + } + + public static CelExpr ofCall( + long id, Optional targetExpr, String function, ImmutableList arguments) { + + CelCall.Builder celCallBuilder = CelCall.newBuilder().setFunction(function).addArgs(arguments); + targetExpr.ifPresent(celCallBuilder::setTarget); + return newBuilder() + .setId(id) + .setExprKind(AutoOneOf_CelExpr_ExprKind.call(celCallBuilder.build())) + .build(); + } + + public static CelExpr ofList( + long id, ImmutableList elements, ImmutableList optionalIndices) { + return newBuilder() + .setId(id) + .setExprKind( + AutoOneOf_CelExpr_ExprKind.list( + CelList.newBuilder() + .addElements(elements) + .addOptionalIndices(optionalIndices) + .build())) + .build(); + } + + public static CelExpr ofStruct( + long id, String messageName, ImmutableList entries) { + return newBuilder() + .setId(id) + .setExprKind( + AutoOneOf_CelExpr_ExprKind.struct( + CelStruct.newBuilder().setMessageName(messageName).addEntries(entries).build())) + .build(); + } + + public static CelExpr ofMap(long id, ImmutableList entries) { + return newBuilder() + .setId(id) + .setExprKind( + AutoOneOf_CelExpr_ExprKind.map(CelMap.newBuilder().addEntries(entries).build())) + .build(); + } + + public static CelStruct.Entry ofStructEntry( + long id, String fieldKey, CelExpr value, boolean isOptionalEntry) { + return CelStruct.Entry.newBuilder() + .setId(id) + .setFieldKey(fieldKey) + .setValue(value) + .setOptionalEntry(isOptionalEntry) + .build(); + } + + public static CelMap.Entry ofMapEntry( + long id, CelExpr mapKey, CelExpr value, boolean isOptionalEntry) { + return CelMap.Entry.newBuilder() + .setId(id) + .setKey(mapKey) + .setValue(value) + .setOptionalEntry(isOptionalEntry) + .build(); + } + + public static CelExpr ofComprehension( + long id, + String iterVar, + CelExpr iterRange, + String accuVar, + CelExpr accuInit, + CelExpr loopCondition, + CelExpr loopStep, + CelExpr result) { + return ofComprehension( + id, + iterVar, + /* iterVar2= */ "", + iterRange, + accuVar, + accuInit, + loopCondition, + loopStep, + result); + } + + @SuppressWarnings("TooManyParameters") + public static CelExpr ofComprehension( + long id, + String iterVar, + String iterVar2, + CelExpr iterRange, + String accuVar, + CelExpr accuInit, + CelExpr loopCondition, + CelExpr loopStep, + CelExpr result) { + return newBuilder() + .setId(id) + .setExprKind( + AutoOneOf_CelExpr_ExprKind.comprehension( + CelComprehension.newBuilder() + .setIterVar(iterVar) + .setIterVar2(iterVar2) + .setIterRange(iterRange) + .setAccuVar(accuVar) + .setAccuInit(accuInit) + .setLoopCondition(loopCondition) + .setLoopStep(loopStep) + .setResult(result) + .build())) + .build(); + } + + @Override + public final String toString() { + return CelExprFormatter.format(this); + } +} diff --git a/common/src/main/java/dev/cel/common/ast/CelExprConverter.java b/common/src/main/java/dev/cel/common/ast/CelExprConverter.java new file mode 100644 index 000000000..6037d901d --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelExprConverter.java @@ -0,0 +1,344 @@ +// Copyright 2022 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.ast; + +import static com.google.common.collect.ImmutableMap.toImmutableMap; + +import dev.cel.expr.Constant; +import dev.cel.expr.Expr; +import dev.cel.expr.Expr.Call; +import dev.cel.expr.Expr.Comprehension; +import dev.cel.expr.Expr.CreateList; +import dev.cel.expr.Expr.CreateStruct; +import dev.cel.expr.Expr.CreateStruct.Entry; +import dev.cel.expr.Expr.CreateStruct.Entry.KeyKindCase; +import dev.cel.expr.Expr.Ident; +import dev.cel.expr.Expr.Select; +import dev.cel.expr.Reference; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; +import java.util.Map; +import java.util.Optional; + +/** + * Converts a proto-based Canonical Expression Tree {@link Expr} into the CEL native representation + * of Expression tree {@link CelExpr} and vice versa. + * + *

Note: Keep this file in sync with {@code CelExprV1Alpha1Converter} + */ +// LINT.IfChange +public final class CelExprConverter { + private CelExprConverter() {} + + /** Convert {@link CelExpr} into {@link Expr} */ + public static Expr fromCelExpr(CelExpr celExpr) { + CelExpr.ExprKind celExprKind = celExpr.exprKind(); + Expr.Builder expr = newExprBuilder(celExpr); + switch (celExprKind.getKind()) { + case CONSTANT: + return expr.setConstExpr(celConstantToExprConstant(celExprKind.constant())).build(); + case IDENT: + return expr.setIdentExpr(Ident.newBuilder().setName(celExprKind.ident().name())).build(); + case SELECT: + CelExpr.CelSelect celSelect = celExprKind.select(); + return expr.setSelectExpr( + Select.newBuilder() + .setField(celSelect.field()) + .setOperand(fromCelExpr(celSelect.operand())) + .setTestOnly(celSelect.testOnly())) + .build(); + case CALL: + CelExpr.CelCall celCall = celExprKind.call(); + Call.Builder callBuilder = + Call.newBuilder() + .setFunction(celCall.function()) + .addAllArgs(fromCelExprList(celCall.args())); + celCall.target().ifPresent(target -> callBuilder.setTarget(fromCelExpr(target))); + return expr.setCallExpr(callBuilder).build(); + case LIST: + CelExpr.CelList celList = celExprKind.list(); + return expr.setListExpr( + CreateList.newBuilder() + .addAllElements(fromCelExprList(celList.elements())) + .addAllOptionalIndices(celList.optionalIndices())) + .build(); + case STRUCT: + return expr.setStructExpr(celStructToExprStruct(celExprKind.struct())).build(); + case MAP: + return expr.setStructExpr(celMapToExprStruct(celExprKind.map())).build(); + case COMPREHENSION: + CelExpr.CelComprehension celComprehension = celExprKind.comprehension(); + return expr.setComprehensionExpr( + Comprehension.newBuilder() + .setIterVar(celComprehension.iterVar()) + .setIterVar2(celComprehension.iterVar2()) + .setIterRange(fromCelExpr(celComprehension.iterRange())) + .setAccuVar(celComprehension.accuVar()) + .setAccuInit(fromCelExpr(celComprehension.accuInit())) + .setLoopCondition(fromCelExpr(celComprehension.loopCondition())) + .setLoopStep(fromCelExpr(celComprehension.loopStep())) + .setResult(fromCelExpr(celComprehension.result()))) + .build(); + case NOT_SET: + return expr.build(); + } + throw new IllegalArgumentException( + "Unexpected expression kind case: " + celExpr.exprKind().getKind()); + } + + /** Convert {@link Expr} into {@link CelExpr} */ + public static CelExpr fromExpr(Expr expr) { + switch (expr.getExprKindCase()) { + case CONST_EXPR: + return CelExpr.ofConstant(expr.getId(), exprConstantToCelConstant(expr.getConstExpr())); + case IDENT_EXPR: + return CelExpr.ofIdent(expr.getId(), expr.getIdentExpr().getName()); + case SELECT_EXPR: + Select selectExpr = expr.getSelectExpr(); + return CelExpr.ofSelect( + expr.getId(), + fromExpr(selectExpr.getOperand()), + selectExpr.getField(), + selectExpr.getTestOnly()); + case CALL_EXPR: + Call callExpr = expr.getCallExpr(); + return CelExpr.ofCall( + expr.getId(), + callExpr.hasTarget() ? Optional.of(fromExpr(callExpr.getTarget())) : Optional.empty(), + callExpr.getFunction(), + fromExprList(callExpr.getArgsList())); + case LIST_EXPR: + CreateList createListExpr = expr.getListExpr(); + return CelExpr.ofList( + expr.getId(), + fromExprList(createListExpr.getElementsList()), + ImmutableList.copyOf(createListExpr.getOptionalIndicesList())); + case STRUCT_EXPR: + return exprStructToCelStruct(expr.getId(), expr.getStructExpr()); + case COMPREHENSION_EXPR: + Comprehension comprehensionExpr = expr.getComprehensionExpr(); + return CelExpr.ofComprehension( + expr.getId(), + comprehensionExpr.getIterVar(), + comprehensionExpr.getIterVar2(), + fromExpr(comprehensionExpr.getIterRange()), + comprehensionExpr.getAccuVar(), + fromExpr(comprehensionExpr.getAccuInit()), + fromExpr(comprehensionExpr.getLoopCondition()), + fromExpr(comprehensionExpr.getLoopStep()), + fromExpr(comprehensionExpr.getResult())); + case EXPRKIND_NOT_SET: + return CelExpr.ofNotSet(expr.getId()); + } + + throw new IllegalArgumentException( + "Unexpected expression kind case: " + expr.getExprKindCase()); + } + + private static ImmutableList fromExprList(Iterable exprList) { + ImmutableList.Builder celExprListBuilder = ImmutableList.builder(); + for (Expr expr : exprList) { + celExprListBuilder.add(fromExpr(expr)); + } + return celExprListBuilder.build(); + } + + /** + * Converts a proto-based {@link Reference} to CEL native representation of {@link CelReference}. + */ + public static CelReference exprReferenceToCelReference(Reference reference) { + CelReference.Builder builder = + CelReference.newBuilder() + .setName(reference.getName()) + .addOverloadIds(reference.getOverloadIdList()); + if (reference.hasValue()) { + builder.setValue(exprConstantToCelConstant(reference.getValue())); + } + + return builder.build(); + } + + /** + * Converts a proto-based {@link Constant} to CEL native representation of {@link CelConstant}. + */ + public static CelConstant exprConstantToCelConstant(Constant constExpr) { + switch (constExpr.getConstantKindCase()) { + case CONSTANTKIND_NOT_SET: + return CelConstant.ofNotSet(); + case NULL_VALUE: + return CelConstant.ofValue(NullValue.NULL_VALUE); + case BOOL_VALUE: + return CelConstant.ofValue(constExpr.getBoolValue()); + case INT64_VALUE: + return CelConstant.ofValue(constExpr.getInt64Value()); + case UINT64_VALUE: + return CelConstant.ofValue(UnsignedLong.fromLongBits(constExpr.getUint64Value())); + case DOUBLE_VALUE: + return CelConstant.ofValue(constExpr.getDoubleValue()); + case STRING_VALUE: + return CelConstant.ofValue(constExpr.getStringValue()); + case BYTES_VALUE: + ByteString bytesValue = constExpr.getBytesValue(); + return CelConstant.ofValue(CelByteString.of(bytesValue.toByteArray())); + case DURATION_VALUE: + return CelConstant.ofValue(constExpr.getDurationValue()); + case TIMESTAMP_VALUE: + return CelConstant.ofValue(constExpr.getTimestampValue()); + default: + throw new IllegalStateException( + "unsupported constant case: " + constExpr.getConstantKindCase()); + } + } + + private static CelExpr exprStructToCelStruct(long id, CreateStruct structExpr) { + if (!structExpr.getMessageName().isEmpty()) { + ImmutableList.Builder entries = ImmutableList.builder(); + for (Entry structExprEntry : structExpr.getEntriesList()) { + if (!structExprEntry.getKeyKindCase().equals(KeyKindCase.FIELD_KEY)) { + throw new IllegalArgumentException( + "Unexpected struct key kind case: " + structExprEntry.getKeyKindCase()); + } + entries.add( + CelExpr.ofStructEntry( + structExprEntry.getId(), + structExprEntry.getFieldKey(), + fromExpr(structExprEntry.getValue()), + structExprEntry.getOptionalEntry())); + } + + return CelExpr.ofStruct(id, structExpr.getMessageName(), entries.build()); + } else { + ImmutableList.Builder entries = ImmutableList.builder(); + for (Entry mapExprEntry : structExpr.getEntriesList()) { + if (!mapExprEntry.getKeyKindCase().equals(KeyKindCase.MAP_KEY)) { + throw new IllegalArgumentException( + "Unexpected map key kind case: " + mapExprEntry.getKeyKindCase()); + } + entries.add( + CelExpr.ofMapEntry( + mapExprEntry.getId(), + fromExpr(mapExprEntry.getMapKey()), + fromExpr(mapExprEntry.getValue()), + mapExprEntry.getOptionalEntry())); + } + + return CelExpr.ofMap(id, entries.build()); + } + } + + private static Expr.Builder newExprBuilder(CelExpr expr) { + return Expr.newBuilder().setId(expr.id()); + } + + /** + * Converts a proto-based {@link Constant} to CEL native representation of {@link CelConstant}. + */ + public static Constant celConstantToExprConstant(CelConstant celConstant) { + switch (celConstant.getKind()) { + case NOT_SET: + return Constant.getDefaultInstance(); + case NULL_VALUE: + return Constant.newBuilder().setNullValue(com.google.protobuf.NullValue.NULL_VALUE).build(); + case BOOLEAN_VALUE: + return Constant.newBuilder().setBoolValue(celConstant.booleanValue()).build(); + case INT64_VALUE: + return Constant.newBuilder().setInt64Value(celConstant.int64Value()).build(); + case UINT64_VALUE: + return Constant.newBuilder().setUint64Value(celConstant.uint64Value().longValue()).build(); + case DOUBLE_VALUE: + return Constant.newBuilder().setDoubleValue(celConstant.doubleValue()).build(); + case STRING_VALUE: + return Constant.newBuilder().setStringValue(celConstant.stringValue()).build(); + case BYTES_VALUE: + CelByteString celByteString = celConstant.bytesValue(); + return Constant.newBuilder() + .setBytesValue(ByteString.copyFrom(celByteString.toByteArray())) + .build(); + case DURATION_VALUE: + return Constant.newBuilder().setDurationValue(celConstant.durationValue()).build(); + case TIMESTAMP_VALUE: + return Constant.newBuilder().setTimestampValue(celConstant.timestampValue()).build(); + } + + throw new IllegalStateException("unsupported constant case: " + celConstant.getKind()); + } + + private static CreateStruct celStructToExprStruct(CelExpr.CelStruct celStruct) { + ImmutableList.Builder entries = ImmutableList.builder(); + for (CelExpr.CelStruct.Entry celStructExprEntry : celStruct.entries()) { + entries.add( + CreateStruct.Entry.newBuilder() + .setId(celStructExprEntry.id()) + .setFieldKey(celStructExprEntry.fieldKey()) + .setValue(fromCelExpr(celStructExprEntry.value())) + .setOptionalEntry(celStructExprEntry.optionalEntry()) + .build()); + } + + return CreateStruct.newBuilder() + .setMessageName(celStruct.messageName()) + .addAllEntries(entries.build()) + .build(); + } + + private static CreateStruct celMapToExprStruct(CelExpr.CelMap celMap) { + ImmutableList.Builder entries = ImmutableList.builder(); + for (CelExpr.CelMap.Entry celMapEntry : celMap.entries()) { + CreateStruct.Entry exprMapEntry = + CreateStruct.Entry.newBuilder() + .setId(celMapEntry.id()) + .setMapKey(fromCelExpr(celMapEntry.key())) + .setValue(fromCelExpr(celMapEntry.value())) + .setOptionalEntry(celMapEntry.optionalEntry()) + .build(); + + entries.add(exprMapEntry); + } + + return CreateStruct.newBuilder().addAllEntries(entries.build()).build(); + } + + private static ImmutableList fromCelExprList(Iterable celExprList) { + ImmutableList.Builder celExprListBuilder = ImmutableList.builder(); + for (CelExpr celExpr : celExprList) { + celExprListBuilder.add(fromCelExpr(celExpr)); + } + return celExprListBuilder.build(); + } + + /** + * Converts a proto-based {@link CelReference} to CEL native representation of {@link Reference}. + */ + public static Reference celReferenceToExprReference(CelReference reference) { + Reference.Builder builder = + Reference.newBuilder().setName(reference.name()).addAllOverloadId(reference.overloadIds()); + reference + .value() + .ifPresent(celConstant -> builder.setValue(celConstantToExprConstant(celConstant))); + + return builder.build(); + } + + public static ImmutableMap exprMacroCallsToCelExprMacroCalls( + Map macroCalls) { + return macroCalls.entrySet().stream() + .collect(toImmutableMap(Map.Entry::getKey, v -> fromExpr(v.getValue()))); + } +} +// LINT.ThenChange(CelExprV1Alpha1Converter.java) diff --git a/common/src/main/java/dev/cel/common/ast/CelExprFactory.java b/common/src/main/java/dev/cel/common/ast/CelExprFactory.java new file mode 100644 index 000000000..b69dab05c --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelExprFactory.java @@ -0,0 +1,268 @@ +// Copyright 2023 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.ast; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Strings.isNullOrEmpty; + +import com.google.common.primitives.UnsignedLong; +import dev.cel.common.annotations.Internal; +import dev.cel.common.values.CelByteString; +import java.util.Arrays; + +/** Factory for generating expression nodes. */ +@Internal +public class CelExprFactory { + private long exprId = 0L; + + public static CelExprFactory newInstance() { + return new CelExprFactory(); + } + + /** Create a new constant expression. */ + public final CelExpr newConstant(CelConstant constant) { + return CelExpr.newBuilder().setId(nextExprId()).setConstant(constant).build(); + } + + /** Creates a new constant {@link CelExpr} for a bool value. */ + public final CelExpr newBoolLiteral(boolean value) { + return newConstant(CelConstant.ofValue(value)); + } + + /** Creates a new constant {@link CelExpr} for a bytes value. */ + public final CelExpr newBytesLiteral(String value) { + return newBytesLiteral(CelByteString.copyFromUtf8(value)); + } + + /** Creates a new constant {@link CelExpr} for a bytes value. */ + public final CelExpr newBytesLiteral(byte[] value) { + return newBytesLiteral(CelByteString.of(value)); + } + + /** Creates a new constant {@link CelExpr} for a bytes value. */ + public final CelExpr newBytesLiteral(CelByteString value) { + return newConstant(CelConstant.ofValue(value)); + } + + /** Creates a new constant {@link CelExpr} for a double value. */ + public final CelExpr newDoubleLiteral(double value) { + return newConstant(CelConstant.ofValue(value)); + } + + /** Creates a new constant {@link CelExpr} for an int value. */ + public final CelExpr newIntLiteral(long value) { + return newConstant(CelConstant.ofValue(value)); + } + + /** Creates a new constant {@link CelExpr} for a string value. */ + public final CelExpr newStringLiteral(String value) { + return newConstant(CelConstant.ofValue(value)); + } + + /** Creates a new constant {@link CelExpr} for a uint value. */ + public final CelExpr newUintLiteral(long value) { + return newConstant(CelConstant.ofValue(UnsignedLong.fromLongBits(value))); + } + + /** Creates a new list {@link CelExpr} comprised of the elements. */ + public final CelExpr newList(CelExpr... elements) { + return newList(Arrays.asList(elements)); + } + + /** Creates a new list {@link CelExpr} comprised of the elements. */ + public final CelExpr newList(Iterable elements) { + return CelExpr.newBuilder() + .setId(nextExprId()) + .setList(CelExpr.CelList.newBuilder().addElements(elements).build()) + .build(); + } + + /** Creates a new map {@link CelExpr} comprised of the entries. */ + public final CelExpr newMap(CelExpr.CelMap.Entry... entries) { + return newMap(Arrays.asList(entries)); + } + + /** Creates a new map {@link CelExpr} comprised of the entries. */ + public final CelExpr newMap(Iterable entries) { + return CelExpr.newBuilder() + .setId(nextExprId()) + .setMap(CelExpr.CelMap.newBuilder().addEntries(entries).build()) + .build(); + } + + /** Creates a new map {@link CelExpr.CelStruct.Entry} comprised of the given key and value. */ + public final CelExpr.CelMap.Entry newMapEntry(CelExpr key, CelExpr value) { + return CelExpr.CelMap.Entry.newBuilder() + .setId(nextExprId()) + .setKey(key) + .setValue(value) + .build(); + } + + /** Creates a new message {@link CelExpr} of the given type comprised of the given fields. */ + public final CelExpr newMessage(String typeName, CelExpr.CelStruct.Entry... fields) { + return newMessage(typeName, Arrays.asList(fields)); + } + + /** Creates a new message {@link CelExpr} of the given type comprised of the given fields. */ + public final CelExpr newMessage(String typeName, Iterable fields) { + checkArgument(!isNullOrEmpty(typeName)); + return CelExpr.newBuilder() + .setId(nextExprId()) + .setStruct( + CelExpr.CelStruct.newBuilder().setMessageName(typeName).addEntries(fields).build()) + .build(); + } + + /** + * Creates a new message {@link CelExpr.CelStruct.Entry} comprised of the given field and value. + */ + public final CelExpr.CelStruct.Entry newMessageField(String field, CelExpr value) { + checkArgument(!isNullOrEmpty(field)); + return CelExpr.CelStruct.Entry.newBuilder() + .setId(nextExprId()) + .setFieldKey(field) + .setValue(value) + .build(); + } + + /** Fold creates a fold for one variable comprehension instruction. */ + public final CelExpr fold( + String iterVar, + CelExpr iterRange, + String accuVar, + CelExpr accuInit, + CelExpr condition, + CelExpr step, + CelExpr result) { + checkArgument(!isNullOrEmpty(iterVar)); + checkArgument(!isNullOrEmpty(accuVar)); + return CelExpr.newBuilder() + .setId(nextExprId()) + .setComprehension( + CelExpr.CelComprehension.newBuilder() + .setIterVar(iterVar) + .setIterRange(iterRange) + .setAccuVar(accuVar) + .setAccuInit(accuInit) + .setLoopCondition(condition) + .setLoopStep(step) + .setResult(result) + .build()) + .build(); + } + + /** Fold creates a fold for two variable comprehension instruction. */ + public final CelExpr fold( + String iterVar, + String iterVar2, + CelExpr iterRange, + String accuVar, + CelExpr accuInit, + CelExpr condition, + CelExpr step, + CelExpr result) { + checkArgument(!isNullOrEmpty(iterVar)); + checkArgument(!isNullOrEmpty(iterVar2)); + checkArgument(!isNullOrEmpty(accuVar)); + return CelExpr.newBuilder() + .setId(nextExprId()) + .setComprehension( + CelExpr.CelComprehension.newBuilder() + .setIterVar(iterVar) + .setIterVar2(iterVar2) + .setIterRange(iterRange) + .setAccuVar(accuVar) + .setAccuInit(accuInit) + .setLoopCondition(condition) + .setLoopStep(step) + .setResult(result) + .build()) + .build(); + } + + /** Creates an identifier {@link CelExpr} for the given name. */ + public final CelExpr newIdentifier(String name) { + checkArgument(!isNullOrEmpty(name)); + return CelExpr.newBuilder() + .setId(nextExprId()) + .setIdent(CelExpr.CelIdent.newBuilder().setName(name).build()) + .build(); + } + + /** Creates a global (free) function call {@link CelExpr} for the given function and arguments. */ + public final CelExpr newGlobalCall(String function, CelExpr... arguments) { + return newGlobalCall(function, Arrays.asList(arguments)); + } + + /** Creates a global (free) function call {@link CelExpr} for the given function and arguments. */ + public final CelExpr newGlobalCall(String function, Iterable arguments) { + checkArgument(!isNullOrEmpty(function)); + return CelExpr.newBuilder() + .setId(nextExprId()) + .setCall(CelExpr.CelCall.newBuilder().setFunction(function).addArgs(arguments).build()) + .build(); + } + + /** + * Creates a receiver-style function call {@link CelExpr} for the given function, target, and + * arguments. + */ + public final CelExpr newReceiverCall(String function, CelExpr target, CelExpr... arguments) { + return newReceiverCall(function, target, Arrays.asList(arguments)); + } + + /** + * Creates a receiver-style function call {@link CelExpr} for the given function, target, and + * arguments. + */ + public final CelExpr newReceiverCall( + String function, CelExpr target, Iterable arguments) { + checkArgument(!isNullOrEmpty(function)); + return CelExpr.newBuilder() + .setId(nextExprId()) + .setCall( + CelExpr.CelCall.newBuilder() + .setFunction(function) + .setTarget(target) + .addArgs(arguments) + .build()) + .build(); + } + + /** + * Creates a field traversal or field presence test {@link CelExpr} for the given operand and + * field. + */ + public final CelExpr newSelect(CelExpr operand, String field, boolean testOnly) { + checkArgument(!isNullOrEmpty(field)); + return CelExpr.newBuilder() + .setId(nextExprId()) + .setSelect( + CelExpr.CelSelect.newBuilder() + .setOperand(operand) + .setField(field) + .setTestOnly(testOnly) + .build()) + .build(); + } + + /** Returns the next unique expression ID. */ + protected long nextExprId() { + return ++exprId; + } + + protected CelExprFactory() {} +} diff --git a/common/src/main/java/dev/cel/common/ast/CelExprFormatter.java b/common/src/main/java/dev/cel/common/ast/CelExprFormatter.java new file mode 100644 index 000000000..d0eee2f50 --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelExprFormatter.java @@ -0,0 +1,325 @@ +// Copyright 2023 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.ast; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.values.CelByteString; +import java.nio.charset.StandardCharsets; +import java.util.Locale; + +/** Provides string formatting support for {@link CelExpr}. */ +final class CelExprFormatter { + private final StringBuilder indent = new StringBuilder(); + private final StringBuilder exprBuilder = new StringBuilder(); + + /** Denotes a set of expression kinds that will not have a new line inserted. */ + private static final ImmutableSet EXCLUDED_NEWLINE_KINDS = + ImmutableSet.of(CelExpr.ExprKind.Kind.CONSTANT, CelExpr.ExprKind.Kind.NOT_SET); + + static String format(CelExpr celExpr) { + CelExprFormatter formatter = new CelExprFormatter(); + formatter.formatExpr(celExpr); + return formatter.exprBuilder.toString(); + } + + private void formatExpr(CelExpr celExpr) { + CelExpr.ExprKind.Kind exprKind = celExpr.exprKind().getKind(); + append(String.format(Locale.getDefault(), "%s [%d] {", exprKind, celExpr.id())); + if (!EXCLUDED_NEWLINE_KINDS.contains(exprKind)) { + appendNewline(); + } + + switch (exprKind) { + case CONSTANT: + appendConst(celExpr.constant()); + break; + case IDENT: + appendIdent(celExpr.ident()); + break; + case SELECT: + appendSelect(celExpr.select()); + break; + case CALL: + appendCall(celExpr.call()); + break; + case LIST: + appendList(celExpr.list()); + break; + case STRUCT: + appendStruct(celExpr.struct()); + break; + case MAP: + appendMap(celExpr.map()); + break; + case COMPREHENSION: + appendComprehension(celExpr.comprehension()); + break; + case NOT_SET: + break; + default: + // This should be unreachable unless if we've added any other kinds. + indent(); + append("Unknown kind: " + exprKind); + outdent(); + break; + } + + if (!EXCLUDED_NEWLINE_KINDS.contains(exprKind)) { + appendNewline(); + append("}"); + } else { + appendWithoutIndent("}"); + } + } + + private void appendConst(CelConstant celConstant) { + appendWithoutIndent(" value: "); + switch (celConstant.getKind()) { + case NULL_VALUE: + appendWithoutIndent("null"); + break; + case BOOLEAN_VALUE: + appendWithoutIndent(Boolean.toString(celConstant.booleanValue())); + break; + case INT64_VALUE: + appendWithoutIndent(Long.toString(celConstant.int64Value())); + break; + case UINT64_VALUE: + appendWithoutIndent(celConstant.uint64Value() + "u"); + break; + case DOUBLE_VALUE: + appendWithoutIndent(Double.toString(celConstant.doubleValue())); + break; + case STRING_VALUE: + appendWithoutIndent("\"" + celConstant.stringValue() + "\""); + break; + case BYTES_VALUE: + CelByteString byteString = celConstant.bytesValue(); + appendWithoutIndent( + String.format( + Locale.getDefault(), + "b\"%s\"", + new String(byteString.toByteArray(), StandardCharsets.UTF_8))); + break; + default: + append("Unknown kind: " + celConstant.getKind()); + break; + } + appendWithoutIndent(" "); + } + + private void appendIdent(CelExpr.CelIdent celIdent) { + indent(); + append("name: " + celIdent.name()); + outdent(); + } + + private void appendSelect(CelExpr.CelSelect celSelect) { + indent(); + formatExpr(celSelect.operand()); + outdent(); + appendWithoutIndent("."); + appendWithoutIndent(celSelect.field()); + if (celSelect.testOnly()) { + appendWithoutIndent("~presence_test"); + } + } + + private void appendCall(CelExpr.CelCall celCall) { + indent(); + appendWithNewline("function: " + celCall.function()); + if (celCall.target().isPresent()) { + appendWithNewline("target: {"); + indent(); + formatExpr(celCall.target().get()); + outdent(); + appendNewline(); + appendWithNewline("}"); + } + append("args: {"); + indent(); + for (CelExpr celExpr : celCall.args()) { + appendNewline(); + formatExpr(celExpr); + } + outdent(); + appendNewline(); + append("}"); + outdent(); + } + + private void appendList(CelExpr.CelList celList) { + indent(); + append("elements: {"); + indent(); + for (CelExpr expr : celList.elements()) { + appendNewline(); + formatExpr(expr); + } + outdent(); + appendNewline(); + append("}"); + if (!celList.optionalIndices().isEmpty()) { + appendNewline(); + append("optional_indices: ["); + for (int i = 0; i < celList.optionalIndices().size(); i++) { + appendWithoutIndent(String.valueOf(i)); + if (i != celList.optionalIndices().size() - 1) { + appendWithoutIndent(", "); + } + } + appendWithoutIndent("]"); + } + outdent(); + } + + private void appendStruct(CelExpr.CelStruct celStruct) { + indent(); + appendWithNewline("name: " + celStruct.messageName()); + append("entries: {"); + indent(); + for (CelExpr.CelStruct.Entry entry : celStruct.entries()) { + appendNewline(); + appendWithNewline(String.format(Locale.getDefault(), "ENTRY [%d] {", entry.id())); + indent(); + appendWithNewline("field_key: " + entry.fieldKey()); + if (entry.optionalEntry()) { + appendWithNewline("optional_entry: true"); + } + appendWithNewline("value: {"); + indent(); + formatExpr(entry.value()); + outdent(); + appendNewline(); + appendWithNewline("}"); + outdent(); + append("}"); + } + outdent(); + appendNewline(); + append("}"); + outdent(); + } + + private void appendMap(CelExpr.CelMap celMap) { + indent(); + boolean firstLine = true; + for (CelExpr.CelMap.Entry entry : celMap.entries()) { + if (!firstLine) { + appendNewline(); + } else { + firstLine = false; + } + appendWithNewline(String.format(Locale.getDefault(), "MAP_ENTRY [%d] {", entry.id())); + indent(); + appendWithNewline("key: {"); + indent(); + formatExpr(entry.key()); + outdent(); + appendNewline(); + appendWithNewline("}"); + if (entry.optionalEntry()) { + appendWithNewline("optional_entry: true"); + } + appendWithNewline("value: {"); + indent(); + formatExpr(entry.value()); + outdent(); + appendNewline(); + appendWithNewline("}"); + outdent(); + append("}"); + } + outdent(); + } + + private void appendComprehension(CelExpr.CelComprehension celComprehension) { + indent(); + appendWithNewline("iter_var: " + celComprehension.iterVar()); + if (!celComprehension.iterVar2().isEmpty()) { + appendWithNewline("iter_var2: " + celComprehension.iterVar2()); + } + // Iter range + appendWithNewline("iter_range: {"); + indent(); + formatExpr(celComprehension.iterRange()); + outdent(); + appendNewline(); + appendWithNewline("}"); + + appendWithNewline("accu_var: " + celComprehension.accuVar()); + // Accu init + appendWithNewline("accu_init: {"); + indent(); + formatExpr(celComprehension.accuInit()); + outdent(); + appendNewline(); + appendWithNewline("}"); + + // Loop condition + appendWithNewline("loop_condition: {"); + indent(); + formatExpr(celComprehension.loopCondition()); + outdent(); + appendNewline(); + appendWithNewline("}"); + + // Loop step + appendWithNewline("loop_step: {"); + indent(); + formatExpr(celComprehension.loopStep()); + outdent(); + appendNewline(); + appendWithNewline("}"); + + // Result + appendWithNewline("result: {"); + indent(); + formatExpr(celComprehension.result()); + outdent(); + appendNewline(); + append("}"); + + outdent(); + } + + private void append(String str) { + exprBuilder.append(indent); + exprBuilder.append(str); + } + + private void appendWithNewline(String str) { + append(str); + appendNewline(); + } + + private void appendWithoutIndent(String str) { + exprBuilder.append(str); + } + + private void appendNewline() { + exprBuilder.append('\n'); + } + + private void indent() { + indent.append(" "); + } + + private void outdent() { + indent.setLength(indent.length() - 2); + } + + private CelExprFormatter() {} +} diff --git a/common/src/main/java/dev/cel/common/ast/CelExprIdGeneratorFactory.java b/common/src/main/java/dev/cel/common/ast/CelExprIdGeneratorFactory.java new file mode 100644 index 000000000..9b7bc60fc --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelExprIdGeneratorFactory.java @@ -0,0 +1,135 @@ +// Copyright 2023 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.ast; + +import com.google.common.base.Preconditions; +import java.util.HashMap; + +/** Factory for populating expression IDs */ +public final class CelExprIdGeneratorFactory { + + /** + * MonotonicIdGenerator increments expression IDs from an initial seed value. + * + * @param exprId Seed value. Must be non-negative. For example, if 1 is provided {@link + * MonotonicIdGenerator#nextExprId()} will return 2. + */ + public static MonotonicIdGenerator newMonotonicIdGenerator(long exprId) { + return new MonotonicIdGenerator(exprId); + } + + /** + * StableIdGenerator ensures new IDs are only created the first time they are encountered. + * + * @param exprId Seed value. Must be non-negative. For example, if 1 is provided {@link + * StableIdGenerator#renumberId(long)} will return 2. + */ + public static StableIdGenerator newStableIdGenerator(long exprId) { + return new StableIdGenerator(exprId); + } + + /** MonotonicIdGenerator increments expression IDs from an initial seed value. */ + public static class MonotonicIdGenerator { + private long exprId; + + public long nextExprId() { + return ++exprId; + } + + private MonotonicIdGenerator(long exprId) { + Preconditions.checkArgument(exprId >= 0); + this.exprId = exprId; + } + } + + /** StableIdGenerator ensures new IDs are only created the first time they are encountered. */ + public static class StableIdGenerator { + private final HashMap idSet; + private long exprId; + + /** Checks if the given ID has been encountered before. */ + public boolean hasId(long id) { + return idSet.containsKey(id); + } + + /** Generates the next available ID. */ + public long nextExprId() { + return ++exprId; + } + + /** + * Generate the next available ID while memoizing the existing ID. + * + *

The main purpose of this is to sanitize a new AST to replace an existing AST's node with. + * The incoming AST may not have its IDs consistently numbered (often, the expr IDs are just + * zeroes). In those cases, we just want to return an incremented expr ID. + * + *

The memoization becomes necessary if the incoming AST contains an expression with macro + * map populated, requiring a normalization pass. In this case, the method behaves largely the + * same as {@link #renumberId}. + * + * @param id Existing ID to memoize. Providing 0 or less will skip the memoization, in which + * case this behaves just like a {@link MonotonicIdGenerator}. + */ + public long nextExprId(long id) { + long nextExprId = ++exprId; + if (id > 0) { + idSet.put(id, nextExprId); + } + return nextExprId; + } + + /** Memoize a given expression ID with a newly generated ID. */ + public void memoize(long existingId, long newId) { + idSet.put(existingId, newId); + } + + /** + * Renumbers the existing expression ID to a newly generated unique ID. The existing ID is + * memoized, and calling this method again with the same ID will always return the same + * generated ID. + */ + public long renumberId(long id) { + Preconditions.checkArgument(id >= 0, "Expr ID must be positive. Got: %s", id); + if (id == 0) { + return 0; + } + + if (idSet.containsKey(id)) { + return idSet.get(id); + } + + long nextExprId = ++exprId; + idSet.put(id, nextExprId); + return nextExprId; + } + + private StableIdGenerator(long exprId) { + Preconditions.checkArgument(exprId >= 0); + this.idSet = new HashMap<>(); + this.exprId = exprId; + } + } + + /** Functional interface for generating the next unique expression ID. */ + @FunctionalInterface + public interface ExprIdGenerator { + + /** Generates an expression ID with the provided expr ID as the context. */ + long generate(long exprId); + } + + private CelExprIdGeneratorFactory() {} +} diff --git a/common/src/main/java/dev/cel/common/ast/CelExprV1Alpha1Converter.java b/common/src/main/java/dev/cel/common/ast/CelExprV1Alpha1Converter.java new file mode 100644 index 000000000..0e755e7a2 --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelExprV1Alpha1Converter.java @@ -0,0 +1,344 @@ +// Copyright 2022 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.ast; + +import static com.google.common.collect.ImmutableMap.toImmutableMap; + +import com.google.api.expr.v1alpha1.Constant; +import com.google.api.expr.v1alpha1.Expr; +import com.google.api.expr.v1alpha1.Expr.Call; +import com.google.api.expr.v1alpha1.Expr.Comprehension; +import com.google.api.expr.v1alpha1.Expr.CreateList; +import com.google.api.expr.v1alpha1.Expr.CreateStruct; +import com.google.api.expr.v1alpha1.Expr.CreateStruct.Entry; +import com.google.api.expr.v1alpha1.Expr.CreateStruct.Entry.KeyKindCase; +import com.google.api.expr.v1alpha1.Expr.Ident; +import com.google.api.expr.v1alpha1.Expr.Select; +import com.google.api.expr.v1alpha1.Reference; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; +import java.util.Map; +import java.util.Optional; + +/** + * Converts a proto-based Canonical Expression Tree {@link Expr} into the CEL native representation + * of Expression tree {@link CelExpr} and vice versa. + * + *

Note: Keep this file in sync with {@code CelExprV1Alpha1Converter} + */ +// LINT.IfChange +public final class CelExprV1Alpha1Converter { + private CelExprV1Alpha1Converter() {} + + /** Convert {@link CelExpr} into {@link Expr} */ + public static Expr fromCelExpr(CelExpr celExpr) { + CelExpr.ExprKind celExprKind = celExpr.exprKind(); + Expr.Builder expr = newExprBuilder(celExpr); + switch (celExprKind.getKind()) { + case CONSTANT: + return expr.setConstExpr(celConstantToExprConstant(celExprKind.constant())).build(); + case IDENT: + return expr.setIdentExpr(Ident.newBuilder().setName(celExprKind.ident().name())).build(); + case SELECT: + CelExpr.CelSelect celSelect = celExprKind.select(); + return expr.setSelectExpr( + Select.newBuilder() + .setField(celSelect.field()) + .setOperand(fromCelExpr(celSelect.operand())) + .setTestOnly(celSelect.testOnly())) + .build(); + case CALL: + CelExpr.CelCall celCall = celExprKind.call(); + Call.Builder callBuilder = + Call.newBuilder() + .setFunction(celCall.function()) + .addAllArgs(fromCelExprList(celCall.args())); + celCall.target().ifPresent(target -> callBuilder.setTarget(fromCelExpr(target))); + return expr.setCallExpr(callBuilder).build(); + case LIST: + CelExpr.CelList celList = celExprKind.list(); + return expr.setListExpr( + CreateList.newBuilder() + .addAllElements(fromCelExprList(celList.elements())) + .addAllOptionalIndices(celList.optionalIndices())) + .build(); + case STRUCT: + return expr.setStructExpr(celStructToExprStruct(celExprKind.struct())).build(); + case MAP: + return expr.setStructExpr(celMapToExprStruct(celExprKind.map())).build(); + case COMPREHENSION: + CelExpr.CelComprehension celComprehension = celExprKind.comprehension(); + return expr.setComprehensionExpr( + Comprehension.newBuilder() + .setIterVar(celComprehension.iterVar()) + .setIterVar2(celComprehension.iterVar2()) + .setIterRange(fromCelExpr(celComprehension.iterRange())) + .setAccuVar(celComprehension.accuVar()) + .setAccuInit(fromCelExpr(celComprehension.accuInit())) + .setLoopCondition(fromCelExpr(celComprehension.loopCondition())) + .setLoopStep(fromCelExpr(celComprehension.loopStep())) + .setResult(fromCelExpr(celComprehension.result()))) + .build(); + case NOT_SET: + return expr.build(); + } + throw new IllegalArgumentException( + "Unexpected expression kind case: " + celExpr.exprKind().getKind()); + } + + /** Convert {@link Expr} into {@link CelExpr} */ + public static CelExpr fromExpr(Expr expr) { + switch (expr.getExprKindCase()) { + case CONST_EXPR: + return CelExpr.ofConstant(expr.getId(), exprConstantToCelConstant(expr.getConstExpr())); + case IDENT_EXPR: + return CelExpr.ofIdent(expr.getId(), expr.getIdentExpr().getName()); + case SELECT_EXPR: + Select selectExpr = expr.getSelectExpr(); + return CelExpr.ofSelect( + expr.getId(), + fromExpr(selectExpr.getOperand()), + selectExpr.getField(), + selectExpr.getTestOnly()); + case CALL_EXPR: + Call callExpr = expr.getCallExpr(); + return CelExpr.ofCall( + expr.getId(), + callExpr.hasTarget() ? Optional.of(fromExpr(callExpr.getTarget())) : Optional.empty(), + callExpr.getFunction(), + fromExprList(callExpr.getArgsList())); + case LIST_EXPR: + CreateList createListExpr = expr.getListExpr(); + return CelExpr.ofList( + expr.getId(), + fromExprList(createListExpr.getElementsList()), + ImmutableList.copyOf(createListExpr.getOptionalIndicesList())); + case STRUCT_EXPR: + return exprStructToCelStruct(expr.getId(), expr.getStructExpr()); + case COMPREHENSION_EXPR: + Comprehension comprehensionExpr = expr.getComprehensionExpr(); + return CelExpr.ofComprehension( + expr.getId(), + comprehensionExpr.getIterVar(), + comprehensionExpr.getIterVar2(), + fromExpr(comprehensionExpr.getIterRange()), + comprehensionExpr.getAccuVar(), + fromExpr(comprehensionExpr.getAccuInit()), + fromExpr(comprehensionExpr.getLoopCondition()), + fromExpr(comprehensionExpr.getLoopStep()), + fromExpr(comprehensionExpr.getResult())); + case EXPRKIND_NOT_SET: + return CelExpr.ofNotSet(expr.getId()); + } + + throw new IllegalArgumentException( + "Unexpected expression kind case: " + expr.getExprKindCase()); + } + + private static ImmutableList fromExprList(Iterable exprList) { + ImmutableList.Builder celExprListBuilder = ImmutableList.builder(); + for (Expr expr : exprList) { + celExprListBuilder.add(fromExpr(expr)); + } + return celExprListBuilder.build(); + } + + /** + * Converts a proto-based {@link Reference} to CEL native representation of {@link CelReference}. + */ + public static CelReference exprReferenceToCelReference(Reference reference) { + CelReference.Builder builder = + CelReference.newBuilder() + .setName(reference.getName()) + .addOverloadIds(reference.getOverloadIdList()); + if (reference.hasValue()) { + builder.setValue(exprConstantToCelConstant(reference.getValue())); + } + + return builder.build(); + } + + /** + * Converts a proto-based {@link Constant} to CEL native representation of {@link CelConstant}. + */ + public static CelConstant exprConstantToCelConstant(Constant constExpr) { + switch (constExpr.getConstantKindCase()) { + case CONSTANTKIND_NOT_SET: + return CelConstant.ofNotSet(); + case NULL_VALUE: + return CelConstant.ofValue(NullValue.NULL_VALUE); + case BOOL_VALUE: + return CelConstant.ofValue(constExpr.getBoolValue()); + case INT64_VALUE: + return CelConstant.ofValue(constExpr.getInt64Value()); + case UINT64_VALUE: + return CelConstant.ofValue(UnsignedLong.fromLongBits(constExpr.getUint64Value())); + case DOUBLE_VALUE: + return CelConstant.ofValue(constExpr.getDoubleValue()); + case STRING_VALUE: + return CelConstant.ofValue(constExpr.getStringValue()); + case BYTES_VALUE: + ByteString bytesValue = constExpr.getBytesValue(); + return CelConstant.ofValue(CelByteString.of(bytesValue.toByteArray())); + case DURATION_VALUE: + return CelConstant.ofValue(constExpr.getDurationValue()); + case TIMESTAMP_VALUE: + return CelConstant.ofValue(constExpr.getTimestampValue()); + default: + throw new IllegalStateException( + "unsupported constant case: " + constExpr.getConstantKindCase()); + } + } + + private static CelExpr exprStructToCelStruct(long id, CreateStruct structExpr) { + if (!structExpr.getMessageName().isEmpty()) { + ImmutableList.Builder entries = ImmutableList.builder(); + for (Entry structExprEntry : structExpr.getEntriesList()) { + if (!structExprEntry.getKeyKindCase().equals(KeyKindCase.FIELD_KEY)) { + throw new IllegalArgumentException( + "Unexpected struct key kind case: " + structExprEntry.getKeyKindCase()); + } + entries.add( + CelExpr.ofStructEntry( + structExprEntry.getId(), + structExprEntry.getFieldKey(), + fromExpr(structExprEntry.getValue()), + structExprEntry.getOptionalEntry())); + } + + return CelExpr.ofStruct(id, structExpr.getMessageName(), entries.build()); + } else { + ImmutableList.Builder entries = ImmutableList.builder(); + for (Entry mapExprEntry : structExpr.getEntriesList()) { + if (!mapExprEntry.getKeyKindCase().equals(KeyKindCase.MAP_KEY)) { + throw new IllegalArgumentException( + "Unexpected map key kind case: " + mapExprEntry.getKeyKindCase()); + } + entries.add( + CelExpr.ofMapEntry( + mapExprEntry.getId(), + fromExpr(mapExprEntry.getMapKey()), + fromExpr(mapExprEntry.getValue()), + mapExprEntry.getOptionalEntry())); + } + + return CelExpr.ofMap(id, entries.build()); + } + } + + private static Expr.Builder newExprBuilder(CelExpr expr) { + return Expr.newBuilder().setId(expr.id()); + } + + /** + * Converts a proto-based {@link Constant} to CEL native representation of {@link CelConstant}. + */ + public static Constant celConstantToExprConstant(CelConstant celConstant) { + switch (celConstant.getKind()) { + case NOT_SET: + return Constant.getDefaultInstance(); + case NULL_VALUE: + return Constant.newBuilder().setNullValue(com.google.protobuf.NullValue.NULL_VALUE).build(); + case BOOLEAN_VALUE: + return Constant.newBuilder().setBoolValue(celConstant.booleanValue()).build(); + case INT64_VALUE: + return Constant.newBuilder().setInt64Value(celConstant.int64Value()).build(); + case UINT64_VALUE: + return Constant.newBuilder().setUint64Value(celConstant.uint64Value().longValue()).build(); + case DOUBLE_VALUE: + return Constant.newBuilder().setDoubleValue(celConstant.doubleValue()).build(); + case STRING_VALUE: + return Constant.newBuilder().setStringValue(celConstant.stringValue()).build(); + case BYTES_VALUE: + CelByteString celByteString = celConstant.bytesValue(); + return Constant.newBuilder() + .setBytesValue(ByteString.copyFrom(celByteString.toByteArray())) + .build(); + case DURATION_VALUE: + return Constant.newBuilder().setDurationValue(celConstant.durationValue()).build(); + case TIMESTAMP_VALUE: + return Constant.newBuilder().setTimestampValue(celConstant.timestampValue()).build(); + } + + throw new IllegalStateException("unsupported constant case: " + celConstant.getKind()); + } + + private static CreateStruct celStructToExprStruct(CelExpr.CelStruct celStruct) { + ImmutableList.Builder entries = ImmutableList.builder(); + for (CelExpr.CelStruct.Entry celStructExprEntry : celStruct.entries()) { + entries.add( + CreateStruct.Entry.newBuilder() + .setId(celStructExprEntry.id()) + .setFieldKey(celStructExprEntry.fieldKey()) + .setValue(fromCelExpr(celStructExprEntry.value())) + .setOptionalEntry(celStructExprEntry.optionalEntry()) + .build()); + } + + return Expr.CreateStruct.newBuilder() + .setMessageName(celStruct.messageName()) + .addAllEntries(entries.build()) + .build(); + } + + private static CreateStruct celMapToExprStruct(CelExpr.CelMap celMap) { + ImmutableList.Builder entries = ImmutableList.builder(); + for (CelExpr.CelMap.Entry celMapEntry : celMap.entries()) { + CreateStruct.Entry exprMapEntry = + CreateStruct.Entry.newBuilder() + .setId(celMapEntry.id()) + .setMapKey(fromCelExpr(celMapEntry.key())) + .setValue(fromCelExpr(celMapEntry.value())) + .setOptionalEntry(celMapEntry.optionalEntry()) + .build(); + + entries.add(exprMapEntry); + } + + return CreateStruct.newBuilder().addAllEntries(entries.build()).build(); + } + + private static ImmutableList fromCelExprList(Iterable celExprList) { + ImmutableList.Builder celExprListBuilder = ImmutableList.builder(); + for (CelExpr celExpr : celExprList) { + celExprListBuilder.add(fromCelExpr(celExpr)); + } + return celExprListBuilder.build(); + } + + /** + * Converts a proto-based {@link CelReference} to CEL native representation of {@link Reference}. + */ + public static Reference celReferenceToExprReference(CelReference reference) { + Reference.Builder builder = + Reference.newBuilder().setName(reference.name()).addAllOverloadId(reference.overloadIds()); + reference + .value() + .ifPresent(celConstant -> builder.setValue(celConstantToExprConstant(celConstant))); + + return builder.build(); + } + + public static ImmutableMap exprMacroCallsToCelExprMacroCalls( + Map macroCalls) { + return macroCalls.entrySet().stream() + .collect(toImmutableMap(Map.Entry::getKey, v -> fromExpr(v.getValue()))); + } +} +// LINT.ThenChange(CelExprConverter.java) diff --git a/common/src/main/java/dev/cel/common/ast/CelExprVisitor.java b/common/src/main/java/dev/cel/common/ast/CelExprVisitor.java new file mode 100644 index 000000000..a5a6cdf17 --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelExprVisitor.java @@ -0,0 +1,160 @@ +// Copyright 2023 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.ast; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelComprehension; +import dev.cel.common.ast.CelExpr.CelIdent; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; + +/** CEL expression visitor implementation using Cel native types. */ +public class CelExprVisitor { + + /** + * ComprehensionArg specifies the arg ordinal values for comprehension arguments, where the + * ordinal of the enum maps to the ordinal of the argument in the comprehension expression. + */ + public enum ComprehensionArg { + ITER_RANGE, + ACCU_INIT, + LOOP_CONDIITON, + LOOP_STEP, + RESULT + } + + protected CelExprVisitor() {} + + /** Visit the {@code ast} value, routing to overloads based on the kind of expression. */ + public void visit(CelAbstractSyntaxTree ast) { + visit(ast.getExpr()); + } + + /** Visit the {@code expr} value, routing to overloads based on the kind of expression. */ + public void visit(CelExpr expr) { + switch (expr.exprKind().getKind()) { + case CONSTANT: + visit(expr, expr.constant()); + break; + case IDENT: + visit(expr, expr.ident()); + break; + case SELECT: + visit(expr, expr.select()); + break; + case CALL: + visit(expr, expr.call()); + break; + case LIST: + visit(expr, expr.list()); + break; + case STRUCT: + visit(expr, expr.struct()); + break; + case MAP: + visit(expr, expr.map()); + break; + case COMPREHENSION: + visit(expr, expr.comprehension()); + break; + default: + throw new IllegalArgumentException("unexpected expr kind: " + expr.exprKind().getKind()); + } + } + + /** Visit an {@code CelIdent} expression. */ + protected void visit(CelExpr expr, CelIdent ident) {} + + /** Visit a {@code CelConstant} expression. */ + protected void visit(CelExpr expr, CelConstant constant) {} + + /** Visit a {@code CelSelect} expression. */ + protected void visit(CelExpr expr, CelSelect select) { + visit(select.operand()); + } + + /** + * Visit a {@code CelCall} expression. + * + *

Arguments to the call are provided to the {@link #visitArg} function after they have been + * {@code visit}ed. + */ + protected void visit(CelExpr expr, CelCall call) { + if (call.target().isPresent()) { + visit(call.target().get()); + } + for (int i = 0; i < call.args().size(); i++) { + CelExpr arg = call.args().get(i); + // Visit the argument prior to calling {@code visitArg(expr, arg, i)} which may be used to + // assist with expression re-writing. + visit(arg); + visitArg(expr, arg, i); + } + } + + /** Visit a {@code CelStruct} expression. */ + protected void visit(CelExpr expr, CelStruct struct) { + for (CelStruct.Entry entry : struct.entries()) { + visit(entry.value()); + } + } + + /** Visit a {@code CelMap} expression. */ + protected void visit(CelExpr expr, CelMap map) { + for (CelMap.Entry entry : map.entries()) { + visit(entry.key()); + visit(entry.value()); + } + } + + /** Visit a {@code CelList} expression. */ + protected void visit(CelExpr expr, CelList list) { + for (CelExpr elem : list.elements()) { + visit(elem); + } + } + + /** + * Visit a {@code CelComprehension} expression. + * + *

Arguments to the comprehension are provided to the {@link #visitArg} function after they + * have been {@code visit}ed. + */ + protected void visit(CelExpr expr, CelComprehension comprehension) { + visit(comprehension.iterRange()); + visitArg(expr, comprehension.iterRange(), ComprehensionArg.ITER_RANGE.ordinal()); + visit(comprehension.accuInit()); + visitArg(expr, comprehension.accuInit(), ComprehensionArg.ACCU_INIT.ordinal()); + visit(comprehension.loopCondition()); + visitArg(expr, comprehension.loopCondition(), ComprehensionArg.LOOP_CONDIITON.ordinal()); + visit(comprehension.loopStep()); + visitArg(expr, comprehension.loopStep(), ComprehensionArg.LOOP_STEP.ordinal()); + visit(comprehension.result()); + visitArg(expr, comprehension.result(), ComprehensionArg.RESULT.ordinal()); + } + + /** + * Visit the argument to an expression in the context of the calling expression. + * + *

For {@code CelCall} expressions, the arg num refers to the ordinal of the argument. + * + *

For {@code CelComprehension} expressions, the arg number refers to the ordinal of the enum + * value as it appears in {@link ComprehensionArg}. + */ + protected void visitArg(CelExpr expr, CelExpr arg, int argNum) {} +} diff --git a/common/src/main/java/dev/cel/common/ast/CelMutableExpr.java b/common/src/main/java/dev/cel/common/ast/CelMutableExpr.java new file mode 100644 index 000000000..e0fabc400 --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelMutableExpr.java @@ -0,0 +1,1209 @@ +// Copyright 2024 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.ast; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; + +import dev.cel.common.ast.CelExpr.CelNotSet; +import dev.cel.common.ast.CelExpr.ExprKind; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Optional; + +/** + * An abstract representation of a common expression that allows mutation in any of its properties. + * The expressions are semantically the same as that of the immutable {@link CelExpr}. Refer to + * {@link Expression} for details. + * + *

This allows for an efficient optimization of an AST without having to traverse and rebuild the + * entire tree. + * + *

This class is not thread-safe by design. + */ +@SuppressWarnings("unchecked") // Class ensures only the super type is used +public final class CelMutableExpr implements Expression { + private long id; + private ExprKind.Kind exprKind; + private Object exprValue; + + @Override + public long id() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + @Override + public ExprKind.Kind getKind() { + return exprKind; + } + + public CelNotSet notSet() { + checkExprKind(Kind.NOT_SET); + return (CelNotSet) exprValue; + } + + @Override + public CelConstant constant() { + checkExprKind(Kind.CONSTANT); + return (CelConstant) exprValue; + } + + @Override + public CelMutableIdent ident() { + checkExprKind(Kind.IDENT); + return (CelMutableIdent) exprValue; + } + + @Override + public CelMutableSelect select() { + checkExprKind(Kind.SELECT); + return (CelMutableSelect) exprValue; + } + + @Override + public CelMutableCall call() { + checkExprKind(Kind.CALL); + return (CelMutableCall) exprValue; + } + + @Override + public CelMutableList list() { + checkExprKind(Kind.LIST); + return (CelMutableList) exprValue; + } + + @Override + public CelMutableStruct struct() { + checkExprKind(Kind.STRUCT); + return (CelMutableStruct) exprValue; + } + + @Override + public CelMutableMap map() { + checkExprKind(Kind.MAP); + return (CelMutableMap) exprValue; + } + + @Override + public CelMutableComprehension comprehension() { + checkExprKind(Kind.COMPREHENSION); + return (CelMutableComprehension) exprValue; + } + + public void setConstant(CelConstant constant) { + this.exprKind = ExprKind.Kind.CONSTANT; + this.exprValue = checkNotNull(constant); + } + + public void setIdent(CelMutableIdent ident) { + this.exprKind = ExprKind.Kind.IDENT; + this.exprValue = checkNotNull(ident); + } + + public void setSelect(CelMutableSelect select) { + this.exprKind = ExprKind.Kind.SELECT; + this.exprValue = checkNotNull(select); + } + + public void setCall(CelMutableCall call) { + this.exprKind = ExprKind.Kind.CALL; + this.exprValue = checkNotNull(call); + } + + public void setList(CelMutableList list) { + this.exprKind = ExprKind.Kind.LIST; + this.exprValue = checkNotNull(list); + } + + public void setStruct(CelMutableStruct struct) { + this.exprKind = ExprKind.Kind.STRUCT; + this.exprValue = checkNotNull(struct); + } + + public void setMap(CelMutableMap map) { + this.exprKind = ExprKind.Kind.MAP; + this.exprValue = checkNotNull(map); + } + + public void setComprehension(CelMutableComprehension comprehension) { + this.exprKind = ExprKind.Kind.COMPREHENSION; + this.exprValue = checkNotNull(comprehension); + } + + /** A mutable identifier expression. */ + public static final class CelMutableIdent implements Ident { + private String name = ""; + + @Override + public String name() { + return name; + } + + public void setName(String name) { + this.name = checkNotNull(name); + } + + public static CelMutableIdent create(String name) { + return new CelMutableIdent(name); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CelMutableIdent) { + CelMutableIdent that = (CelMutableIdent) obj; + return this.name.equals(that.name); + } + + return false; + } + + @Override + public int hashCode() { + return name.hashCode(); + } + + private CelMutableIdent deepCopy() { + return new CelMutableIdent(name); + } + + private CelMutableIdent(String name) { + this.name = checkNotNull(name); + } + } + + /** A mutable field selection expression. e.g. `request.auth`. */ + public static final class CelMutableSelect implements Expression.Select { + private CelMutableExpr operand; + private String field = ""; + private boolean testOnly; + + @Override + public CelMutableExpr operand() { + return operand; + } + + public void setOperand(CelMutableExpr operand) { + this.operand = checkNotNull(operand); + } + + @Override + public String field() { + return field; + } + + public void setField(String field) { + this.field = checkNotNull(field); + } + + @Override + public boolean testOnly() { + return testOnly; + } + + public void setTestOnly(boolean testOnly) { + this.testOnly = testOnly; + } + + private CelMutableSelect deepCopy() { + return create(newInstance(operand()), field, testOnly); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CelMutableSelect) { + CelMutableSelect that = (CelMutableSelect) obj; + return this.operand.equals(that.operand()) + && this.field.equals(that.field()) + && this.testOnly == that.testOnly(); + } + return false; + } + + @Override + public int hashCode() { + int h = 1; + h *= 1000003; + h ^= operand.hashCode(); + h *= 1000003; + h ^= field.hashCode(); + h *= 1000003; + h ^= testOnly ? 1231 : 1237; + return h; + } + + public static CelMutableSelect create(CelMutableExpr operand, String field) { + return new CelMutableSelect(operand, field, false); + } + + public static CelMutableSelect create(CelMutableExpr operand, String field, boolean testOnly) { + return new CelMutableSelect(operand, field, testOnly); + } + + private CelMutableSelect(CelMutableExpr operand, String field, boolean testOnly) { + this.operand = checkNotNull(operand); + this.field = checkNotNull(field); + this.testOnly = testOnly; + } + } + + /** A mutable call expression. See {@link Expression.Call} */ + public static final class CelMutableCall implements Expression.Call { + private Optional target; + private String function; + private java.util.List args; + + @Override + public Optional target() { + return target; + } + + public void setTarget(CelMutableExpr target) { + this.target = Optional.of(target); + } + + @Override + public String function() { + return function; + } + + public void setFunction(String function) { + this.function = checkNotNull(function); + } + + @Override + public java.util.List args() { + return args; + } + + public void clearArgs() { + args.clear(); + } + + public void addArgs(CelMutableExpr... exprs) { + addArgs(Arrays.asList(checkNotNull(exprs))); + } + + public void addArgs(Iterable exprs) { + exprs.forEach(e -> args.add(checkNotNull(e))); + } + + public void setArgs(Collection exprs) { + this.args = new ArrayList<>(checkNotNull(exprs)); + } + + public void setArg(int index, CelMutableExpr arg) { + checkArgument(index >= 0 && index < args.size()); + args.set(index, checkNotNull(arg)); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CelMutableCall) { + CelMutableCall that = (CelMutableCall) obj; + return this.target.equals(that.target()) + && this.function.equals(that.function()) + && this.args.equals(that.args()); + } + + return false; + } + + @Override + public int hashCode() { + int h = 1; + h *= 1000003; + h ^= target.hashCode(); + h *= 1000003; + h ^= function.hashCode(); + h *= 1000003; + h ^= args.hashCode(); + return h; + } + + private CelMutableCall deepCopy() { + java.util.List copiedArgs = deepCopyList(args); + return target().isPresent() + ? create(newInstance(target.get()), function, copiedArgs) + : create(function, copiedArgs); + } + + public static CelMutableCall create(String function, CelMutableExpr... args) { + return create(function, Arrays.asList(checkNotNull(args))); + } + + public static CelMutableCall create(String function, java.util.List args) { + return new CelMutableCall(function, args); + } + + public static CelMutableCall create( + CelMutableExpr target, String function, CelMutableExpr... args) { + return create(target, function, Arrays.asList(checkNotNull(args))); + } + + public static CelMutableCall create( + CelMutableExpr target, String function, java.util.List args) { + return new CelMutableCall(target, function, args); + } + + private CelMutableCall(String function, java.util.List args) { + this.target = Optional.empty(); + this.function = checkNotNull(function); + this.args = new ArrayList<>(checkNotNull(args)); + } + + private CelMutableCall( + CelMutableExpr target, String function, java.util.List args) { + this(function, args); + this.target = Optional.of(target); + } + } + + /** A mutable list creation expression. See {@link List} */ + public static final class CelMutableList implements List { + private final java.util.List elements; + private final java.util.List optionalIndices; + + @Override + public java.util.List elements() { + return elements; + } + + public void setElement(int index, CelMutableExpr element) { + checkArgument(index >= 0 && index < elements().size()); + elements.set(index, checkNotNull(element)); + } + + @Override + public java.util.List optionalIndices() { + return optionalIndices; + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CelMutableList) { + CelMutableList that = (CelMutableList) obj; + return this.elements.equals(that.elements()) + && this.optionalIndices.equals(that.optionalIndices()); + } + + return false; + } + + @Override + public int hashCode() { + int h = 1; + h *= 1000003; + h ^= elements.hashCode(); + h *= 1000003; + h ^= optionalIndices.hashCode(); + + return h; + } + + private CelMutableList deepCopy() { + return create(deepCopyList(elements), optionalIndices); + } + + public static CelMutableList create(CelMutableExpr... elements) { + return create(Arrays.asList(checkNotNull(elements))); + } + + public static CelMutableList create(java.util.List elements) { + return create(elements, new ArrayList<>()); + } + + public static CelMutableList create( + java.util.List mutableExprList, java.util.List optionalIndices) { + return new CelMutableList(mutableExprList, optionalIndices); + } + + private CelMutableList( + java.util.List mutableExprList, java.util.List optionalIndices) { + this.elements = new ArrayList<>(checkNotNull(mutableExprList)); + this.optionalIndices = new ArrayList<>(checkNotNull(optionalIndices)); + } + } + + /** A mutable list creation expression. See {@link Expression.Struct} */ + public static final class CelMutableStruct implements Expression.Struct { + private String messageName = ""; + private java.util.List entries; + + @Override + public String messageName() { + return messageName; + } + + public void setMessageName(String messageName) { + this.messageName = checkNotNull(messageName); + } + + @Override + public java.util.List entries() { + return entries; + } + + public void setEntries(java.util.List entries) { + this.entries = checkNotNull(entries); + } + + public void setEntry(int index, CelMutableStruct.Entry entry) { + checkArgument(index >= 0 && index < entries().size()); + entries.set(index, checkNotNull(entry)); + } + + /** Represents a mutable entry of the struct. */ + public static final class Entry implements Expression.Struct.Entry { + private long id; + private String fieldKey = ""; + private CelMutableExpr value; + private boolean optionalEntry; + + @Override + public long id() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + @Override + public String fieldKey() { + return fieldKey; + } + + public void setFieldKey(String fieldKey) { + this.fieldKey = checkNotNull(fieldKey); + } + + @Override + public CelMutableExpr value() { + return value; + } + + public void setValue(CelMutableExpr value) { + this.value = checkNotNull(value); + } + + @Override + public boolean optionalEntry() { + return optionalEntry; + } + + public void setOptionalEntry(boolean optionalEntry) { + this.optionalEntry = optionalEntry; + } + + private Entry deepCopy() { + return create(id, fieldKey, newInstance(value), optionalEntry); + } + + public static Entry create(long id, String fieldKey, CelMutableExpr value) { + return create(id, fieldKey, value, false); + } + + public static Entry create( + long id, String fieldKey, CelMutableExpr value, boolean optionalEntry) { + return new Entry(id, fieldKey, value, optionalEntry); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof Entry) { + Entry that = (Entry) obj; + return this.id == that.id() + && this.fieldKey.equals(that.fieldKey()) + && this.value.equals(that.value()) + && this.optionalEntry == that.optionalEntry(); + } + return false; + } + + @Override + public int hashCode() { + int h = 1; + h *= 1000003; + h ^= (int) ((id >>> 32) ^ id); + h *= 1000003; + h ^= fieldKey.hashCode(); + h *= 1000003; + h ^= value.hashCode(); + h *= 1000003; + h ^= optionalEntry ? 1231 : 1237; + return h; + } + + private Entry(long id, String fieldKey, CelMutableExpr value, boolean optionalEntry) { + this.id = id; + this.fieldKey = checkNotNull(fieldKey); + this.value = checkNotNull(value); + this.optionalEntry = optionalEntry; + } + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CelMutableStruct) { + CelMutableStruct that = (CelMutableStruct) obj; + return this.messageName.equals(that.messageName()) && this.entries.equals(that.entries()); + } + return false; + } + + @Override + public int hashCode() { + int h = 1; + h *= 1000003; + h ^= messageName.hashCode(); + h *= 1000003; + h ^= entries.hashCode(); + return h; + } + + private CelMutableStruct deepCopy() { + ArrayList copiedEntries = new ArrayList<>(); + for (CelMutableStruct.Entry entry : entries) { + copiedEntries.add(entry.deepCopy()); + } + + return create(messageName, copiedEntries); + } + + public static CelMutableStruct create( + String messageName, java.util.List entries) { + return new CelMutableStruct(messageName, entries); + } + + private CelMutableStruct(String messageName, java.util.List entries) { + this.messageName = checkNotNull(messageName); + this.entries = new ArrayList<>(checkNotNull(entries)); + } + } + + /** A mutable map creation expression. See {@link Expression.Map} */ + public static final class CelMutableMap implements Expression.Map { + private java.util.List entries; + + @Override + public java.util.List entries() { + return entries; + } + + public void setEntries(java.util.List entries) { + this.entries = checkNotNull(entries); + } + + public void setEntry(int index, CelMutableMap.Entry entry) { + checkArgument(index >= 0 && index < entries().size()); + entries.set(index, checkNotNull(entry)); + } + + /** Represents an entry of the map */ + public static final class Entry implements Expression.Map.Entry { + private long id; + private CelMutableExpr key; + private CelMutableExpr value; + private boolean optionalEntry; + + @Override + public long id() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + @Override + public CelMutableExpr key() { + return key; + } + + public void setKey(CelMutableExpr key) { + this.key = checkNotNull(key); + } + + @Override + public CelMutableExpr value() { + return value; + } + + public void setValue(CelMutableExpr value) { + this.value = checkNotNull(value); + } + + @Override + public boolean optionalEntry() { + return optionalEntry; + } + + public void setOptionalEntry(boolean optionalEntry) { + this.optionalEntry = optionalEntry; + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof Entry) { + Entry that = (Entry) obj; + return this.id == that.id() + && this.key.equals(that.key()) + && this.value.equals(that.value()) + && this.optionalEntry == that.optionalEntry(); + } + return false; + } + + @Override + public int hashCode() { + int h = 1; + h *= 1000003; + h ^= (int) ((id >>> 32) ^ id); + h *= 1000003; + h ^= key.hashCode(); + h *= 1000003; + h ^= value.hashCode(); + h *= 1000003; + h ^= optionalEntry ? 1231 : 1237; + return h; + } + + private Entry deepCopy() { + return create(id, newInstance(key), newInstance(value), optionalEntry); + } + + public static Entry create(CelMutableExpr key, CelMutableExpr value) { + return create(0, key, value, false); + } + + public static Entry create(long id, CelMutableExpr key, CelMutableExpr value) { + return create(id, key, value, false); + } + + public static Entry create( + long id, CelMutableExpr key, CelMutableExpr value, boolean optionalEntry) { + return new Entry(id, key, value, optionalEntry); + } + + private Entry(long id, CelMutableExpr key, CelMutableExpr value, boolean optionalEntry) { + this.id = id; + this.key = checkNotNull(key); + this.value = checkNotNull(value); + this.optionalEntry = optionalEntry; + } + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CelMutableMap) { + CelMutableMap that = (CelMutableMap) obj; + return this.entries.equals(that.entries()); + } + return false; + } + + @Override + public int hashCode() { + int h = 1; + h *= 1000003; + h ^= entries.hashCode(); + return h; + } + + private CelMutableMap deepCopy() { + ArrayList copiedEntries = new ArrayList<>(); + for (CelMutableMap.Entry entry : entries) { + copiedEntries.add(entry.deepCopy()); + } + + return create(copiedEntries); + } + + public static CelMutableMap create(java.util.List entries) { + return new CelMutableMap(new ArrayList<>(entries)); + } + + private CelMutableMap(java.util.List entries) { + this.entries = checkNotNull(entries); + } + } + + /** + * A mutable comprehension expression applied to a list or map. See {@link + * Expression.Comprehension} + */ + public static final class CelMutableComprehension + implements Expression.Comprehension { + + private String iterVar; + + private String iterVar2; + + private CelMutableExpr iterRange; + + private String accuVar; + + private CelMutableExpr accuInit; + + private CelMutableExpr loopCondition; + + private CelMutableExpr loopStep; + + private CelMutableExpr result; + + @Override + public String iterVar() { + return iterVar; + } + + @Override + public String iterVar2() { + return iterVar2; + } + + public void setIterVar(String iterVar) { + this.iterVar = checkNotNull(iterVar); + } + + public void setIterVar2(String iterVar2) { + this.iterVar2 = checkNotNull(iterVar2); + } + + @Override + public CelMutableExpr iterRange() { + return iterRange; + } + + public void setIterRange(CelMutableExpr iterRange) { + this.iterRange = checkNotNull(iterRange); + } + + @Override + public String accuVar() { + return accuVar; + } + + public void setAccuVar(String accuVar) { + this.accuVar = checkNotNull(accuVar); + } + + @Override + public CelMutableExpr accuInit() { + return accuInit; + } + + public void setAccuInit(CelMutableExpr accuInit) { + this.accuInit = checkNotNull(accuInit); + } + + @Override + public CelMutableExpr loopCondition() { + return loopCondition; + } + + public void setLoopCondition(CelMutableExpr loopCondition) { + this.loopCondition = checkNotNull(loopCondition); + } + + @Override + public CelMutableExpr loopStep() { + return loopStep; + } + + public void setLoopStep(CelMutableExpr loopStep) { + this.loopStep = checkNotNull(loopStep); + } + + @Override + public CelMutableExpr result() { + return result; + } + + public void setResult(CelMutableExpr result) { + this.result = checkNotNull(result); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CelMutableComprehension) { + CelMutableComprehension that = (CelMutableComprehension) obj; + return this.iterVar.equals(that.iterVar()) + && this.iterVar2.equals(that.iterVar2()) + && this.accuVar.equals(that.accuVar()) + && this.iterRange.equals(that.iterRange()) + && this.accuInit.equals(that.accuInit()) + && this.loopCondition.equals(that.loopCondition()) + && this.loopStep.equals(that.loopStep()) + && this.result.equals(that.result()); + } + return false; + } + + @Override + public int hashCode() { + int h = 1; + h *= 1000003; + h ^= iterVar.hashCode(); + h *= 1000003; + h ^= iterVar2.hashCode(); + h *= 1000003; + h ^= iterRange.hashCode(); + h *= 1000003; + h ^= accuVar.hashCode(); + h *= 1000003; + h ^= accuInit.hashCode(); + h *= 1000003; + h ^= loopCondition.hashCode(); + h *= 1000003; + h ^= loopStep.hashCode(); + h *= 1000003; + h ^= result.hashCode(); + return h; + } + + private CelMutableComprehension deepCopy() { + return create( + iterVar, + iterVar2, + newInstance(iterRange), + accuVar, + newInstance(accuInit), + newInstance(loopCondition), + newInstance(loopStep), + newInstance(result)); + } + + public static CelMutableComprehension create( + String iterVar, + CelMutableExpr iterRange, + String accuVar, + CelMutableExpr accuInit, + CelMutableExpr loopCondition, + CelMutableExpr loopStep, + CelMutableExpr result) { + return create( + iterVar, + /* iterVar2= */ "", + iterRange, + accuVar, + accuInit, + loopCondition, + loopStep, + result); + } + + public static CelMutableComprehension create( + String iterVar, + String iterVar2, + CelMutableExpr iterRange, + String accuVar, + CelMutableExpr accuInit, + CelMutableExpr loopCondition, + CelMutableExpr loopStep, + CelMutableExpr result) { + return new CelMutableComprehension( + iterVar, iterVar2, iterRange, accuVar, accuInit, loopCondition, loopStep, result); + } + + private CelMutableComprehension( + String iterVar, + String iterVar2, + CelMutableExpr iterRange, + String accuVar, + CelMutableExpr accuInit, + CelMutableExpr loopCondition, + CelMutableExpr loopStep, + CelMutableExpr result) { + this.iterVar = checkNotNull(iterVar); + this.iterVar2 = checkNotNull(iterVar2); + this.iterRange = checkNotNull(iterRange); + this.accuVar = checkNotNull(accuVar); + this.accuInit = checkNotNull(accuInit); + this.loopCondition = checkNotNull(loopCondition); + this.loopStep = checkNotNull(loopStep); + this.result = checkNotNull(result); + } + } + + public static CelMutableExpr ofNotSet() { + return ofNotSet(0L); + } + + public static CelMutableExpr ofNotSet(long id) { + return new CelMutableExpr(id); + } + + public static CelMutableExpr ofConstant(CelConstant constant) { + return ofConstant(0L, constant); + } + + public static CelMutableExpr ofConstant(long id, CelConstant constant) { + return new CelMutableExpr(id, constant); + } + + public static CelMutableExpr ofIdent(String name) { + return ofIdent(0, name); + } + + public static CelMutableExpr ofIdent(long id, String name) { + return new CelMutableExpr(id, CelMutableIdent.create(name)); + } + + public static CelMutableExpr ofSelect(CelMutableSelect mutableSelect) { + return ofSelect(0, mutableSelect); + } + + public static CelMutableExpr ofSelect(long id, CelMutableSelect mutableSelect) { + return new CelMutableExpr(id, mutableSelect); + } + + public static CelMutableExpr ofCall(CelMutableCall mutableCall) { + return ofCall(0, mutableCall); + } + + public static CelMutableExpr ofCall(long id, CelMutableCall mutableCall) { + return new CelMutableExpr(id, mutableCall); + } + + public static CelMutableExpr ofList(CelMutableList mutableList) { + return ofList(0, mutableList); + } + + public static CelMutableExpr ofList(long id, CelMutableList mutableList) { + return new CelMutableExpr(id, mutableList); + } + + public static CelMutableExpr ofStruct(CelMutableStruct mutableStruct) { + return ofStruct(0, mutableStruct); + } + + public static CelMutableExpr ofStruct(long id, CelMutableStruct mutableStruct) { + return new CelMutableExpr(id, mutableStruct); + } + + public static CelMutableExpr ofMap(CelMutableMap mutableMap) { + return ofMap(0, mutableMap); + } + + public static CelMutableExpr ofMap(long id, CelMutableMap mutableMap) { + return new CelMutableExpr(id, mutableMap); + } + + public static CelMutableExpr ofComprehension(CelMutableComprehension mutableComprehension) { + return ofComprehension(0, mutableComprehension); + } + + public static CelMutableExpr ofComprehension( + long id, CelMutableComprehension mutableComprehension) { + return new CelMutableExpr(id, mutableComprehension); + } + + /** Constructs a deep copy of the mutable expression. */ + public static CelMutableExpr newInstance(CelMutableExpr other) { + return new CelMutableExpr(other); + } + + private CelMutableExpr(long id, CelConstant mutableConstant) { + this.id = id; + setConstant(mutableConstant); + } + + private CelMutableExpr(long id, CelMutableIdent mutableIdent) { + this.id = id; + setIdent(mutableIdent); + } + + private CelMutableExpr(long id, CelMutableSelect mutableSelect) { + this.id = id; + setSelect(mutableSelect); + } + + private CelMutableExpr(long id, CelMutableCall mutableCall) { + this.id = id; + setCall(mutableCall); + } + + private CelMutableExpr(long id, CelMutableList mutableList) { + this.id = id; + setList(mutableList); + } + + private CelMutableExpr(long id, CelMutableStruct mutableStruct) { + this.id = id; + setStruct(mutableStruct); + } + + private CelMutableExpr(long id, CelMutableMap mutableMap) { + this.id = id; + setMap(mutableMap); + } + + private CelMutableExpr(long id, CelMutableComprehension mutableComprehension) { + this.id = id; + setComprehension(mutableComprehension); + } + + private CelMutableExpr(long id) { + this(); + this.id = id; + } + + private CelMutableExpr() { + this.exprValue = CelExpr.newBuilder().build().exprKind().notSet(); + this.exprKind = ExprKind.Kind.NOT_SET; + } + + private CelMutableExpr(CelMutableExpr other) { + checkNotNull(other); + this.id = other.id; + this.exprKind = other.exprKind; + switch (other.getKind()) { + case NOT_SET: + this.exprValue = CelExpr.newBuilder().build().exprKind().notSet(); + break; + case CONSTANT: + this.exprValue = other.exprValue; // Constant is immutable. + break; + case IDENT: + this.exprValue = other.ident().deepCopy(); + break; + case SELECT: + this.exprValue = other.select().deepCopy(); + break; + case CALL: + this.exprValue = other.call().deepCopy(); + break; + case LIST: + this.exprValue = other.list().deepCopy(); + break; + case STRUCT: + this.exprValue = other.struct().deepCopy(); + break; + case MAP: + this.exprValue = other.map().deepCopy(); + break; + case COMPREHENSION: + this.exprValue = other.comprehension().deepCopy(); + break; + default: + throw new IllegalStateException("Unexpected expr kind: " + this.exprKind); + } + } + + private Object exprValue() { + switch (this.exprKind) { + case NOT_SET: + return notSet(); + case CONSTANT: + return constant(); + case IDENT: + return ident(); + case SELECT: + return select(); + case CALL: + return call(); + case LIST: + return list(); + case STRUCT: + return struct(); + case MAP: + return map(); + case COMPREHENSION: + return comprehension(); + } + + throw new IllegalStateException("Unexpected expr kind: " + this.exprKind); + } + + private static java.util.List deepCopyList( + java.util.List elements) { + ArrayList copiedArgs = new ArrayList<>(); + for (CelMutableExpr arg : elements) { + copiedArgs.add(newInstance(arg)); + } + + return copiedArgs; + } + + private void checkExprKind(ExprKind.Kind exprKind) { + checkArgument(this.exprKind.equals(exprKind), "Invalid ExprKind: %s", exprKind); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CelMutableExpr) { + CelMutableExpr that = (CelMutableExpr) obj; + if (this.id != that.id() || !this.exprKind.equals(that.getKind())) { + return false; + } + + return this.exprValue().equals(that.exprValue()); + } + + return false; + } + + @Override + public String toString() { + return CelMutableExprConverter.fromMutableExpr(this).toString(); + } + + @Override + public int hashCode() { + int h = 1; + h *= 1000003; + h ^= (int) ((id >>> 32) ^ id); + h *= 1000003; + h ^= this.exprValue().hashCode(); + + return h; + } +} diff --git a/common/src/main/java/dev/cel/common/ast/CelMutableExprConverter.java b/common/src/main/java/dev/cel/common/ast/CelMutableExprConverter.java new file mode 100644 index 000000000..3e9ebc9c3 --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelMutableExprConverter.java @@ -0,0 +1,231 @@ +// Copyright 2024 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.ast; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static java.util.stream.Collectors.toCollection; + +import com.google.common.collect.ImmutableList; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelComprehension; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.common.ast.CelMutableExpr.CelMutableCall; +import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; +import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +/** + * Converts a mutable Expression Tree {@link CelMutableExpr} into the CEL native representation of + * Expression tree {@link CelExpr} and vice versa. + */ +public final class CelMutableExprConverter { + + public static CelMutableExpr fromCelExpr(CelExpr celExpr) { + CelExpr.ExprKind celExprKind = celExpr.exprKind(); + switch (celExprKind.getKind()) { + case CONSTANT: + return CelMutableExpr.ofConstant(celExpr.id(), celExpr.constant()); + case IDENT: + return CelMutableExpr.ofIdent(celExpr.id(), celExpr.ident().name()); + case SELECT: + CelSelect select = celExpr.select(); + CelMutableExpr operand = fromCelExpr(select.operand()); + return CelMutableExpr.ofSelect( + celExpr.id(), CelMutableSelect.create(operand, select.field(), select.testOnly())); + case CALL: + CelCall celCall = celExprKind.call(); + List args = + celCall.args().stream() + .map(CelMutableExprConverter::fromCelExpr) + .collect(toCollection(ArrayList::new)); + CelMutableCall mutableCall = + celCall.target().isPresent() + ? CelMutableCall.create( + fromCelExpr(celCall.target().get()), celCall.function(), args) + : CelMutableCall.create(celCall.function(), args); + + return CelMutableExpr.ofCall(celExpr.id(), mutableCall); + case LIST: + CelList createList = celExpr.list(); + return CelMutableExpr.ofList( + celExpr.id(), + CelMutableList.create( + fromCelExprList(createList.elements()), createList.optionalIndices())); + case STRUCT: + return CelMutableExpr.ofStruct( + celExpr.id(), fromCelStructToMutableStruct(celExpr.struct())); + case MAP: + return CelMutableExpr.ofMap(celExpr.id(), fromCelMapToMutableMap(celExpr.map())); + case COMPREHENSION: + CelComprehension celComprehension = celExprKind.comprehension(); + CelMutableComprehension mutableComprehension = + CelMutableComprehension.create( + celComprehension.iterVar(), + celComprehension.iterVar2(), + fromCelExpr(celComprehension.iterRange()), + celComprehension.accuVar(), + fromCelExpr(celComprehension.accuInit()), + fromCelExpr(celComprehension.loopCondition()), + fromCelExpr(celComprehension.loopStep()), + fromCelExpr(celComprehension.result())); + return CelMutableExpr.ofComprehension(celExpr.id(), mutableComprehension); + case NOT_SET: + return CelMutableExpr.ofNotSet(celExpr.id()); + } + + throw new IllegalArgumentException( + "Unexpected expression kind case: " + celExpr.exprKind().getKind()); + } + + private static List fromCelExprList(Iterable celExprList) { + ArrayList mutableExprList = new ArrayList<>(); + for (CelExpr celExpr : celExprList) { + mutableExprList.add(fromCelExpr(celExpr)); + } + return mutableExprList; + } + + private static CelMutableStruct fromCelStructToMutableStruct(CelStruct celStruct) { + List entries = new ArrayList<>(); + for (CelStruct.Entry celStructExprEntry : celStruct.entries()) { + entries.add( + CelMutableStruct.Entry.create( + celStructExprEntry.id(), + celStructExprEntry.fieldKey(), + fromCelExpr(celStructExprEntry.value()), + celStructExprEntry.optionalEntry())); + } + + return CelMutableStruct.create(celStruct.messageName(), entries); + } + + private static CelMutableMap fromCelMapToMutableMap(CelMap celMap) { + List entries = new ArrayList<>(); + for (CelMap.Entry celMapExprEntry : celMap.entries()) { + entries.add( + CelMutableMap.Entry.create( + celMapExprEntry.id(), + fromCelExpr(celMapExprEntry.key()), + fromCelExpr(celMapExprEntry.value()), + celMapExprEntry.optionalEntry())); + } + + return CelMutableMap.create(entries); + } + + public static CelExpr fromMutableExpr(CelMutableExpr mutableExpr) { + long id = mutableExpr.id(); + switch (mutableExpr.getKind()) { + case CONSTANT: + return CelExpr.ofConstant(id, mutableExpr.constant()); + case IDENT: + return CelExpr.ofIdent(id, mutableExpr.ident().name()); + case SELECT: + CelMutableSelect select = mutableExpr.select(); + CelExpr operand = fromMutableExpr(select.operand()); + return CelExpr.ofSelect(id, operand, select.field(), select.testOnly()); + case CALL: + CelMutableCall mutableCall = mutableExpr.call(); + ImmutableList args = + mutableCall.args().stream() + .map(CelMutableExprConverter::fromMutableExpr) + .collect(toImmutableList()); + Optional targetExpr = + mutableCall.target().map(CelMutableExprConverter::fromMutableExpr); + return CelExpr.ofCall(id, targetExpr, mutableCall.function(), args); + case LIST: + CelMutableList mutableList = mutableExpr.list(); + return CelExpr.ofList( + id, + fromMutableExprList(mutableList.elements()), + ImmutableList.copyOf(mutableList.optionalIndices())); + case STRUCT: + CelMutableStruct mutableStruct = mutableExpr.struct(); + return CelExpr.newBuilder() + .setId(id) + .setStruct(fromMutableStructToCelStruct(mutableStruct)) + .build(); + case MAP: + CelMutableMap mutableMap = mutableExpr.map(); + return CelExpr.newBuilder().setId(id).setMap(fromMutableMapToCelMap(mutableMap)).build(); + case COMPREHENSION: + CelMutableComprehension mutableComprehension = mutableExpr.comprehension(); + return CelExpr.ofComprehension( + id, + mutableComprehension.iterVar(), + mutableComprehension.iterVar2(), + fromMutableExpr(mutableComprehension.iterRange()), + mutableComprehension.accuVar(), + fromMutableExpr(mutableComprehension.accuInit()), + fromMutableExpr(mutableComprehension.loopCondition()), + fromMutableExpr(mutableComprehension.loopStep()), + fromMutableExpr(mutableComprehension.result())); + case NOT_SET: + return CelExpr.ofNotSet(id); + } + + throw new IllegalArgumentException("Unexpected expression kind case: " + mutableExpr.getKind()); + } + + private static ImmutableList fromMutableExprList( + Iterable mutableExprList) { + ImmutableList.Builder celExprList = ImmutableList.builder(); + for (CelMutableExpr mutableExpr : mutableExprList) { + celExprList.add(fromMutableExpr(mutableExpr)); + } + return celExprList.build(); + } + + private static CelStruct fromMutableStructToCelStruct(CelMutableStruct mutableStruct) { + List entries = new ArrayList<>(); + for (CelMutableStruct.Entry mutableStructEntry : mutableStruct.entries()) { + entries.add( + CelExpr.ofStructEntry( + mutableStructEntry.id(), + mutableStructEntry.fieldKey(), + fromMutableExpr(mutableStructEntry.value()), + mutableStructEntry.optionalEntry())); + } + + return CelStruct.newBuilder() + .setMessageName(mutableStruct.messageName()) + .addEntries(entries) + .build(); + } + + private static CelMap fromMutableMapToCelMap(CelMutableMap mutableMap) { + List entries = new ArrayList<>(); + for (CelMutableMap.Entry mutableMapEntry : mutableMap.entries()) { + entries.add( + CelExpr.ofMapEntry( + mutableMapEntry.id(), + fromMutableExpr(mutableMapEntry.key()), + fromMutableExpr(mutableMapEntry.value()), + mutableMapEntry.optionalEntry())); + } + + return CelMap.newBuilder().addEntries(entries).build(); + } + + private CelMutableExprConverter() {} +} diff --git a/common/src/main/java/dev/cel/common/ast/CelReference.java b/common/src/main/java/dev/cel/common/ast/CelReference.java new file mode 100644 index 000000000..94c2c7aaf --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/CelReference.java @@ -0,0 +1,85 @@ +// Copyright 2023 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.ast; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import java.util.Arrays; +import java.util.Optional; + +/** + * Describes a resolved reference to a declaration. + * + *

This is the CEL-Java native type equivalent of Reference message type from checked.proto. + */ +@AutoValue +@Internal +@Immutable +public abstract class CelReference { + public abstract String name(); + + public abstract ImmutableList overloadIds(); + + public abstract Optional value(); + + /** Builder for configuring the {@link CelReference} */ + @AutoValue.Builder + public abstract static class Builder { + public abstract Builder setName(String name); + + public abstract Builder setValue(CelConstant value); + + abstract ImmutableList overloadIds(); + + abstract Optional value(); + + abstract ImmutableList.Builder overloadIdsBuilder(); + + @CanIgnoreReturnValue + public Builder addOverloadIds(String... overloadIds) { + checkNotNull(overloadIds); + return addOverloadIds(Arrays.asList(overloadIds)); + } + + @CanIgnoreReturnValue + public Builder addOverloadIds(Iterable overloadIds) { + checkNotNull(overloadIds); + this.overloadIdsBuilder().addAll(overloadIds); + return this; + } + + @CheckReturnValue + abstract CelReference autoBuild(); + + public final CelReference build() { + CelReference celReference = autoBuild(); + Preconditions.checkArgument( + !value().isPresent() || overloadIds().isEmpty(), + "Value and overloadIds cannot be set at the same time."); + return celReference; + } + } + + public static CelReference.Builder newBuilder() { + return new AutoValue_CelReference.Builder().setName(""); + } +} diff --git a/common/src/main/java/dev/cel/common/ast/Expression.java b/common/src/main/java/dev/cel/common/ast/Expression.java new file mode 100644 index 000000000..b32598857 --- /dev/null +++ b/common/src/main/java/dev/cel/common/ast/Expression.java @@ -0,0 +1,282 @@ +// Copyright 2024 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.ast; + +import dev.cel.common.annotations.Internal; +import java.util.Optional; + +/** + * An abstract representation of a common expression. + * + *

Expressions are abstractly represented as a collection of identifiers, select statements, + * function calls, literals, and comprehensions. All operators with the exception of the '.' + * operator are modelled as function calls. This makes it easy to represent new operators into the + * existing AST. + * + *

All references within expressions must resolve to a [Decl][] provided at type-check for an + * expression to be valid. A reference may either be a bare identifier `name` or a qualified + * identifier `google.api.name`. References may either refer to a value or a function declaration. + * + *

For example, the expression `google.api.name.startsWith('expr')` references the declaration + * `google.api.name` within a [Expr.Select][] expression, and the function declaration `startsWith`. + */ +@Internal +public interface Expression { + + /** + * Required. An id assigned to this node by the parser which is unique in a given expression tree. + * This is used to associate type information and other attributes to a node in the parse tree. + */ + long id(); + + /** Represents the enumeration value for the underlying expression kind. */ + CelExpr.ExprKind.Kind getKind(); + + /** Gets the underlying constant expression. */ + CelConstant constant(); + + /** Gets the underlying identifier expression. */ + Ident ident(); + + /** Gets the underlying call expression. */ + Call call(); + + /** Gets the underlying identifier expression. */ + List list(); + + /** Gets the underlying select expression. */ + Select select(); + + /** Gets the underlying struct expression. */ + Struct> struct(); + + /** Gets the underlying map expression. */ + Map> map(); + + /** Gets the underlying comprehension expression. */ + Comprehension comprehension(); + + /** An identifier expression. e.g. `request`. */ + interface Ident { + + /** + * Required. Holds a single, unqualified identifier, possibly preceded by a '.'. + * + *

Qualified names are represented by the [Expr.Select][] expression. + */ + String name(); + } + + /** A call expression, including calls to predefined functions and operators. */ + interface Call { + /** + * The target of a method call-style expression. + * + *

For example, `x` in `x.f()`. + */ + Optional target(); + + /** Required. The name of the function or method being called. */ + String function(); + + /** + * Arguments to the call. + * + *

For example, `foo` in `f(foo)` or `x.f(foo)`. + */ + java.util.List args(); + } + + /** + * A list creation expression. + * + *

Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogeneous, e.g. `dyn([1, 'hello', + * 2.0])` + */ + interface List { + + /** The elements part of the list */ + java.util.List elements(); + + /** + * The indices within the elements list which are marked as optional elements. + * + *

When an optional-typed value is present, the value it contains is included in the list. If + * the optional-typed value is absent, the list element is omitted from the list result. + */ + java.util.List optionalIndices(); + } + + /** A field selection expression. e.g. `request.auth`. */ + interface Select { + /** + * Required. The target of the selection expression. + * + *

For example, in the select expression `request.auth`, the `request` portion of the + * expression is the `operand`. + */ + E operand(); + + /** + * Required. The name of the field to select. + * + *

For example, in the select expression `request.auth`, the `auth` portion of the expression + * would be the `field`. + */ + String field(); + + /** + * Whether the select is to be interpreted as a field presence test. + * + *

This results from the macro `has(request.auth)`. + */ + boolean testOnly(); + } + + /** + * A message creation expression. + * + *

Messages are constructed with a type name and composed of field ids: `types.MyType{field_id: + * 'value'}`. + */ + interface Struct> { + + /** The type name of the message to be created, empty when creating map literals. */ + String messageName(); + + /** The entries in the creation expression. */ + java.util.List entries(); + + /** Represents an entry of the struct */ + interface Entry { + /** + * Required. An id assigned to this node by the parser which is unique in a given expression + * tree. This is used to associate type information and other attributes to the node. + */ + long id(); + + /** Entry key kind. */ + String fieldKey(); + + /** + * Required. The value assigned to the key. + * + *

If the optional_entry field is true, the expression must resolve to an optional-typed + * value. If the optional value is present, the key will be set; however, if the optional + * value is absent, the key will be unset. + */ + T value(); + + /** Whether the key-value pair is optional. */ + boolean optionalEntry(); + } + } + + /** + * A map creation expression. + * + *

Maps are constructed as `{'key_name': 'value'}`. + */ + interface Map> { + + java.util.List entries(); + + /** Represents an entry of the map. */ + interface Entry { + /** + * Required. An id assigned to this node by the parser which is unique in a given expression + * tree. This is used to associate type information and other attributes to the node. + */ + long id(); + + /** Required. The key. */ + T key(); + + /** + * Required. The value assigned to the key. + * + *

If the optional_entry field is true, the expression must resolve to an optional-typed + * value. If the optional value is present, the key will be set; however, if the optional + * value is absent, the key will be unset. + */ + T value(); + + boolean optionalEntry(); + } + } + + /** + * A comprehension expression applied to a list or map. + * + *

Comprehensions are not part of the core syntax, but enabled with macros. A macro matches a + * specific call signature within a parsed AST and replaces the call with an alternate AST block. + * Macro expansion happens at parse time. + * + *

The following macros are supported within CEL: + * + *

Aggregate type macros may be applied to all elements in a list or all keys in a map: + * + *

`all`, `exists`, `exists_one` - test a predicate expression against the inputs and return + * `true` if the predicate is satisfied for all, any, or only one value `list.all(x, x < 10)`. + * `filter` - test a predicate expression against the inputs and return the subset of elements + * which satisfy the predicate: `payments.filter(p, p > 1000)`. `map` - apply an expression to all + * elements in the input and return the output aggregate type: `[1, 2, 3].map(i, i * i)`. + * + *

The `has(m.x)` macro tests whether the property `x` is present in struct `m`. The semantics + * of this macro depend on the type of `m`. For proto2 messages `has(m.x)` is defined as 'defined, + * but not set`. For proto3, the macro tests whether the property is set to its default. For map + * and struct types, the macro tests whether the property `x` is defined on `m`. + * + *

Comprehension evaluation can be best visualized as the following pseudocode: + */ + interface Comprehension { + /** The name of the iteration variable. */ + String iterVar(); + + /** The name of the second iteration variable. */ + String iterVar2(); + + /** The range over which var iterates. */ + E iterRange(); + + /** The name of the variable used for accumulation of the result. */ + String accuVar(); + + /** The initial value of the accumulator. */ + E accuInit(); + + /** + * An expression which can contain iter_var and accu_var. + * + *

Returns false when the result has been computed and may be used as a hint to short-circuit + * the remainder of the comprehension. + */ + E loopCondition(); + + /** + * An expression which can contain iter_var and accu_var. + * + *

Computes the next value of accu_var. + */ + E loopStep(); + + /** + * An expression which can contain accu_var. + * + *

Computes the result. + */ + E result(); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/BUILD.bazel b/common/src/main/java/dev/cel/common/exceptions/BUILD.bazel new file mode 100644 index 000000000..672238cf0 --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/BUILD.bazel @@ -0,0 +1,138 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//common/exceptions:__pkg__", + "//publish:__pkg__", + ], +) + +java_library( + name = "runtime_exception", + srcs = ["CelRuntimeException.java"], + # used_by_android + tags = [ + ], + deps = [ + "//common:error_codes", + "//common/annotations", + ], +) + +java_library( + name = "attribute_not_found", + srcs = ["CelAttributeNotFoundException.java"], + # used_by_android + tags = [ + ], + deps = [ + ":runtime_exception", + "//common:error_codes", + "//common/annotations", + ], +) + +java_library( + name = "divide_by_zero", + srcs = ["CelDivideByZeroException.java"], + # used_by_android + tags = [ + ], + deps = [ + ":runtime_exception", + "//common:error_codes", + "//common/annotations", + ], +) + +java_library( + name = "index_out_of_bounds", + srcs = ["CelIndexOutOfBoundsException.java"], + # used_by_android + tags = [ + ], + deps = [ + ":runtime_exception", + "//common:error_codes", + "//common/annotations", + ], +) + +java_library( + name = "bad_format", + srcs = ["CelBadFormatException.java"], + # used_by_android + tags = [ + ], + deps = [ + ":runtime_exception", + "//common:error_codes", + "//common/annotations", + ], +) + +java_library( + name = "numeric_overflow", + srcs = ["CelNumericOverflowException.java"], + # used_by_android + tags = [ + ], + deps = [ + ":runtime_exception", + "//common:error_codes", + "//common/annotations", + ], +) + +java_library( + name = "invalid_argument", + srcs = ["CelInvalidArgumentException.java"], + # used_by_android + tags = [ + ], + deps = [ + ":runtime_exception", + "//common:error_codes", + "//common/annotations", + ], +) + +java_library( + name = "iteration_budget_exceeded", + srcs = ["CelIterationLimitExceededException.java"], + # used_by_android + tags = [ + ], + deps = [ + ":runtime_exception", + "//common:error_codes", + "//common/annotations", + ], +) + +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"], + # used_by_android + tags = [ + ], + deps = [ + ":runtime_exception", + "//common:error_codes", + "//common/annotations", + ], +) diff --git a/common/src/main/java/dev/cel/common/exceptions/CelAttributeNotFoundException.java b/common/src/main/java/dev/cel/common/exceptions/CelAttributeNotFoundException.java new file mode 100644 index 000000000..d805c9cf4 --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/CelAttributeNotFoundException.java @@ -0,0 +1,61 @@ +// Copyright 2025 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; +import java.util.Arrays; +import java.util.Collection; + +/** Indicates an attempt to access a map or object using an invalid attribute or key. */ +@Internal +public final class CelAttributeNotFoundException extends CelRuntimeException { + + public static CelAttributeNotFoundException of(String message) { + return new CelAttributeNotFoundException(message); + } + + public static CelAttributeNotFoundException forMissingMapKey(String key) { + return new CelAttributeNotFoundException(String.format("key '%s' is not present in map.", key)); + } + + public static CelAttributeNotFoundException forFieldResolution(String... fields) { + return forFieldResolution(Arrays.asList(fields)); + } + + public static CelAttributeNotFoundException forFieldResolution(Collection fields) { + return new CelAttributeNotFoundException(formatErrorMessage(fields)); + } + + public static CelAttributeNotFoundException forMissingAttributes(Collection attributes) { + return new CelAttributeNotFoundException( + "No such attribute(s): " + String.join(", ", attributes)); + } + + private static String formatErrorMessage(Collection fields) { + String maybePlural = ""; + if (fields.size() > 1) { + maybePlural = "s"; + } + + return String.format( + "Error resolving field%s '%s'. Field selections must be performed on messages or maps.", + maybePlural, String.join(", ", fields)); + } + + private CelAttributeNotFoundException(String message) { + super(message, CelErrorCode.ATTRIBUTE_NOT_FOUND); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/CelBadFormatException.java b/common/src/main/java/dev/cel/common/exceptions/CelBadFormatException.java new file mode 100644 index 000000000..ba4db602a --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/CelBadFormatException.java @@ -0,0 +1,31 @@ +// Copyright 2025 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 that a data conversion failed due to a mismatch in the format specification. */ +@Internal +public final class CelBadFormatException extends CelRuntimeException { + + public CelBadFormatException(Throwable cause) { + super(cause, CelErrorCode.BAD_FORMAT); + } + + public CelBadFormatException(String errorMessage) { + super(errorMessage, CelErrorCode.BAD_FORMAT); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/CelDivideByZeroException.java b/common/src/main/java/dev/cel/common/exceptions/CelDivideByZeroException.java new file mode 100644 index 000000000..c507797c5 --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/CelDivideByZeroException.java @@ -0,0 +1,31 @@ +// Copyright 2025 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 that a division by zero occurred. */ +@Internal +public final class CelDivideByZeroException extends CelRuntimeException { + + public CelDivideByZeroException() { + super("/ by zero", CelErrorCode.DIVIDE_BY_ZERO); + } + + public CelDivideByZeroException(Throwable cause) { + super(cause, CelErrorCode.DIVIDE_BY_ZERO); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/CelDuplicateKeyException.java b/common/src/main/java/dev/cel/common/exceptions/CelDuplicateKeyException.java new file mode 100644 index 000000000..f4c99d516 --- /dev/null +++ b/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); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/CelIndexOutOfBoundsException.java b/common/src/main/java/dev/cel/common/exceptions/CelIndexOutOfBoundsException.java new file mode 100644 index 000000000..72a6cd1c0 --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/CelIndexOutOfBoundsException.java @@ -0,0 +1,27 @@ +// Copyright 2025 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 that a list index access was attempted using an index that is out of bounds. */ +@Internal +public final class CelIndexOutOfBoundsException extends CelRuntimeException { + + public CelIndexOutOfBoundsException(Object index) { + super("Index out of bounds: " + index, CelErrorCode.INDEX_OUT_OF_BOUNDS); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/CelInvalidArgumentException.java b/common/src/main/java/dev/cel/common/exceptions/CelInvalidArgumentException.java new file mode 100644 index 000000000..6a2b4ab72 --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/CelInvalidArgumentException.java @@ -0,0 +1,31 @@ +// Copyright 2025 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 that an invalid argument was supplied to a function. */ +@Internal +public final class CelInvalidArgumentException extends CelRuntimeException { + + public CelInvalidArgumentException(Throwable cause) { + super(cause, CelErrorCode.INVALID_ARGUMENT); + } + + public CelInvalidArgumentException(String message) { + super(message, CelErrorCode.INVALID_ARGUMENT); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/CelIterationLimitExceededException.java b/common/src/main/java/dev/cel/common/exceptions/CelIterationLimitExceededException.java new file mode 100644 index 000000000..cfaa25f35 --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/CelIterationLimitExceededException.java @@ -0,0 +1,30 @@ +// Copyright 2025 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; +import java.util.Locale; + +/** Indicates that the iteration budget for a comprehension has been exceeded. */ +@Internal +public final class CelIterationLimitExceededException extends CelRuntimeException { + + public CelIterationLimitExceededException(int budget) { + super( + String.format(Locale.US, "Iteration budget exceeded: %d", budget), + CelErrorCode.ITERATION_BUDGET_EXCEEDED); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/CelNumericOverflowException.java b/common/src/main/java/dev/cel/common/exceptions/CelNumericOverflowException.java new file mode 100644 index 000000000..78fbe807e --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/CelNumericOverflowException.java @@ -0,0 +1,34 @@ +// Copyright 2025 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 that a numeric overflow occurred due to arithmetic operations or conversions resulting + * in a value outside the representable range. + */ +@Internal +public final class CelNumericOverflowException extends CelRuntimeException { + + public CelNumericOverflowException(String message) { + super(message, CelErrorCode.NUMERIC_OVERFLOW); + } + + public CelNumericOverflowException(Throwable cause) { + super(cause, CelErrorCode.NUMERIC_OVERFLOW); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/CelOverloadNotFoundException.java b/common/src/main/java/dev/cel/common/exceptions/CelOverloadNotFoundException.java new file mode 100644 index 000000000..d7c4a01a8 --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/CelOverloadNotFoundException.java @@ -0,0 +1,43 @@ +// 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; +import java.util.Collection; +import java.util.Collections; + +/** Indicates that a matching overload could not be found during function dispatch. */ +@Internal +public final class CelOverloadNotFoundException extends CelRuntimeException { + + public CelOverloadNotFoundException(String functionName) { + this(functionName, Collections.emptyList()); + } + + public CelOverloadNotFoundException(String functionName, Collection overloadIds) { + super(formatErrorMessage(functionName, overloadIds), CelErrorCode.OVERLOAD_NOT_FOUND); + } + + private static String formatErrorMessage(String functionName, Collection overloadIds) { + StringBuilder sb = new StringBuilder(); + sb.append("No matching overload for function '").append(functionName).append("'."); + if (!overloadIds.isEmpty()) { + sb.append(" Overload candidates: ").append(String.join(", ", overloadIds)); + } + + return sb.toString(); + } +} diff --git a/common/src/main/java/dev/cel/common/exceptions/CelRuntimeException.java b/common/src/main/java/dev/cel/common/exceptions/CelRuntimeException.java new file mode 100644 index 000000000..c87e192bd --- /dev/null +++ b/common/src/main/java/dev/cel/common/exceptions/CelRuntimeException.java @@ -0,0 +1,43 @@ +// Copyright 2023 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; + +/** + * Wrapper for an unchecked runtime exception with a CelErrorCode supplied. + * + *

Note: This is not to be confused with the notion of CEL Runtime. Use {@code + * CelEvaluationException} instead to signify an evaluation error. + */ +@Internal +public abstract class CelRuntimeException extends RuntimeException { + private final CelErrorCode errorCode; + + CelRuntimeException(String errorMessage, CelErrorCode errorCode) { + super(errorMessage); + this.errorCode = errorCode; + } + + public CelRuntimeException(Throwable cause, CelErrorCode errorCode) { + super(cause); + this.errorCode = errorCode; + } + + public CelErrorCode getErrorCode() { + return errorCode; + } +} diff --git a/common/src/main/java/dev/cel/common/formats/BUILD.bazel b/common/src/main/java/dev/cel/common/formats/BUILD.bazel new file mode 100644 index 000000000..e906c8ba2 --- /dev/null +++ b/common/src/main/java/dev/cel/common/formats/BUILD.bazel @@ -0,0 +1,81 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//common/formats:__pkg__"], +) + +java_library( + name = "yaml_helper", + srcs = [ + "YamlHelper.java", + ], + tags = [ + ], + deps = [ + ":parser_context", + "@maven//:com_google_guava_guava", + "@maven//:org_yaml_snakeyaml", + ], +) + +java_library( + name = "value_string", + srcs = [ + "ValueString.java", + ], + tags = [ + ], + deps = [ + "//:auto_value", + ], +) + +java_library( + name = "parser_context", + srcs = [ + "ParserContext.java", + ], + tags = [ + ], + deps = [ + ":value_string", + "//common:compiler_common", + ], +) + +java_library( + name = "yaml_parser_context_impl", + srcs = [ + "YamlParserContextImpl.java", + ], + tags = [ + ], + deps = [ + "//common:compiler_common", + "//common:source", + "//common:source_location", + "//common/annotations", + "//common/formats:parser_context", + "//common/formats:value_string", + "//common/formats:yaml_helper", + "@maven//:com_google_guava_guava", + "@maven//:org_yaml_snakeyaml", + ], +) + +java_library( + name = "file_source", + srcs = ["CelFileSource.java"], + tags = [ + ], + deps = [ + "//:auto_value", + "//common:cel_source_helper", + "//common:source", + "//common:source_location", + "//common/internal", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) diff --git a/common/src/main/java/dev/cel/common/formats/CelFileSource.java b/common/src/main/java/dev/cel/common/formats/CelFileSource.java new file mode 100644 index 000000000..7f946d1b6 --- /dev/null +++ b/common/src/main/java/dev/cel/common/formats/CelFileSource.java @@ -0,0 +1,77 @@ +// Copyright 2025 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.formats; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.CelSourceHelper; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.Source; +import dev.cel.common.internal.CelCodePointArray; +import java.util.Map; +import java.util.Optional; + +/** + * CelFileSource represents the source content of a generic configuration and its related metadata. + * This object is amenable to being serialized into YAML, textproto or other formats as needed. + */ +@AutoValue +public abstract class CelFileSource implements Source { + + @Override + public abstract CelCodePointArray getContent(); + + @Override + public abstract String getDescription(); + + @Override + public abstract ImmutableMap getPositionsMap(); + + @Override + public Optional getSnippet(int line) { + return CelSourceHelper.getSnippet(getContent(), line); + } + + /** + * Get the line and column in the source expression text for the given code point {@code offset}. + */ + public Optional getOffsetLocation(int offset) { + return CelSourceHelper.getOffsetLocation(getContent(), offset); + } + + /** Builder for {@link CelFileSource}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setContent(CelCodePointArray content); + + public abstract Builder setDescription(String description); + + public abstract Builder setPositionsMap(Map value); + + @CheckReturnValue + public abstract CelFileSource build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder(CelCodePointArray celCodePointArray) { + return new AutoValue_CelFileSource.Builder() + .setDescription("") + .setContent(celCodePointArray) + .setPositionsMap(ImmutableMap.of()); + } +} diff --git a/common/src/main/java/dev/cel/common/formats/ParserContext.java b/common/src/main/java/dev/cel/common/formats/ParserContext.java new file mode 100644 index 000000000..17eff473f --- /dev/null +++ b/common/src/main/java/dev/cel/common/formats/ParserContext.java @@ -0,0 +1,73 @@ +// Copyright 2025 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.formats; + +import dev.cel.common.CelIssue; +import java.util.List; +import java.util.Map; + +/** + * ParserContext declares a set of interfaces for managing metadata, such as node IDs, parsing + * errors and source offsets. + */ +public interface ParserContext { + + /** + * NextID returns a monotonically increasing identifier for a source fragment. This ID is + * implicitly created and tracked within the CollectMetadata method. + */ + long nextId(); + + /** + * CollectMetadata records the source position information of a given node, and returns the id + * associated with the source metadata which is returned in the Policy SourceInfo object. + */ + long collectMetadata(T node); + + void reportError(long id, String message); + + List getIssues(); + + Map getIdToOffsetMap(); + + /** + * @deprecated Use {@link #newSourceString} instead. + */ + @Deprecated + default ValueString newValueString(T node) { + return newSourceString(node); + } + + /** + * NewYamlString creates a new ValueString from the YAML node, evaluated according to standard + * YAML parsing rules. + * + *

This respects the whitespace folding semantics defined by the node's scalar style (e.g., + * folded string {@code >} versus literal string {@code |}). Use this method for general string + * fields such as {@code description}, {@code name}, or {@code id}. + */ + ValueString newYamlString(T node); + + /** + * NewRawString creates a new ValueString from the YAML node, preserving formatting for accurate + * source mapping. + * + *

This extracts the verbatim text directly from the source file, preserving raw block + * indentation and unmodified newlines. Use this method when the string represents code or a CEL + * expression where precise character-level offsets must be maintained for accurate diagnostic + * error reporting. + */ + ValueString newSourceString(T node); +} diff --git a/common/src/main/java/dev/cel/common/formats/ValueString.java b/common/src/main/java/dev/cel/common/formats/ValueString.java new file mode 100644 index 000000000..86df60a88 --- /dev/null +++ b/common/src/main/java/dev/cel/common/formats/ValueString.java @@ -0,0 +1,55 @@ +// Copyright 2024 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.formats; + +import com.google.auto.value.AutoValue; + +/** ValueString contains an identifier corresponding to source metadata and a simple string. */ +@AutoValue +public abstract class ValueString { + + /** A unique identifier. This is populated by the parser. */ + public abstract long id(); + + /** String value of the {@code ValueString} */ + public abstract String value(); + + /** Builder for {@link ValueString}. */ + @AutoValue.Builder + public abstract static class Builder { + + /** Set the identifier for the string to associate it back to collected source metadata. */ + public abstract Builder setId(long id); + + /** Set the string value. */ + public abstract Builder setValue(String value); + + /** Build the {@code ValueString}. */ + public abstract ValueString build(); + } + + /** Convert the {@code ValueString} to a {@code Builder}. */ + public abstract Builder toBuilder(); + + /** Builder for {@link ValueString}. */ + public static Builder newBuilder() { + return new AutoValue_ValueString.Builder().setId(0).setValue(""); + } + + /** Creates a new {@link ValueString} instance with the specified ID and string value. */ + public static ValueString of(long id, String value) { + return newBuilder().setId(id).setValue(value).build(); + } +} diff --git a/common/src/main/java/dev/cel/common/formats/YamlHelper.java b/common/src/main/java/dev/cel/common/formats/YamlHelper.java new file mode 100644 index 000000000..c16126f95 --- /dev/null +++ b/common/src/main/java/dev/cel/common/formats/YamlHelper.java @@ -0,0 +1,143 @@ +// Copyright 2024 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.formats; + +import static com.google.common.collect.ImmutableMap.toImmutableMap; +import static java.util.Arrays.stream; +import static java.util.stream.Collectors.joining; + +import com.google.common.base.Joiner; +import com.google.common.collect.ImmutableMap; +import java.io.StringReader; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; +import org.yaml.snakeyaml.LoaderOptions; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.constructor.SafeConstructor; +import org.yaml.snakeyaml.nodes.Node; +import org.yaml.snakeyaml.nodes.ScalarNode; + +/** Helper class for parsing YAML. */ +public final class YamlHelper { + public static final String ERROR = "*error*"; + + /** Enum for YAML node types. */ + public enum YamlNodeType { + MAP("tag:yaml.org,2002:map"), + STRING("tag:yaml.org,2002:str"), + BOOLEAN("tag:yaml.org,2002:bool"), + INTEGER("tag:yaml.org,2002:int"), + DOUBLE("tag:yaml.org,2002:float"), + TEXT("!txt"), + LIST("tag:yaml.org,2002:seq"), + ; + + private static final ImmutableMap TAG_TO_NODE_TYPE = + stream(YamlNodeType.values()) + .collect(toImmutableMap(YamlNodeType::tag, Function.identity())); + + private final String tag; + + public static Optional nodeType(String tag) { + return Optional.ofNullable(TAG_TO_NODE_TYPE.get(tag)); + } + + public String tag() { + return tag; + } + + YamlNodeType(String tag) { + this.tag = tag; + } + } + + /** Assert that a given YAML node matches one of the provided {@code YamlNodeType} values. */ + public static boolean assertYamlType( + ParserContext ctx, long id, Node node, YamlNodeType... expectedNodeTypes) { + if (validateYamlType(node, expectedNodeTypes)) { + return true; + } + String nodeTag = node.getTag().getValue(); + + ctx.reportError( + id, + String.format( + "Got yaml node type %s, wanted type(s) [%s]", + nodeTag, stream(expectedNodeTypes).map(YamlNodeType::tag).collect(joining(" ")))); + return false; + } + + public static Optional parseYamlSource(String policyContent) { + Yaml yaml = new Yaml(new SafeConstructor(new LoaderOptions())); + return Optional.ofNullable(yaml.compose(new StringReader(policyContent))); + } + + public static boolean assertRequiredFields( + ParserContext ctx, long id, List missingRequiredFields) { + if (missingRequiredFields.isEmpty()) { + return true; + } + + ctx.reportError( + id, + String.format( + "Missing required attribute(s): %s", Joiner.on(", ").join(missingRequiredFields))); + return false; + } + + public static boolean validateYamlType(Node node, YamlNodeType... expectedNodeTypes) { + String nodeTag = node.getTag().getValue(); + for (YamlNodeType expectedNodeType : expectedNodeTypes) { + if (expectedNodeType.tag().equals(nodeTag)) { + return true; + } + } + return false; + } + + public static Double newDouble(ParserContext ctx, Node node) { + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.DOUBLE)) { + return 0.0; + } + + return Double.parseDouble(((ScalarNode) node).getValue()); + } + + public static Integer newInteger(ParserContext ctx, Node node) { + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.INTEGER)) { + return 0; + } + + return Integer.parseInt(((ScalarNode) node).getValue()); + } + + public static boolean newBoolean(ParserContext ctx, Node node) { + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.BOOLEAN)) { + return false; + } + + return Boolean.parseBoolean(((ScalarNode) node).getValue()); + } + + public static String newString(ParserContext ctx, Node node) { + return ctx.newYamlString(node).value(); + } + + private YamlHelper() {} +} diff --git a/common/src/main/java/dev/cel/common/formats/YamlParserContextImpl.java b/common/src/main/java/dev/cel/common/formats/YamlParserContextImpl.java new file mode 100644 index 000000000..9f6077562 --- /dev/null +++ b/common/src/main/java/dev/cel/common/formats/YamlParserContextImpl.java @@ -0,0 +1,168 @@ +// Copyright 2024 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.formats; + +import static dev.cel.common.formats.YamlHelper.ERROR; +import static dev.cel.common.formats.YamlHelper.assertYamlType; + +import com.google.common.base.Strings; +import dev.cel.common.CelIssue; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.Source; +import dev.cel.common.annotations.Internal; +import dev.cel.common.formats.YamlHelper.YamlNodeType; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.yaml.snakeyaml.DumperOptions; +import org.yaml.snakeyaml.DumperOptions.ScalarStyle; +import org.yaml.snakeyaml.nodes.Node; +import org.yaml.snakeyaml.nodes.ScalarNode; + +/** + * Class to assist with storing generic configuration parsing context. + * + *

CEL Library Internals. Do not use. + */ +@Internal +public final class YamlParserContextImpl implements ParserContext { + + private final ArrayList issues; + private final HashMap idToLocationMap; + private final HashMap idToOffsetMap; + private final Source policySource; + private long id; + + @Override + public void reportError(long id, String message) { + issues.add(CelIssue.formatError(idToLocationMap.get(id), message)); + } + + @Override + public List getIssues() { + return issues; + } + + @Override + public Map getIdToOffsetMap() { + return idToOffsetMap; + } + + @Override + public ValueString newYamlString(Node node) { + long id = collectMetadata(node); + if (!assertYamlType(this, id, node, YamlNodeType.STRING, YamlNodeType.TEXT)) { + return ValueString.of(id, ERROR); + } + + ScalarNode scalarNode = (ScalarNode) node; + return ValueString.of(id, scalarNode.getValue()); + } + + @Override + public ValueString newSourceString(Node node) { + long id = collectMetadata(node); + if (!assertYamlType(this, id, node, YamlNodeType.STRING, YamlNodeType.TEXT)) { + return ValueString.of(id, ERROR); + } + + ScalarNode scalarNode = (ScalarNode) node; + ScalarStyle style = scalarNode.getScalarStyle(); + if (style.equals(ScalarStyle.FOLDED) || style.equals(ScalarStyle.LITERAL)) { + CelSourceLocation location = idToLocationMap.get(id); + int line = location.getLine(); + int column = location.getColumn(); + + String indent = Strings.padStart("", column, ' '); + String text = policySource.getSnippet(line).orElse(""); + StringBuilder raw = new StringBuilder(); + while (text.startsWith(indent)) { + line++; + raw.append(text); + text = policySource.getSnippet(line).orElse(""); + if (text.isEmpty()) { + break; + } + if (text.startsWith(indent)) { + raw.append("\n"); + } + } + + idToOffsetMap.compute(id, (k, offset) -> offset - column); + + return ValueString.of(id, raw.toString()); + } + + return ValueString.of(id, scalarNode.getValue()); + } + + @Override + public long collectMetadata(Node node) { + long id = nextId(); + int line = node.getStartMark().getLine() + 1; // Yaml lines are 0 indexed + int column = node.getStartMark().getColumn(); + if (node instanceof ScalarNode) { + DumperOptions.ScalarStyle style = ((ScalarNode) node).getScalarStyle(); + switch (style) { + case SINGLE_QUOTED: + case DOUBLE_QUOTED: + column++; + break; + case LITERAL: + case FOLDED: + // For multi-lines, actual string content begins on next line + line++; + // Columns must be computed from the indentation + column = 0; + String snippet = policySource.getSnippet(line).orElse(""); + for (char c : snippet.toCharArray()) { + if (!Character.isWhitespace(c)) { + break; + } + column++; + } + break; + default: + break; + } + } + idToLocationMap.put(id, CelSourceLocation.of(line, column)); + + int offset = 0; + if (line > 1) { + offset = policySource.getContent().lineOffsets().get(line - 2) + column; + } + idToOffsetMap.put(id, offset); + + return id; + } + + @Override + public long nextId() { + return ++id; + } + + public static ParserContext newInstance(Source source) { + return new YamlParserContextImpl(source); + } + + private YamlParserContextImpl(Source source) { + this.issues = new ArrayList<>(); + this.idToLocationMap = new HashMap<>(); + this.idToOffsetMap = new HashMap<>(); + this.policySource = source; + } +} diff --git a/common/src/main/java/dev/cel/common/internal/AdaptingTypes.java b/common/src/main/java/dev/cel/common/internal/AdaptingTypes.java new file mode 100644 index 000000000..48158bd91 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/AdaptingTypes.java @@ -0,0 +1,376 @@ +// Copyright 2022 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.internal; + +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.annotations.Internal; +import java.util.Arrays; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; +import java.util.Map; +import java.util.Set; +import org.jspecify.annotations.Nullable; + +/** + * Collection of types which support bidirectional adaptation between CEL and Java native value + * representations. + * + *

CEL Library Internals. Do Not Use. + */ +@CheckReturnValue +@Internal +public final class AdaptingTypes { + + private AdaptingTypes() {} + + public static List adaptingList(List list, BidiConverter bidiConverter) { + return new AdaptingList<>(list, bidiConverter); + } + + public static Map adaptingMap( + Map map, BidiConverter keyConverter, BidiConverter valueConverter) { + return new AdaptingMap<>(map, keyConverter, valueConverter); + } + + /** Exception thrown on write access to adapted collection. */ + private static RuntimeException readonly() { + throw new UnsupportedOperationException("collection is unmodifiable"); + } + + private static class AdaptingIterator implements Iterator { + + private final Iterator delegate; + private final BidiConverter bidiConverter; + + private AdaptingIterator(Iterator delegate, BidiConverter bidiConverter) { + this.delegate = delegate; + this.bidiConverter = bidiConverter; + } + + @Override + public boolean hasNext() { + return delegate.hasNext(); + } + + @Override + public B next() { + return bidiConverter.forwardConverter().convert(delegate.next()); + } + + @Override + public void remove() { + delegate.remove(); + } + } + + private static class AdaptingCollection implements Collection { + + protected final Collection delegate; + protected final BidiConverter bidiConverter; + + public AdaptingCollection(Collection delegate, BidiConverter bidiConverter) { + this.delegate = delegate; + this.bidiConverter = bidiConverter; + } + + protected Converter converter() { + return bidiConverter.forwardConverter(); + } + + protected Converter backwardConverter() { + return bidiConverter.backwardConverter(); + } + + @Override + public int size() { + return delegate.size(); + } + + @Override + public boolean isEmpty() { + return delegate.isEmpty(); + } + + @SuppressWarnings("unchecked") + @Override + public boolean contains(Object o) { + return delegate.contains(backwardConverter().convert((B) o)); + } + + @Override + public Iterator iterator() { + return new AdaptingIterator<>(delegate.iterator(), bidiConverter); + } + + @Override + public Object[] toArray() { + return delegate.stream().map(baseEl -> converter().convert(baseEl)).toArray(); + } + + @Override + @SuppressWarnings("unchecked") + public T[] toArray(T[] ts) { + if (ts.length < size()) { + return (T[]) toArray(); + } + A[] base = delegate.toArray((A[]) new Object[ts.length]); + Arrays.setAll(ts, i -> (T) converter().convert(base[i])); + return ts; + } + + @Override + public boolean add(B a) { + throw readonly(); + } + + @Override + public boolean remove(Object o) { + throw readonly(); + } + + @Override + public boolean containsAll(Collection collection) { + for (Object o : collection) { + if (!contains(o)) { + return false; + } + } + return true; + } + + @Override + public boolean addAll(Collection collection) { + throw readonly(); + } + + @Override + public boolean removeAll(Collection collection) { + throw readonly(); + } + + @Override + public boolean retainAll(Collection collection) { + throw readonly(); + } + + @Override + public void clear() { + throw readonly(); + } + } + + /** Adapter for lists. */ + private static class AdaptingList extends AdaptingCollection implements List { + + public AdaptingList(List delegate, BidiConverter bidiConverter) { + super(delegate, bidiConverter); + } + + @Override + public boolean addAll(int i, Collection collection) { + throw readonly(); + } + + @Override + public B get(int i) { + return converter().convert(((List) delegate).get(i)); + } + + @Override + public B set(int i, B a) { + throw readonly(); + } + + @Override + public void add(int i, B a) { + throw readonly(); + } + + @Override + public B remove(int i) { + throw readonly(); + } + + @SuppressWarnings("unchecked") + @Override + public int indexOf(Object o) { + List list = (List) delegate; + return list.indexOf(backwardConverter().convert((B) o)); + } + + @SuppressWarnings("unchecked") + @Override + public int lastIndexOf(Object o) { + List list = (List) delegate; + return list.lastIndexOf(backwardConverter().convert((B) o)); + } + + @Override + public ListIterator listIterator() { + // This is very rarely used, and CEL doesn't use it for sure. See + // if someone complains before implementing it. + throw new UnsupportedOperationException("listIterator not supported"); + } + + @Override + public ListIterator listIterator(int i) { + throw new UnsupportedOperationException("listIterator not supported"); + } + + @Override + public List subList(int i, int i1) { + return new AdaptingList<>(((List) delegate).subList(i, i1), bidiConverter); + } + } + + private static class AdaptingSet extends AdaptingCollection implements Set { + private AdaptingSet(Set delegate, BidiConverter bidiConverter) { + super(delegate, bidiConverter); + } + } + + private static class AdaptingEntry implements Map.Entry { + + private final Map.Entry delegate; + private final Converter keyConverter; + private final Converter valueConverter; + + public AdaptingEntry( + Map.Entry delegate, Converter keyConverter, Converter valueConverter) { + this.delegate = delegate; + this.keyConverter = keyConverter; + this.valueConverter = valueConverter; + } + + @Override + public C getKey() { + return keyConverter.convert(delegate.getKey()); + } + + @Override + public D getValue() { + return valueConverter.convert(delegate.getValue()); + } + + @Override + public D setValue(D y) { + throw readonly(); + } + } + + /** Adapter for maps. */ + private static class AdaptingMap implements Map { + + private final Map delegate; + private final BidiConverter keyBidiConverter; + private final BidiConverter valueBidiConverter; + + public AdaptingMap( + Map delegate, + BidiConverter keyBidiConverter, + BidiConverter valueBidiConverter) { + this.delegate = delegate; + this.keyBidiConverter = keyBidiConverter; + this.valueBidiConverter = valueBidiConverter; + } + + protected Converter keyConverter() { + return keyBidiConverter.forwardConverter(); + } + + protected Converter keyBackwardConverter() { + return keyBidiConverter.backwardConverter(); + } + + protected Converter valueConverter() { + return valueBidiConverter.forwardConverter(); + } + + protected Converter valueBackwardConverter() { + return valueBidiConverter.backwardConverter(); + } + + @Override + public int size() { + return delegate.size(); + } + + @Override + public boolean isEmpty() { + return delegate.isEmpty(); + } + + @SuppressWarnings("unchecked") + @Override + public boolean containsKey(Object o) { + return delegate.containsKey(keyBackwardConverter().convert((C) o)); + } + + @SuppressWarnings("unchecked") + @Override + public boolean containsValue(Object o) { + return delegate.containsValue(valueBackwardConverter().convert((D) o)); + } + + @SuppressWarnings("unchecked") + @Override + public @Nullable D get(Object o) { + return valueConverter().convert(delegate.get(keyBackwardConverter().convert((C) o))); + } + + @Override + public @Nullable D put(C a, D b) { + throw readonly(); + } + + @Override + public @Nullable D remove(Object o) { + throw readonly(); + } + + @Override + public void putAll(Map map) { + throw readonly(); + } + + @Override + public void clear() { + throw readonly(); + } + + @Override + public Set keySet() { + return new AdaptingSet<>(delegate.keySet(), keyBidiConverter); + } + + @Override + public Collection values() { + return new AdaptingCollection<>(delegate.values(), valueBidiConverter); + } + + @Override + public Set> entrySet() { + Converter, Map.Entry> entryConverter = + (Map.Entry entry) -> new AdaptingEntry<>(entry, keyConverter(), valueConverter()); + Converter, Map.Entry> entryBackwardConverter = + (Map.Entry entry) -> + new AdaptingEntry<>(entry, keyBackwardConverter(), valueBackwardConverter()); + return new AdaptingSet<>( + delegate.entrySet(), BidiConverter.of(entryConverter, entryBackwardConverter)); + } + } +} diff --git a/common/src/main/java/dev/cel/common/internal/BUILD.bazel b/common/src/main/java/dev/cel/common/internal/BUILD.bazel new file mode 100644 index 000000000..58b15b103 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/BUILD.bazel @@ -0,0 +1,460 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//common/internal:__pkg__", + "//publish:__pkg__", + ], +) + +# keep sorted +INTERNAL_SOURCES = [ + "BasicCodePointArray.java", + "CelCodePointArray.java", + "Constants.java", + "EmptyCodePointArray.java", + "Latin1CodePointArray.java", + "SupplementalCodePointArray.java", +] + +# keep sorted +ENV_VISITOR_SOURCES = [ + "EnvVisitable.java", + "EnvVisitor.java", +] + +# keep sorted +CEL_DESCRIPTOR_POOL_SOURCES = [ + "CelDescriptorPool.java", + "CombinedDescriptorPool.java", + "DefaultDescriptorPool.java", +] + +java_library( + name = "code_point_stream", + srcs = ["CodePointStream.java"], + tags = [ + ], + deps = [ + ":internal", + "//common/annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_antlr_antlr4_runtime", + ], +) + +java_library( + name = "internal", + srcs = INTERNAL_SOURCES, + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "//common/ast", + "//common/values", + "//common/values:cel_byte_string", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "internal_android", + srcs = INTERNAL_SOURCES, + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "//common/ast:ast_android", + "//common/values:cel_byte_string", + "//common/values:values_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "comparison_functions", + srcs = ["ComparisonFunctions.java"], + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "comparison_functions_android", + srcs = ["ComparisonFunctions.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "converter", + srcs = [ + "AdaptingTypes.java", + "BidiConverter.java", + "Converter.java", + ], + # used_by_android + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "errors", + srcs = ["Errors.java"], + tags = [ + ], + deps = [ + "//:auto_value", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +DYNAMIC_PROTO_SOURCES = [ + "DynamicProto.java", + "ProtoAdapter.java", +] + +java_library( + name = "default_instance_message_factory", + srcs = [ + "DefaultInstanceMessageFactory.java", + "DefaultInstanceMessageLiteFactory.java", + ], + tags = [ + ], + deps = [ + ":reflection_util", + "//common/annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "default_instance_message_lite_factory", + srcs = ["DefaultInstanceMessageLiteFactory.java"], + tags = [ + ], + deps = [ + ":reflection_util", + "//common/annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "dynamic_proto", + srcs = DYNAMIC_PROTO_SOURCES, + tags = [ + ], + deps = [ + ":converter", + ":proto_lite_adapter", + ":proto_message_factory", + ":well_known_proto", + "//common:options", + "//common/annotations", + "//common/exceptions:numeric_overflow", + "//common/values", + "//common/values:cel_byte_string", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "proto_lite_adapter", + srcs = ["ProtoLiteAdapter.java"], + tags = [ + ], + deps = [ + ":well_known_proto", + "//common:options", + "//common:proto_json_adapter", + "//common/annotations", + "//common/exceptions:numeric_overflow", + "//common/internal:proto_time_utils", + "//common/values", + "//common/values:cel_byte_string", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "proto_equality", + srcs = ["ProtoEquality.java"], + tags = [ + ], + deps = [ + ":dynamic_proto", + "//:auto_value", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "file_descriptor_converter", + srcs = [ + "FileDescriptorSetConverter.java", + ], + tags = [ + ], + deps = [ + ":cel_descriptor_pools", + "//:auto_value", + "//common/internal:well_known_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "env_visitor", + srcs = ENV_VISITOR_SOURCES, + tags = [ + ], + deps = [ + "//common/annotations", + "//parser:macro", + "@cel_spec//proto/cel/expr:checked_java_proto", + ], +) + +java_library( + name = "well_known_proto", + srcs = ["WellKnownProto.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "well_known_proto_android", + srcs = ["WellKnownProto.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "default_message_factory", + srcs = ["DefaultMessageFactory.java"], + tags = [ + ], + deps = [ + ":cel_descriptor_pools", + ":default_instance_message_factory", + ":proto_message_factory", + "//common/annotations", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "proto_message_factory", + srcs = ["ProtoMessageFactory.java"], + tags = [ + ], + deps = [ + ":cel_descriptor_pools", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "cel_descriptor_pools", + srcs = CEL_DESCRIPTOR_POOL_SOURCES, + tags = [ + ], + deps = [ + ":well_known_proto", + "//common:cel_descriptors", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "cel_lite_descriptor_pool", + srcs = ["CelLiteDescriptorPool.java"], + tags = [ + ], + deps = [ + "//protobuf:cel_lite_descriptor", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +cel_android_library( + name = "cel_lite_descriptor_pool_android", + srcs = ["CelLiteDescriptorPool.java"], + tags = [ + ], + deps = [ + "//protobuf:cel_lite_descriptor", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "default_lite_descriptor_pool", + srcs = ["DefaultLiteDescriptorPool.java"], + tags = [ + ], + deps = [ + ":cel_lite_descriptor_pool", + ":well_known_proto", + "//common/annotations", + "//protobuf:cel_lite_descriptor", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +cel_android_library( + name = "default_lite_descriptor_pool_android", + srcs = ["DefaultLiteDescriptorPool.java"], + tags = [ + ], + deps = [ + ":cel_lite_descriptor_pool_android", + ":well_known_proto_android", + "//common/annotations", + "//protobuf:cel_lite_descriptor", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "safe_string_formatter", + srcs = ["SafeStringFormatter.java"], + # used_by_android + tags = [ + ], + deps = [ + "//common/annotations", + "@maven//:com_google_re2j_re2j", + ], +) + +java_library( + name = "reflection_util", + srcs = ["ReflectionUtil.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "proto_time_utils", + srcs = ["ProtoTimeUtils.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "proto_time_utils_android", + srcs = ["ProtoTimeUtils.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "date_time_helpers", + srcs = ["DateTimeHelpers.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/exceptions:bad_format", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "date_time_helpers_android", + srcs = ["DateTimeHelpers.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/exceptions:bad_format", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) diff --git a/common/src/main/java/dev/cel/common/internal/BasicCodePointArray.java b/common/src/main/java/dev/cel/common/internal/BasicCodePointArray.java new file mode 100644 index 000000000..a54fb65d7 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/BasicCodePointArray.java @@ -0,0 +1,70 @@ +// Copyright 2022 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.internal; + +import static com.google.common.base.Preconditions.checkElementIndex; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkPositionIndexes; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; + +/** + * An array of code points that contain code points from both the Latin-1 character set and Basic + * Multilingual Plane. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +@AutoValue +@AutoValue.CopyAnnotations +@SuppressWarnings("Immutable") // char[] is not exposed externally, thus cannot be mutated. +public abstract class BasicCodePointArray extends CelCodePointArray { + + @SuppressWarnings("mutable") + abstract char[] codePoints(); + + abstract int offset(); + + static BasicCodePointArray create( + char[] codePoints, int size, ImmutableList lineOffsets) { + return create(codePoints, 0, lineOffsets, size); + } + + static BasicCodePointArray create( + char[] codePoints, int offset, ImmutableList lineOffsets, int size) { + return new AutoValue_BasicCodePointArray(size, checkNotNull(lineOffsets), codePoints, offset); + } + + @Override + public BasicCodePointArray slice(int i, int j) { + checkPositionIndexes(i, j, size()); + return create(codePoints(), offset() + i, lineOffsets(), j - i); + } + + @Override + public int get(int index) { + checkElementIndex(index, size()); + return codePoints()[offset() + index] & 0xffff; + } + + @Override + public final String toString() { + return new String(codePoints(), offset(), size()); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/BidiConverter.java b/common/src/main/java/dev/cel/common/internal/BidiConverter.java new file mode 100644 index 000000000..45f63b965 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/BidiConverter.java @@ -0,0 +1,65 @@ +// Copyright 2022 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.internal; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.annotations.Internal; + +/** + * The {@code BidiConverter} is a bidirectional converter which contains {@code Converter} objects + * to forward convert from proto to CEL and backward convert from CEL to proto. + * + *

Use the {@code BidiConverter} when dealing with reading and constructing proto messages during + * expression interpretation as CEL numeric primitives are wider than many of the proto primitives. + * + *

CEL Library Internals. Do Not Use. + * + * @param The proto value type. + * @param The CEL value type. + */ +@AutoValue +@CheckReturnValue +@Internal +public abstract class BidiConverter { + + /** A {@code BidiConverter} used for objects which do not need conversion. */ + public static final BidiConverter IDENTITY = + BidiConverter.of(value -> value, value -> value); + + /** Return the {@code Converter} which adapts from proto values to CEL values. */ + public abstract Converter forwardConverter(); + + /** Return the {@code Converter} which adapts from CEL values to proto values. */ + public abstract Converter backwardConverter(); + + /** Return a {@code BidiConverter} with the converter references reversed. */ + public BidiConverter reverse() { + return of(backwardConverter(), forwardConverter()); + } + + /** + * Create a new {@code BidiConverter} from the {@code forwardConverter} and {@code + * backwardConverter} {@link Converter} objects. + */ + public static BidiConverter of( + Converter forwardConverter, Converter backwardConverter) { + return new AutoValue_BidiConverter<>(forwardConverter, backwardConverter); + } + + public static BidiConverter identity() { + return new AutoValue_BidiConverter<>(value -> value, value -> value); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/CelCodePointArray.java b/common/src/main/java/dev/cel/common/internal/CelCodePointArray.java new file mode 100644 index 000000000..1f3124c93 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/CelCodePointArray.java @@ -0,0 +1,152 @@ +// Copyright 2022 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.internal; + +import static com.google.common.base.Strings.isNullOrEmpty; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import java.util.PrimitiveIterator; + +/** + * Represents an in-memory read-only contiguous source of Unicode code points. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public abstract class CelCodePointArray { + + // Package-private default constructor to prevent extensions outside of the codebase. + CelCodePointArray() {} + + /** Returns a new {@link CelCodePointArray} that is a subview of this between [i, j). */ + public abstract CelCodePointArray slice(int i, int j); + + /** Get the code point at the given index. */ + public abstract int get(int index); + + /** Returns the number of code points. */ + public abstract int size(); + + /** Returns the line offsets. */ + public abstract ImmutableList lineOffsets(); + + public final int length() { + return size(); + } + + /** Returns true if empty, false otherwise. */ + public boolean isEmpty() { + return length() == 0; + } + + @Override + public abstract String toString(); + + public static CelCodePointArray fromString(String text) { + if (isNullOrEmpty(text)) { + return EmptyCodePointArray.INSTANCE; + } + PrimitiveIterator.OfInt codePoints = text.codePoints().iterator(); + byte[] byteArray = new byte[text.length()]; + int byteIndex = 0; + + LineOffsetContext lineOffsetContext = new LineOffsetContext(); + while (codePoints.hasNext()) { + int codePoint = codePoints.nextInt(); + lineOffsetContext.process(codePoint); + if (codePoint <= 0xff) { + byteArray[byteIndex++] = (byte) codePoint; + continue; + } + if (codePoint <= 0xffff) { + char[] charArray = new char[text.length()]; + int charIndex = 0; + for (; charIndex < byteIndex; charIndex++) { + charArray[charIndex] = (char) (byteArray[charIndex] & 0xff); + } + byteArray = null; + charArray[charIndex++] = (char) codePoint; + while (codePoints.hasNext()) { + codePoint = codePoints.nextInt(); + lineOffsetContext.process(codePoint); + if (codePoint <= 0xffff) { + charArray[charIndex++] = (char) codePoint; + continue; + } + int[] intArray = new int[text.length()]; + int intIndex = 0; + for (; intIndex < charIndex; intIndex++) { + intArray[intIndex] = charArray[intIndex] & 0xffff; + } + charArray = null; + intArray[intIndex++] = codePoint; + while (codePoints.hasNext()) { + codePoint = codePoints.nextInt(); + lineOffsetContext.process(codePoint); + intArray[intIndex++] = codePoint; + } + + return SupplementalCodePointArray.create( + intArray, intIndex, lineOffsetContext.buildLineOffsets()); + } + + return BasicCodePointArray.create( + charArray, charIndex, lineOffsetContext.buildLineOffsets()); + } + int[] intArray = new int[text.length()]; + int intIndex = 0; + for (; intIndex < byteIndex; intIndex++) { + intArray[intIndex] = byteArray[intIndex] & 0xff; + } + byteArray = null; + intArray[intIndex++] = codePoint; + while (codePoints.hasNext()) { + codePoint = codePoints.nextInt(); + lineOffsetContext.process(codePoint); + intArray[intIndex++] = codePoint; + } + + return SupplementalCodePointArray.create( + intArray, intIndex, lineOffsetContext.buildLineOffsets()); + } + + return Latin1CodePointArray.create(byteArray, byteIndex, lineOffsetContext.buildLineOffsets()); + } + + private static class LineOffsetContext { + private static final int NEWLINE_CODE_POINT = 10; + + private final ImmutableList.Builder lineOffsetBuilder; + private int lineOffsetCodePoints; + + private void process(int codePoint) { + lineOffsetCodePoints++; + if (codePoint == NEWLINE_CODE_POINT) { + lineOffsetBuilder.add(lineOffsetCodePoints); + } + } + + private ImmutableList buildLineOffsets() { + return lineOffsetBuilder.add(lineOffsetCodePoints + 1).build(); + } + + private LineOffsetContext() { + this.lineOffsetBuilder = ImmutableList.builder(); + } + } +} diff --git a/common/src/main/java/dev/cel/common/internal/CelDescriptorPool.java b/common/src/main/java/dev/cel/common/internal/CelDescriptorPool.java new file mode 100644 index 000000000..0cd610d18 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/CelDescriptorPool.java @@ -0,0 +1,49 @@ +// Copyright 2023 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.internal; + +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.ExtensionRegistry; +import dev.cel.common.annotations.Internal; +import java.util.Optional; + +/** + * {@link CelDescriptorPool} allows lookup of descriptors for message types and field descriptors + * for Proto2 extension messages. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public interface CelDescriptorPool { + + /** Finds the descriptor by fully qualified message type. */ + Optional findDescriptor(String name); + + /** + * Finds the corresponding field descriptor for an extension field on a message. The field name + * must be fully-qualified. + */ + Optional findExtensionDescriptor( + Descriptor containingDescriptor, String fieldName); + + /** + * Retrieves the registered extension registry. This is specifically needed to handle unpacking + * Any messages containing Proto2 extension messages. + */ + ExtensionRegistry getExtensionRegistry(); +} diff --git a/common/src/main/java/dev/cel/common/internal/CelLiteDescriptorPool.java b/common/src/main/java/dev/cel/common/internal/CelLiteDescriptorPool.java new file mode 100644 index 000000000..73fce4fbb --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/CelLiteDescriptorPool.java @@ -0,0 +1,32 @@ +// Copyright 2025 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.internal; + +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.MessageLite; +import dev.cel.protobuf.CelLiteDescriptor.MessageLiteDescriptor; +import java.util.Optional; + +/** + * CelLiteDescriptorPool allows lookup of {@link MessageLiteDescriptor} by its fully qualified name. + */ +@Immutable +public interface CelLiteDescriptorPool { + Optional findDescriptor(String protoTypeName); + + Optional findDescriptor(MessageLite messageLite); + + MessageLiteDescriptor getDescriptorOrThrow(String protoTypeName); +} diff --git a/common/src/main/java/dev/cel/common/internal/CodePointStream.java b/common/src/main/java/dev/cel/common/internal/CodePointStream.java new file mode 100644 index 000000000..50b231ef9 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/CodePointStream.java @@ -0,0 +1,117 @@ +// Copyright 2022 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.internal; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; +import static java.lang.Math.min; + +import dev.cel.common.annotations.Internal; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.IntStream; +import org.antlr.v4.runtime.misc.Interval; + +/** + * Implementation of ANTLRv4 CharStream using CelCodePointArray. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class CodePointStream implements CharStream { + + private final String sourceName; + private final CelCodePointArray codePoints; + private int position; + + public CodePointStream(String sourceName, CelCodePointArray codePoints) { + this.sourceName = checkNotNull(sourceName); + this.codePoints = checkNotNull(codePoints); + position = 0; + } + + @Override + public void consume() { + if (position >= size()) { + checkState(LA(1) == IntStream.EOF); + throw new IllegalStateException("Cannot consume EOF"); + } + position++; + } + + @Override + public int LA(int i) { + int index; + switch (Integer.signum(i)) { + case -1: + index = position + i; + if (index < 0) { + return IntStream.EOF; + } + return codePoints.get(index); + case 0: + return 0; + case 1: + index = position + i - 1; + if (index >= codePoints.size()) { + return IntStream.EOF; + } + return codePoints.get(index); + default: + throw new AssertionError(); + } + } + + @Override + public int mark() { + return -1; + } + + @Override + public void release(int marker) {} + + @Override + public int index() { + return position; + } + + @Override + public void seek(int index) { + checkArgument(index >= 0 && index <= size()); + position = index; + } + + @Override + public int size() { + return codePoints.size(); + } + + @Override + public String getSourceName() { + return sourceName; + } + + @Override + public String getText(Interval interval) { + int index = min(interval.a, size()); + int size = min(interval.b - interval.a + 1, size() - index); + return codePoints.slice(index, index + size).toString(); + } + + @Override + public String toString() { + return codePoints.toString(); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/CombinedDescriptorPool.java b/common/src/main/java/dev/cel/common/internal/CombinedDescriptorPool.java new file mode 100644 index 000000000..6227b9e7b --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/CombinedDescriptorPool.java @@ -0,0 +1,86 @@ +// Copyright 2023 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.internal; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.ExtensionRegistry; +import dev.cel.common.annotations.Internal; +import java.util.Optional; + +/** + * The {@link CombinedDescriptorPool} takes one or more {@link CelDescriptorPool} instances and + * supports descriptor lookups in the order the descriptor pools are added to the constructor. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public final class CombinedDescriptorPool implements CelDescriptorPool { + private final ImmutableList descriptorPools; + + @SuppressWarnings("Immutable") // ExtensionRegistry is immutable, just not marked as such. + private final ExtensionRegistry extensionRegistry; + + public static CombinedDescriptorPool create(ImmutableList descriptorPools) { + return new CombinedDescriptorPool(descriptorPools); + } + + @Override + public Optional findDescriptor(String name) { + for (CelDescriptorPool descriptorPool : descriptorPools) { + Optional maybeDescriptor = descriptorPool.findDescriptor(name); + if (maybeDescriptor.isPresent()) { + return maybeDescriptor; + } + } + + return Optional.empty(); + } + + @Override + public Optional findExtensionDescriptor( + Descriptor containingDescriptor, String fieldName) { + for (CelDescriptorPool descriptorPool : descriptorPools) { + Optional maybeExtensionDescriptor = + descriptorPool.findExtensionDescriptor(containingDescriptor, fieldName); + if (maybeExtensionDescriptor.isPresent()) { + return maybeExtensionDescriptor; + } + } + + return Optional.empty(); + } + + @Override + public ExtensionRegistry getExtensionRegistry() { + return extensionRegistry; + } + + private CombinedDescriptorPool(ImmutableList descriptorPools) { + this.descriptorPools = descriptorPools; + // TODO: Combine the extension registry. This will become necessary once we accept + // ExtensionRegistry through runtime builder. Ideally, proto team should open source this + // implementation but we may have to create our own. + this.extensionRegistry = + descriptorPools.stream() + .map(CelDescriptorPool::getExtensionRegistry) + .filter(e -> !e.equals(ExtensionRegistry.getEmptyRegistry())) + .findFirst() + .orElse(ExtensionRegistry.getEmptyRegistry()); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/ComparisonFunctions.java b/common/src/main/java/dev/cel/common/internal/ComparisonFunctions.java new file mode 100644 index 000000000..4d498d526 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/ComparisonFunctions.java @@ -0,0 +1,159 @@ +// Copyright 2022 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.internal; + +import com.google.common.primitives.UnsignedLong; +import com.google.common.primitives.UnsignedLongs; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.annotations.Internal; + +/** + * The {@code ComparisonFunctions} methods provide safe cross-type comparisons between {@code long}, + * {@code double}, and {@link UnsignedLong} values. + * + *

CEL Library Internals. Do Not Use. + */ +@CheckReturnValue +@Internal +public final class ComparisonFunctions { + + private static final UnsignedLong UINT_TO_INT_MAX = UnsignedLong.valueOf(Long.MAX_VALUE); + private static final double DOUBLE_TO_INT_MAX = (double) Long.MAX_VALUE; + private static final double DOUBLE_TO_INT_MIN = (double) Long.MIN_VALUE; + private static final double DOUBLE_TO_UINT_MAX = UnsignedLong.MAX_VALUE.doubleValue(); + + public static int compareDoubleInt(double d, long l) { + if (d < DOUBLE_TO_INT_MIN) { + return -1; + } + if (d > DOUBLE_TO_INT_MAX) { + return 1; + } + return Double.compare(d, (double) l); + } + + public static int compareIntDouble(long l, double d) { + return -compareDoubleInt(d, l); + } + + public static int compareDoubleUint(double d, UnsignedLong ul) { + if (d < 0.0) { + return -1; + } + if (d > DOUBLE_TO_UINT_MAX) { + return 1; + } + return Double.compare(d, ul.doubleValue()); + } + + public static int compareUintDouble(UnsignedLong ul, double d) { + return -compareDoubleUint(d, ul); + } + + public static int compareIntUint(long l, UnsignedLong ul) { + if (l < 0 || ul.compareTo(UINT_TO_INT_MAX) >= 0) { + return -1; + } + return Long.compare(l, ul.longValue()); + } + + public static int compareUintInt(UnsignedLong ul, long l) { + return -compareIntUint(l, ul); + } + + /** + * Compare two numeric values of any type (double, int, uint) for equality. + * + *

Floating point values are follow IEEE 754 standard for NaN comparisons. + */ + public static boolean numericEquals(Number x, Number y) { + if (x instanceof Double) { + if (y instanceof Double) { + return !(Double.isNaN((Double) x) || Double.isNaN((Double) y)) + && x.doubleValue() == y.doubleValue(); + } + if (y instanceof Long) { + return compareDoubleInt((Double) x, (Long) y) == 0; + } + if (y instanceof UnsignedLong) { + return compareDoubleUint((Double) x, (UnsignedLong) y) == 0; + } + } + if (x instanceof Long) { + if (y instanceof Long) { + return x.equals(y); + } + if (y instanceof Double) { + return compareIntDouble((Long) x, (Double) y) == 0; + } + if (y instanceof UnsignedLong) { + return compareIntUint((Long) x, (UnsignedLong) y) == 0; + } + } + if (x instanceof UnsignedLong) { + if (y instanceof UnsignedLong) { + return x.equals(y); + } + if (y instanceof Double) { + return compareUintDouble((UnsignedLong) x, (Double) y) == 0; + } + if (y instanceof Long) { + return compareUintInt((UnsignedLong) x, (Long) y) == 0; + } + } + return false; + } + + /** Compare two numeric values of any type (double, int, uint). */ + public static int numericCompare(Number x, Number y) { + if (x instanceof Double) { + if (y instanceof Double) { + return ((Double) x).compareTo((Double) y); + } + if (y instanceof Long) { + return compareDoubleInt((Double) x, (Long) y); + } + if (y instanceof UnsignedLong) { + return compareDoubleUint((Double) x, (UnsignedLong) y); + } + } + if (x instanceof Long) { + if (y instanceof Long) { + return Long.compare((Long) x, (Long) y); + } + if (y instanceof Double) { + return compareIntDouble((Long) x, (Double) y); + } + if (y instanceof UnsignedLong) { + return compareIntUint((Long) x, (UnsignedLong) y); + } + } + if (x instanceof UnsignedLong) { + if (y instanceof UnsignedLong) { + return UnsignedLongs.compare(x.longValue(), y.longValue()); + } + if (y instanceof Double) { + return compareUintDouble((UnsignedLong) x, (Double) y); + } + if (y instanceof Long) { + return compareUintInt((UnsignedLong) x, (Long) y); + } + } + throw new UnsupportedOperationException( + "Unsupported argument types: " + x.getClass() + ", " + y.getClass()); + } + + private ComparisonFunctions() {} +} diff --git a/common/src/main/java/dev/cel/common/internal/Constants.java b/common/src/main/java/dev/cel/common/internal/Constants.java new file mode 100644 index 000000000..49bca7489 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/Constants.java @@ -0,0 +1,547 @@ +// Copyright 2022 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.internal; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkState; + +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import dev.cel.common.annotations.Internal; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; +import java.text.ParseException; +import java.util.PrimitiveIterator; + +/** + * Internal utility class for working with {@link dev.cel.expr.Constant}. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class Constants { + + private static final String DOUBLE_QUOTE = "\""; + private static final String SINGLE_QUOTE = "'"; + private static final String TRIPLE_DOUBLE_QUOTE = "\"\"\""; + private static final String TRIPLE_SINGLE_QUOTE = "'''"; + private static final int MAX_SCRATCH_CODE_POINTS = 8; + private static final int MIN_CODE_POINT = 0; + private static final int MAX_CODE_POINT = 0x10ffff; + private static final int MIN_SURROGATE = 0xd800; + private static final int MAX_SURROGATE = 0xdfff; + + public static final CelConstant NULL = CelConstant.ofValue(NullValue.NULL_VALUE); + public static final CelConstant FALSE = CelConstant.ofValue(false); + public static final CelConstant TRUE = CelConstant.ofValue(true); + public static final CelConstant ERROR = CelConstant.ofValue("<>"); + + public static CelConstant parseInt(String text) throws ParseException { + int base; + if (text.startsWith("-0x")) { + base = 16; + // Strip off the sign and prefix. + text = text.substring(3); + // Add the sign back. + text = "-" + text; + } else if (text.startsWith("0x")) { + base = 16; + text = text.substring(2); + if (text.startsWith("-")) { + // While the lexer/parser should never present such a literal, this is here for safety as + // Long.parseLong would accept it. + throw new ParseException("Integer literal is malformed", 0); + } + } else { + base = 10; + } + long value; + try { + value = Long.parseLong(text, base); + } catch (NumberFormatException e) { + throw new ParseException(e.getMessage(), 0); + } + return CelConstant.ofValue(value); + } + + public static CelConstant parseUint(String text) throws ParseException { + int base; + if (!text.endsWith("u") && !text.endsWith("U")) { + throw new ParseException("Unsigned integer literal is missing trailing 'u' suffix", 0); + } + text = text.substring(0, text.length() - 1); + if (text.startsWith("0x")) { + base = 16; + text = text.substring(2); + } else { + base = 10; + } + long value; + try { + value = Long.parseUnsignedLong(text, base); + } catch (NumberFormatException e) { + throw new ParseException(e.getMessage(), 0); + } + return CelConstant.ofValue(UnsignedLong.fromLongBits(value)); + } + + public static CelConstant parseDouble(String text) throws ParseException { + double value; + try { + value = Double.parseDouble(text); + } catch (NumberFormatException e) { + throw new ParseException(e.getMessage(), 0); + } + return CelConstant.ofValue(value); + } + + public static CelConstant parseBytes(String text) throws ParseException { + boolean isRawLiteral = false; + int offset = 0; + if (text.startsWith("r") || text.startsWith("R")) { + isRawLiteral = true; + text = text.substring(1); + offset++; + if (!text.startsWith("b") && !text.startsWith("B")) { + throw new ParseException("Bytes literal is missing leading 'b' or 'B' prefix", 0); + } + text = text.substring(1); + offset++; + } else { + if (!text.startsWith("b") && !text.startsWith("B")) { + throw new ParseException("Bytes literal is missing leading 'b' or 'B' prefix", 0); + } + text = text.substring(1); + offset++; + if (text.startsWith("r") || text.startsWith("R")) { + isRawLiteral = true; + text = text.substring(1); + offset++; + } + } + String quote; + if (text.startsWith(TRIPLE_DOUBLE_QUOTE)) { + quote = TRIPLE_DOUBLE_QUOTE; + text = text.substring(quote.length()); + } else if (text.startsWith(TRIPLE_SINGLE_QUOTE)) { + quote = TRIPLE_SINGLE_QUOTE; + text = text.substring(quote.length()); + } else if (text.startsWith(DOUBLE_QUOTE)) { + quote = DOUBLE_QUOTE; + text = text.substring(quote.length()); + } else if (text.startsWith(SINGLE_QUOTE)) { + quote = SINGLE_QUOTE; + text = text.substring(quote.length()); + } else { + throw new ParseException("Bytes literal is missing surrounding single or double quotes", 0); + } + checkForClosingQuote(text, quote); + offset += quote.length(); + checkState(text.endsWith(quote)); + text = text.substring(0, text.length() - quote.length()); + DecodeBuffer buffer = new DecodeByteStringBuffer(text.length()); + decodeString(offset, text, buffer, isRawLiteral, true); + return CelConstant.ofValue(CelByteString.of(buffer.toDecodedValue().toByteArray())); + } + + public static CelConstant parseString(String text) throws ParseException { + int offset = 0; + boolean isRawLiteral = false; + if (text.startsWith("r") || text.startsWith("R")) { + isRawLiteral = true; + text = text.substring(1); + offset++; + } + String quote; + if (text.startsWith(TRIPLE_DOUBLE_QUOTE)) { + quote = TRIPLE_DOUBLE_QUOTE; + text = text.substring(quote.length()); + } else if (text.startsWith(TRIPLE_SINGLE_QUOTE)) { + quote = TRIPLE_SINGLE_QUOTE; + text = text.substring(quote.length()); + } else if (text.startsWith(DOUBLE_QUOTE)) { + quote = DOUBLE_QUOTE; + text = text.substring(quote.length()); + } else if (text.startsWith(SINGLE_QUOTE)) { + quote = SINGLE_QUOTE; + text = text.substring(quote.length()); + } else { + throw new ParseException("String literal is missing surrounding single or double quotes", 0); + } + checkForClosingQuote(text, quote); + offset += quote.length(); + checkState(text.endsWith(quote)); + text = text.substring(0, text.length() - quote.length()); + DecodeBuffer buffer = new DecodeStringBuffer(text.length()); + decodeString(offset, text, buffer, isRawLiteral, false); + return CelConstant.ofValue(buffer.toDecodedValue()); + } + + private static void decodeString( + int offset, String text, DecodeBuffer buffer, boolean isRawLiteral, boolean isBytesLiteral) + throws ParseException { + boolean skipNewline = false; + PrimitiveIterator.OfInt iterator = text.codePoints().iterator(); + int[] scratchCodePoints = null; + while (iterator.hasNext()) { + int seqOffset = offset; // Save offset for the start of this sequence. + int codePoint = iterator.nextInt(); + offset++; + if (codePoint != '\\') { + if (codePoint != '\r') { + if (codePoint == '\n' && skipNewline) { + skipNewline = false; + continue; + } + skipNewline = false; + if (codePoint >= MIN_SURROGATE && codePoint <= MAX_SURROGATE) { + throw new ParseException("Invalid unicode code point", seqOffset); + } + buffer.appendCodePoint(codePoint); + } else { + // Normalize '\r' and '\r\n' to '\n'. + buffer.appendCodePoint('\n'); + skipNewline = true; + } + } else { + // An escape sequence. + skipNewline = false; + if (!iterator.hasNext()) { + throw new ParseException( + isRawLiteral + ? "Raw literals cannot end with an odd number of \\" + : isBytesLiteral + ? "Bytes literal cannot end with \\" + : "String literal cannot end with \\", + seqOffset); + } + codePoint = iterator.nextInt(); + offset++; + if (isRawLiteral) { + // For raw literals, all escapes are valid and those characters come through literally in + // the string. + buffer.appendCodePoint('\\'); + if (codePoint >= MIN_SURROGATE && codePoint <= MAX_SURROGATE) { + throw new ParseException("Invalid unicode code point", seqOffset); + } + buffer.appendCodePoint(codePoint); + continue; + } + switch (codePoint) { + case 'a': + buffer.appendByte((byte) 7); + break; + case 'b': + buffer.appendByte((byte) '\b'); + break; + case 'f': + buffer.appendByte((byte) '\f'); + break; + case 'n': + buffer.appendByte((byte) '\n'); + break; + case 'r': + buffer.appendByte((byte) '\r'); + break; + case 't': + buffer.appendByte((byte) '\t'); + break; + case 'v': + buffer.appendByte((byte) 11); + break; + case '"': + buffer.appendByte((byte) '"'); + break; + case '\'': + buffer.appendByte((byte) '\''); + break; + case '\\': + buffer.appendByte((byte) '\\'); + break; + case '?': + buffer.appendByte((byte) '?'); + break; + case '`': + buffer.appendByte((byte) '`'); + break; + case '0': + case '1': + case '2': + case '3': + { + if (scratchCodePoints == null) { + scratchCodePoints = new int[MAX_SCRATCH_CODE_POINTS]; + } + // There needs to be 2 octal digits. + if (!nextInts(iterator, 2, scratchCodePoints) + || !areOctalDigits(scratchCodePoints, 2)) { + throw new ParseException("Invalid octal escape sequence", seqOffset); + } + int octalValue = codePoint - '0'; + octalValue = (octalValue * 8) + (scratchCodePoints[0] - '0'); + octalValue = (octalValue * 8) + (scratchCodePoints[1] - '0'); + buffer.appendByte((byte) octalValue); + offset += 2; + } + break; + case 'x': + case 'X': + { + if (scratchCodePoints == null) { + scratchCodePoints = new int[MAX_SCRATCH_CODE_POINTS]; + } + // There needs to be 2 hex digits. + if (!nextInts(iterator, 2, scratchCodePoints) + || !areHexDigits(scratchCodePoints, 2)) { + throw new ParseException("Invalid hex escape sequence", seqOffset); + } + int value = unhex(scratchCodePoints, 2); + buffer.appendByte((byte) value); + offset += 2; + } + break; + case 'u': + { + if (isBytesLiteral) { + throw new ParseException( + "Illegal escape sequence: Unicode escape sequences cannot be used in bytes" + + " literal", + seqOffset); + } + if (scratchCodePoints == null) { + scratchCodePoints = new int[MAX_SCRATCH_CODE_POINTS]; + } + // There needs to be 4 hex digits. + if (!nextInts(iterator, 4, scratchCodePoints) + || !areHexDigits(scratchCodePoints, 4)) { + throw new ParseException("Invalid unicode escape sequence", seqOffset); + } + int value = unhex(scratchCodePoints, 4); + if (value < MIN_CODE_POINT + || value > MAX_CODE_POINT + || (value >= MIN_SURROGATE && value <= MAX_SURROGATE)) { + throw new ParseException("Invalid unicode code point", seqOffset); + } + buffer.appendCodePoint(value); + offset += 4; + } + break; + case 'U': + { + if (isBytesLiteral) { + throw new ParseException( + "Illegal escape sequence: Unicode escape sequences cannot be used in bytes" + + " literal", + offset); + } + if (scratchCodePoints == null) { + scratchCodePoints = new int[MAX_SCRATCH_CODE_POINTS]; + } + // There needs to be 8 hex digits. + if (!nextInts(iterator, 8, scratchCodePoints) + || !areHexDigits(scratchCodePoints, 8)) { + throw new ParseException("Invalid unicode escape sequence", seqOffset); + } + int value = unhex(scratchCodePoints, 8); + if (value < MIN_CODE_POINT + || value > MAX_CODE_POINT + || (value >= MIN_SURROGATE && value <= MAX_SURROGATE)) { + throw new ParseException("Invalid unicode code point", seqOffset); + } + buffer.appendCodePoint(value); + offset += 8; + } + break; + default: + throw new ParseException("Illegal escape sequence", seqOffset); + } + } + } + } + + private static boolean nextInts(PrimitiveIterator.OfInt iterator, int count, int[] scratch) { + checkArgument(count <= scratch.length); + int index = 0; + while (iterator.hasNext() && index < count) { + scratch[index++] = iterator.nextInt(); + } + return index == count; + } + + private static boolean isOctalDigit(int codePoint) { + return codePoint >= '0' && codePoint <= '7'; + } + + private static boolean isHexDigit(int codePoint) { + return (codePoint >= 'a' && codePoint <= 'f') + || (codePoint >= 'A' && codePoint <= 'F') + || (codePoint >= '0' && codePoint <= '9'); + } + + private static boolean isDigit(int codePoint) { + return codePoint >= '0' && codePoint <= '9'; + } + + private static int toLowerCase(int codePoint) { + return codePoint >= 'A' && codePoint <= 'Z' ? (codePoint - 'A') + 'a' : codePoint; + } + + private static boolean areOctalDigits(int[] codePoints, int count) { + checkArgument(count <= codePoints.length); + for (int index = 0; index < count; index++) { + if (!isOctalDigit(codePoints[index])) { + return false; + } + } + return true; + } + + private static boolean areHexDigits(int[] codePoints, int count) { + checkArgument(count <= codePoints.length); + for (int index = 0; index < count; index++) { + if (!isHexDigit(codePoints[index])) { + return false; + } + } + return true; + } + + private interface DecodeBuffer { + void appendByte(byte b); + + void appendCodePoint(int codePoint); + + T toDecodedValue(); + } + + private static final class DecodeByteStringBuffer implements DecodeBuffer { + + private final ByteString.Output output; + + private DecodeByteStringBuffer(int initialCapacity) { + output = ByteString.newOutput(initialCapacity); + } + + @Override + public void appendByte(byte b) { + output.write(b); + } + + @Override + public void appendCodePoint(int codePoint) { + checkArgument(codePoint >= MIN_CODE_POINT && codePoint <= MAX_CODE_POINT); + if (codePoint < 0x80) { + output.write((byte) codePoint); + } else if (codePoint < 0x800) { + output.write((byte) ((0xF << 6) | (codePoint >>> 6))); + output.write((byte) (0x80 | (0x3F & codePoint))); + } else if (codePoint < 0x10000) { + output.write((byte) ((0xF << 5) | (codePoint >>> 12))); + output.write((byte) (0x80 | (0x3F & (codePoint >>> 6)))); + output.write((byte) (0x80 | (0x3F & codePoint))); + } else { + output.write((byte) ((0xF << 4) | (codePoint >>> 18))); + output.write((byte) (0x80 | (0x3F & (codePoint >>> 12)))); + output.write((byte) (0x80 | (0x3F & (codePoint >>> 6)))); + output.write((byte) (0x80 | (0x3F & codePoint))); + } + } + + @Override + public ByteString toDecodedValue() { + return output.toByteString(); + } + } + + private static final class DecodeStringBuffer implements DecodeBuffer { + + private final StringBuilder builder; + + private DecodeStringBuffer(int initialCapacity) { + builder = new StringBuilder(initialCapacity); + } + + @Override + public void appendByte(byte b) { + builder.appendCodePoint(b & 0xff); + } + + @Override + public void appendCodePoint(int codePoint) { + checkArgument(codePoint >= MIN_CODE_POINT && codePoint <= MAX_CODE_POINT); + builder.appendCodePoint(codePoint); + } + + @Override + public String toDecodedValue() { + return builder.toString(); + } + } + + private static void checkForClosingQuote(String text, String quote) throws ParseException { + if (quote.isEmpty()) { + return; + } + if (text.length() < quote.length()) { + throw new ParseException( + String.format("String literal missing terminating quote %s", quote), 0); + } + int position = 0; + boolean isClosed = false; + while (position + quote.length() <= text.length()) { + char codeUnit = text.charAt(position); + if (codeUnit != '\\') { + boolean quoteMatches = true; + for (int i = 0; i < quote.length(); i++) { + if (text.charAt(position + i) != quote.charAt(i)) { + quoteMatches = false; + break; + } + } + + if (quoteMatches) { + isClosed = position + quote.length() == text.length(); + break; + } + } else { + position++; + } + position++; + } + if (!isClosed) { + throw new ParseException( + String.format("String literal contains unescaped terminating quote %s", quote), 0); + } + } + + private static int unhex(int value, int nextValue) { + if (isDigit(nextValue)) { + return (value * 16) + (nextValue - '0'); + } else { + return (value * 16) + ((toLowerCase(nextValue) - 'a') + 10); + } + } + + private static int unhex(int[] codePoints, int length) { + int value = 0; + for (int index = 0; index < length; index++) { + value = unhex(value, codePoints[index]); + } + return value; + } + + private Constants() {} +} diff --git a/common/src/main/java/dev/cel/common/internal/Converter.java b/common/src/main/java/dev/cel/common/internal/Converter.java new file mode 100644 index 000000000..2c52d0219 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/Converter.java @@ -0,0 +1,28 @@ +// Copyright 2022 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.internal; + +import dev.cel.common.annotations.Internal; + +/** + * Functional interface for converting between two types. + * + *

CEL Library Internals. Do Not Use. + */ +@FunctionalInterface +@Internal +public interface Converter { + B convert(A value); +} diff --git a/common/src/main/java/dev/cel/common/internal/DateTimeHelpers.java b/common/src/main/java/dev/cel/common/internal/DateTimeHelpers.java new file mode 100644 index 000000000..805a9bd75 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/DateTimeHelpers.java @@ -0,0 +1,260 @@ +// Copyright 2025 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.internal; + +import com.google.common.base.Strings; +import com.google.protobuf.Timestamp; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelBadFormatException; +import java.time.DateTimeException; +import java.time.Duration; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.OffsetDateTime; +import java.time.ZoneId; +import java.util.Locale; + +/** Collection of utility methods for CEL datetime handlings. */ +@Internal +@SuppressWarnings("JavaInstantGetSecondsGetNano") // Intended within CEL. +public final class DateTimeHelpers { + public static final String UTC = "UTC"; + + // Timestamp for "0001-01-01T00:00:00Z" + private static final long TIMESTAMP_SECONDS_MIN = -62135596800L; + // Timestamp for "9999-12-31T23:59:59Z" + private static final long TIMESTAMP_SECONDS_MAX = 253402300799L; + + private static final long DURATION_SECONDS_MIN = -315576000000L; + private static final long DURATION_SECONDS_MAX = 315576000000L; + private static final int NANOS_PER_SECOND = 1000000000; + + /** + * Constructs a new {@link LocalDateTime} instance + * + * @param ts Timestamp protobuf object + * @param tz Timezone based on the CEL specification. This is either the canonical name from tz + * database or a standard offset represented in (+/-)HH:MM. Few valid examples are: + *

+ * + * @return If an Invalid timezone is supplied. + */ + public static LocalDateTime newLocalDateTime(Timestamp ts, String tz) { + return Instant.ofEpochSecond(ts.getSeconds(), ts.getNanos()) + .atZone(timeZone(tz)) + .toLocalDateTime(); + } + + /** + * Constructs a new {@link LocalDateTime} instance from a Java Instant. + * + * @param instant Instant object + * @param tz Timezone based on the CEL specification. This is either the canonical name from tz + * database or a standard offset represented in (+/-)HH:MM. Few valid examples are: + *
    + *
  • UTC + *
  • America/Los_Angeles + *
  • -09:30 or -9:30 (Leading zeroes can be omitted though not allowed by spec) + *
+ * + * @return A new {@link LocalDateTime} instance. + */ + public static LocalDateTime newLocalDateTime(Instant instant, String tz) { + return instant.atZone(timeZone(tz)).toLocalDateTime(); + } + + /** + * Parse from RFC 3339 date string to {@link java.time.Instant}. + * + *

Example of accepted format: "1972-01-01T10:00:20.021-05:00" + */ + public static Instant parse(String text) { + OffsetDateTime offsetDateTime = OffsetDateTime.parse(text); + Instant instant = offsetDateTime.toInstant(); + checkValid(instant); + + return instant; + } + + /** Adds a duration to an instant. */ + public static Instant add(Instant ts, Duration dur) { + Instant newInstant = ts.plus(dur); + checkValid(newInstant); + + return newInstant; + } + + /** Adds two durations */ + public static Duration add(Duration d1, Duration d2) { + Duration newDuration = d1.plus(d2); + checkValid(newDuration); + + return newDuration; + } + + /** Subtracts a duration to an instant. */ + public static Instant subtract(Instant ts, Duration dur) { + Instant newInstant = ts.minus(dur); + checkValid(newInstant); + + return newInstant; + } + + /** Subtract a duration from another. */ + public static Duration subtract(Duration d1, Duration d2) { + Duration newDuration = d1.minus(d2); + checkValid(newDuration); + + return newDuration; + } + + /** + * Formats a {@link Duration} into a minimal seconds-based representation. + * + *

Note: follows {@code ProtoTimeUtils#toString(Duration)} implementation + */ + public static String toString(Duration duration) { + if (duration.isZero()) { + return "0s"; + } + + long totalNanos = duration.toNanos(); + StringBuilder sb = new StringBuilder(); + + if (totalNanos < 0) { + sb.append('-'); + totalNanos = -totalNanos; + } + + long seconds = totalNanos / 1_000_000_000; + int nanos = (int) (totalNanos % 1_000_000_000); + + sb.append(seconds); + + // Follows ProtoTimeUtils.toString(Duration) implementation + if (nanos > 0) { + sb.append('.'); + if (nanos % 1_000_000 == 0) { + // Millisecond precision (3 digits) + int millis = nanos / 1_000_000; + sb.append(String.format(Locale.US, "%03d", millis)); + } else if (nanos % 1_000 == 0) { + // Microsecond precision (6 digits) + int micros = nanos / 1_000; + sb.append(String.format(Locale.US, "%06d", micros)); + } else { + // Nanosecond precision (9 digits) + sb.append(String.format(Locale.US, "%09d", nanos)); + } + } + + sb.append('s'); + return sb.toString(); + } + + /** + * Get the DateTimeZone Instance. + * + * @param tz the ID of the datetime zone + * @return the ZoneId object + */ + private static ZoneId timeZone(String tz) { + try { + return ZoneId.of(tz); + } catch (DateTimeException e) { + // If timezone is not a string name (for example, 'US/Central'), it should be a numerical + // offset from UTC in the format [+/-]HH:MM. + try { + int ind = tz.indexOf(":"); + if (ind == -1) { + throw new CelBadFormatException(e); + } + + int hourOffset = Integer.parseInt(tz.substring(0, ind)); + int minOffset = Integer.parseInt(tz.substring(ind + 1)); + // Ensures that the offset are properly formatted in [+/-]HH:MM to conform with + // ZoneOffset's format requirements. + // Example: "-9:30" -> "-09:30" and "9:30" -> "+09:30" + String formattedOffset = + ((hourOffset < 0) ? "-" : "+") + + String.format(Locale.US, "%02d:%02d", Math.abs(hourOffset), minOffset); + + return ZoneId.of(formattedOffset); + + } catch (DateTimeException e2) { + throw new CelBadFormatException(e2); + } + } + } + + /** Throws an {@link IllegalArgumentException} if the given {@link Timestamp} is not valid. */ + public static void checkValid(Instant instant) { + long seconds = instant.getEpochSecond(); + + if (seconds < TIMESTAMP_SECONDS_MIN || seconds > TIMESTAMP_SECONDS_MAX) { + throw new IllegalArgumentException( + Strings.lenientFormat( + "Timestamp is not valid. " + + "Seconds (%s) must be in range [-62,135,596,800, +253,402,300,799]. " + + "Nanos (%s) must be in range [0, +999,999,999].", + seconds, instant.getNano())); + } + } + + /** Throws an {@link IllegalArgumentException} if the given {@link Duration} is not valid. */ + private static void checkValid(Duration duration) { + long seconds = duration.getSeconds(); + int nanos = duration.getNano(); + if (!isDurationValid(seconds, nanos)) { + throw new IllegalArgumentException( + Strings.lenientFormat( + "Duration is not valid. " + + "Seconds (%s) must be in range [-315,576,000,000, +315,576,000,000]. " + + "Nanos (%s) must be in range [-999,999,999, +999,999,999]. " + + "Nanos must have the same sign as seconds", + seconds, nanos)); + } + } + + /** + * Returns true if the given number of seconds and nanos is a valid {@link Duration}. The {@code + * seconds} value must be in the range [-315,576,000,000, +315,576,000,000]. The {@code nanos} + * value must be in the range [-999,999,999, +999,999,999]. + * + *

Note: Durations less than one second are represented with a 0 {@code seconds} field + * and a positive or negative {@code nanos} field. For durations of one second or more, a non-zero + * value for the {@code nanos} field must be of the same sign as the {@code seconds} field. + */ + private static boolean isDurationValid(long seconds, int nanos) { + if (seconds < DURATION_SECONDS_MIN || seconds > DURATION_SECONDS_MAX) { + return false; + } + if (nanos < -999999999L || nanos >= NANOS_PER_SECOND) { + return false; + } + if (seconds < 0 || nanos < 0) { + if (seconds > 0 || nanos > 0) { + return false; + } + } + return true; + } + + private DateTimeHelpers() {} +} diff --git a/common/src/main/java/dev/cel/common/internal/DefaultDescriptorPool.java b/common/src/main/java/dev/cel/common/internal/DefaultDescriptorPool.java new file mode 100644 index 000000000..a4614a2cb --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/DefaultDescriptorPool.java @@ -0,0 +1,153 @@ +// Copyright 2023 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.internal; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableMap.toImmutableMap; +import static java.util.Arrays.stream; + +import com.google.common.collect.ImmutableCollection; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableMultimap; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.BytesValue; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.Empty; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.FieldMask; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import dev.cel.common.CelDescriptors; +import dev.cel.common.annotations.Internal; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** + * A descriptor pool that has descriptors pre-loaded for well-known types defined by {@link + * WellKnownProto}. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public final class DefaultDescriptorPool implements CelDescriptorPool { + + private static final ImmutableMap WELL_KNOWN_PROTO_TO_DESCRIPTORS = + ImmutableMap.builder() + .put(WellKnownProto.ANY_VALUE, Any.getDescriptor()) + .put(WellKnownProto.BOOL_VALUE, BoolValue.getDescriptor()) + .put(WellKnownProto.BYTES_VALUE, BytesValue.getDescriptor()) + .put(WellKnownProto.DOUBLE_VALUE, DoubleValue.getDescriptor()) + .put(WellKnownProto.DURATION, Duration.getDescriptor()) + .put(WellKnownProto.FLOAT_VALUE, FloatValue.getDescriptor()) + .put(WellKnownProto.INT32_VALUE, Int32Value.getDescriptor()) + .put(WellKnownProto.INT64_VALUE, Int64Value.getDescriptor()) + .put(WellKnownProto.STRING_VALUE, StringValue.getDescriptor()) + .put(WellKnownProto.TIMESTAMP, Timestamp.getDescriptor()) + .put(WellKnownProto.UINT32_VALUE, UInt32Value.getDescriptor()) + .put(WellKnownProto.UINT64_VALUE, UInt64Value.getDescriptor()) + .put(WellKnownProto.JSON_LIST_VALUE, ListValue.getDescriptor()) + .put(WellKnownProto.JSON_STRUCT_VALUE, Struct.getDescriptor()) + .put(WellKnownProto.JSON_VALUE, Value.getDescriptor()) + .put(WellKnownProto.EMPTY, Empty.getDescriptor()) + .put(WellKnownProto.FIELD_MASK, FieldMask.getDescriptor()) + .buildOrThrow(); + + private static final ImmutableMap WELL_KNOWN_TYPE_NAME_TO_DESCRIPTORS = + stream(WellKnownProto.values()) + .collect(toImmutableMap(WellKnownProto::typeName, WELL_KNOWN_PROTO_TO_DESCRIPTORS::get)); + + /** A DefaultDescriptorPool instance with just well known types loaded. */ + public static final DefaultDescriptorPool INSTANCE = + new DefaultDescriptorPool( + WELL_KNOWN_TYPE_NAME_TO_DESCRIPTORS, + ImmutableMultimap.of(), + ExtensionRegistry.getEmptyRegistry()); + + // K: Fully qualified message type name, V: Message descriptor + private final ImmutableMap descriptorMap; + + // K: Fully qualified message type name (of containing descriptor) + // V: Field descriptor for the extension message + private final ImmutableMultimap extensionDescriptorMap; + + @SuppressWarnings("Immutable") // ExtensionRegistry is immutable, just not marked as such. + private final ExtensionRegistry extensionRegistry; + + public static DefaultDescriptorPool create(CelDescriptors celDescriptors) { + return create(celDescriptors, ExtensionRegistry.getEmptyRegistry()); + } + + public static DefaultDescriptorPool create( + CelDescriptors celDescriptors, ExtensionRegistry extensionRegistry) { + Map descriptorMap = + new HashMap<>(WELL_KNOWN_TYPE_NAME_TO_DESCRIPTORS); // Using a hashmap to allow deduping + + for (Descriptor descriptor : celDescriptors.messageTypeDescriptors()) { + descriptorMap.putIfAbsent(descriptor.getFullName(), descriptor); + } + + return new DefaultDescriptorPool( + ImmutableMap.copyOf(descriptorMap), + celDescriptors.extensionDescriptors(), + extensionRegistry); + } + + public static Descriptor getWellKnownProtoDescriptor(WellKnownProto wellKnownProto) { + return WELL_KNOWN_PROTO_TO_DESCRIPTORS.get(wellKnownProto); + } + + @Override + public Optional findDescriptor(String name) { + return Optional.ofNullable(descriptorMap.get(name)); + } + + @Override + public Optional findExtensionDescriptor( + Descriptor containingDescriptor, String fieldName) { + String typeName = containingDescriptor.getFullName(); + ImmutableCollection fieldDescriptors = extensionDescriptorMap.get(typeName); + + return fieldDescriptors.stream().filter(d -> d.getFullName().equals(fieldName)).findFirst(); + } + + @Override + public ExtensionRegistry getExtensionRegistry() { + return extensionRegistry; + } + + private DefaultDescriptorPool( + ImmutableMap descriptorMap, + ImmutableMultimap extensionDescriptorMap, + ExtensionRegistry extensionRegistry) { + this.descriptorMap = checkNotNull(descriptorMap); + this.extensionDescriptorMap = checkNotNull(extensionDescriptorMap); + this.extensionRegistry = checkNotNull(extensionRegistry); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/DefaultInstanceMessageFactory.java b/common/src/main/java/dev/cel/common/internal/DefaultInstanceMessageFactory.java new file mode 100644 index 000000000..163d0273e --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/DefaultInstanceMessageFactory.java @@ -0,0 +1,71 @@ +// Copyright 2022 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.internal; + +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.GeneratorNames; +import com.google.protobuf.Message; +import com.google.protobuf.MessageLite; +import dev.cel.common.annotations.Internal; +import java.util.Optional; + +/** + * Singleton factory for creating default messages from a protobuf descriptor. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class DefaultInstanceMessageFactory { + private static final DefaultInstanceMessageFactory INSTANCE = new DefaultInstanceMessageFactory(); + + /** Gets a single instance of this MessageFactory */ + public static DefaultInstanceMessageFactory getInstance() { + return INSTANCE; + } + + /** + * Creates a default instance of a protobuf message given a descriptor. This is essentially the + * same as calling FooMessage.getDefaultInstance(), except reflection is leveraged. + * + * @return Default instance of a type. Returns an empty optional if the descriptor used to + * construct the type via reflection is different to the provided descriptor or if the + * descriptor class isn't loaded in the binary. + */ + public Optional getPrototype(Descriptor descriptor) { + MessageLite defaultInstance = + DefaultInstanceMessageLiteFactory.getInstance() + .getPrototype(descriptor.getFullName(), GeneratorNames.getBytecodeClassName(descriptor)) + .orElse(null); + if (defaultInstance == null) { + return Optional.empty(); + } + + if (!(defaultInstance instanceof Message)) { + throw new IllegalArgumentException( + "Expected a full protobuf message, but got: " + defaultInstance.getClass()); + } + + Message fullMessage = (Message) defaultInstance; + + // Reference equality is intended. We want to make sure the descriptors are equal + // to guarantee types to be hermetic if linked types is disabled. + if (fullMessage.getDescriptorForType() != descriptor) { + return Optional.empty(); + } + return Optional.of(fullMessage); + } + + private DefaultInstanceMessageFactory() {} +} diff --git a/common/src/main/java/dev/cel/common/internal/DefaultInstanceMessageLiteFactory.java b/common/src/main/java/dev/cel/common/internal/DefaultInstanceMessageLiteFactory.java new file mode 100644 index 000000000..8adb79248 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/DefaultInstanceMessageLiteFactory.java @@ -0,0 +1,109 @@ +// Copyright 2025 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.internal; + +import com.google.common.annotations.VisibleForTesting; +import com.google.protobuf.MessageLite; +import dev.cel.common.annotations.Internal; +import java.lang.reflect.Method; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ConcurrentHashMap; + +/** + * Singleton factory for creating default messages from a fully qualified protobuf type name and its + * java class name. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class DefaultInstanceMessageLiteFactory { + + private static final DefaultInstanceMessageLiteFactory INSTANCE = + new DefaultInstanceMessageLiteFactory(); + + private final Map messageByTypeName = + new ConcurrentHashMap<>(); + + /** Gets a single instance of this DefaultInstanceMessageLiteFactory */ + public static DefaultInstanceMessageLiteFactory getInstance() { + return INSTANCE; + } + + /** + * Creates a default instance of a protobuf message given a fully qualified type name. This is + * essentially the same as calling FooMessage.getDefaultInstance(), except reflection is + * leveraged. + * + * @return Default instance of a type. Returns an empty optional if the java class for the + * protobuf message isn't linked in the binary. + */ + public Optional getPrototype(String protoFqn, String protoJavaClassFqn) { + LazyGeneratedMessageDefaultInstance lazyDefaultInstance = + messageByTypeName.computeIfAbsent( + protoFqn, (unused) -> new LazyGeneratedMessageDefaultInstance(protoJavaClassFqn)); + + MessageLite defaultInstance = lazyDefaultInstance.getDefaultInstance(); + + return Optional.ofNullable(defaultInstance); + } + + /** A placeholder to lazily load the generated messages' defaultInstances. */ + private static final class LazyGeneratedMessageDefaultInstance { + private final String fullClassName; + private volatile MessageLite defaultInstance = null; + private volatile boolean loaded = false; + + public LazyGeneratedMessageDefaultInstance(String fullClassName) { + this.fullClassName = fullClassName; + } + + public MessageLite getDefaultInstance() { + if (!loaded) { + synchronized (this) { + if (!loaded) { + loadDefaultInstance(); + loaded = true; + } + } + } + return defaultInstance; + } + + private void loadDefaultInstance() { + Class clazz; + try { + clazz = Class.forName(fullClassName); + } catch (ClassNotFoundException e) { + // The class may not exist in cases where the java class for the generated message was not + // linked into the binary (Ex: evaluating a checked expression from a + // cached source), or a dynamic descriptor was explicitly used. CEL will return a dynamic + // message in such cases. + return; + } + + Method method = ReflectionUtil.getMethod(clazz, "getDefaultInstance"); + defaultInstance = (MessageLite) ReflectionUtil.invoke(method, null); + } + } + + /** Clears the descriptor map. This should not be used outside testing. */ + @VisibleForTesting + void resetTypeMap() { + messageByTypeName.clear(); + } + + private DefaultInstanceMessageLiteFactory() {} +} diff --git a/common/src/main/java/dev/cel/common/internal/DefaultLiteDescriptorPool.java b/common/src/main/java/dev/cel/common/internal/DefaultLiteDescriptorPool.java new file mode 100644 index 000000000..0078e5c13 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/DefaultLiteDescriptorPool.java @@ -0,0 +1,325 @@ +// Copyright 2025 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.internal; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.Empty; +import com.google.protobuf.FieldMask; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.MessageLite; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import dev.cel.common.annotations.Internal; +import dev.cel.protobuf.CelLiteDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.EncodingType; +import dev.cel.protobuf.CelLiteDescriptor.MessageLiteDescriptor; +import java.util.NoSuchElementException; +import java.util.Optional; +import java.util.function.Supplier; + +/** Descriptor pool for {@link CelLiteDescriptor}s. */ +@Immutable +@Internal +public final class DefaultLiteDescriptorPool implements CelLiteDescriptorPool { + private final ImmutableMap protoFqnToMessageInfo; + private final ImmutableMap, MessageLiteDescriptor> classToMessageInfo; + + public static DefaultLiteDescriptorPool newInstance(CelLiteDescriptor... descriptors) { + return newInstance(ImmutableSet.copyOf(descriptors)); + } + + public static DefaultLiteDescriptorPool newInstance(ImmutableSet descriptors) { + return new DefaultLiteDescriptorPool(descriptors); + } + + @Override + public Optional findDescriptor(MessageLite messageLite) { + return Optional.ofNullable(classToMessageInfo.get(messageLite.getClass())); + } + + @Override + public Optional findDescriptor(String protoTypeName) { + return Optional.ofNullable(protoFqnToMessageInfo.get(protoTypeName)); + } + + @Override + public MessageLiteDescriptor getDescriptorOrThrow(String protoTypeName) { + return findDescriptor(protoTypeName) + .orElseThrow( + () -> new NoSuchElementException("Could not find a descriptor for: " + protoTypeName)); + } + + private static MessageLiteDescriptor newMessageInfo(WellKnownProto wellKnownProto) { + ImmutableList.Builder fieldDescriptors = ImmutableList.builder(); + Supplier messageBuilder = null; + switch (wellKnownProto) { + case ANY_VALUE: + messageBuilder = Any::newBuilder; + fieldDescriptors + .add( + newPrimitiveFieldDescriptor( + 1, + "type_url", + FieldLiteDescriptor.JavaType.STRING, + FieldLiteDescriptor.Type.STRING)) + .add( + newPrimitiveFieldDescriptor( + 2, + "value", + FieldLiteDescriptor.JavaType.BYTE_STRING, + FieldLiteDescriptor.Type.BYTES)); + break; + case FIELD_MASK: + messageBuilder = FieldMask::newBuilder; + fieldDescriptors.add( + new FieldLiteDescriptor( + /* fieldNumber= */ 1, + /* fieldName= */ "paths", + /* javaType= */ FieldLiteDescriptor.JavaType.STRING, + /* encodingType= */ EncodingType.LIST, + /* protoFieldType= */ FieldLiteDescriptor.Type.STRING, + /* isPacked= */ false, + /* fieldProtoTypeName= */ "")); + break; + case BOOL_VALUE: + messageBuilder = BoolValue::newBuilder; + fieldDescriptors.add( + newPrimitiveFieldDescriptor( + 1, "value", FieldLiteDescriptor.JavaType.BOOLEAN, FieldLiteDescriptor.Type.BOOL)); + break; + case BYTES_VALUE: + messageBuilder = BytesValue::newBuilder; + fieldDescriptors.add( + newPrimitiveFieldDescriptor( + 1, + "value", + FieldLiteDescriptor.JavaType.BYTE_STRING, + FieldLiteDescriptor.Type.BYTES)); + break; + case DOUBLE_VALUE: + messageBuilder = DoubleValue::newBuilder; + fieldDescriptors.add( + newPrimitiveFieldDescriptor( + 1, "value", FieldLiteDescriptor.JavaType.DOUBLE, FieldLiteDescriptor.Type.DOUBLE)); + break; + case FLOAT_VALUE: + messageBuilder = FloatValue::newBuilder; + fieldDescriptors.add( + newPrimitiveFieldDescriptor( + 1, "value", FieldLiteDescriptor.JavaType.FLOAT, FieldLiteDescriptor.Type.FLOAT)); + break; + case INT32_VALUE: + messageBuilder = Int32Value::newBuilder; + fieldDescriptors.add( + newPrimitiveFieldDescriptor( + 1, "value", FieldLiteDescriptor.JavaType.INT, FieldLiteDescriptor.Type.INT32)); + break; + case INT64_VALUE: + messageBuilder = Int64Value::newBuilder; + fieldDescriptors.add( + newPrimitiveFieldDescriptor( + 1, "value", FieldLiteDescriptor.JavaType.LONG, FieldLiteDescriptor.Type.INT64)); + break; + case STRING_VALUE: + messageBuilder = StringValue::newBuilder; + fieldDescriptors.add( + newPrimitiveFieldDescriptor( + 1, "value", FieldLiteDescriptor.JavaType.STRING, FieldLiteDescriptor.Type.STRING)); + break; + case UINT32_VALUE: + messageBuilder = UInt32Value::newBuilder; + fieldDescriptors.add( + newPrimitiveFieldDescriptor( + 1, "value", FieldLiteDescriptor.JavaType.INT, FieldLiteDescriptor.Type.UINT32)); + break; + case UINT64_VALUE: + messageBuilder = UInt64Value::newBuilder; + fieldDescriptors.add( + newPrimitiveFieldDescriptor( + 1, "value", FieldLiteDescriptor.JavaType.LONG, FieldLiteDescriptor.Type.UINT64)); + break; + case JSON_STRUCT_VALUE: + messageBuilder = Struct::newBuilder; + fieldDescriptors.add( + new FieldLiteDescriptor( + /* fieldNumber= */ 1, + /* fieldName= */ "fields", + /* javaType= */ FieldLiteDescriptor.JavaType.MESSAGE, + /* encodingType= */ EncodingType.MAP, + /* protoFieldType= */ FieldLiteDescriptor.Type.MESSAGE, + /* isPacked= */ false, + /* fieldProtoTypeName= */ "google.protobuf.Struct.FieldsEntry")); + break; + case JSON_VALUE: + messageBuilder = Value::newBuilder; + fieldDescriptors.add( + new FieldLiteDescriptor( + /* fieldNumber= */ 1, + /* fieldName= */ "null_value", + /* javaType= */ FieldLiteDescriptor.JavaType.ENUM, + /* encodingType= */ EncodingType.SINGULAR, + /* protoFieldType= */ FieldLiteDescriptor.Type.ENUM, + /* isPacked= */ false, + /* fieldProtoTypeName= */ "google.protobuf.NullValue")); + fieldDescriptors.add( + new FieldLiteDescriptor( + /* fieldNumber= */ 2, + /* fieldName= */ "number_value", + /* javaType= */ FieldLiteDescriptor.JavaType.DOUBLE, + /* encodingType= */ EncodingType.SINGULAR, + /* protoFieldType= */ FieldLiteDescriptor.Type.DOUBLE, + /* isPacked= */ false, + /* fieldProtoTypeName= */ "")); + fieldDescriptors.add( + new FieldLiteDescriptor( + /* fieldNumber= */ 3, + /* fieldName= */ "string_value", + /* javaType= */ FieldLiteDescriptor.JavaType.STRING, + /* encodingType= */ EncodingType.SINGULAR, + /* protoFieldType= */ FieldLiteDescriptor.Type.STRING, + /* isPacked= */ false, + /* fieldProtoTypeName= */ "")); + fieldDescriptors.add( + new FieldLiteDescriptor( + /* fieldNumber= */ 4, + /* fieldName= */ "bool_value", + /* javaType= */ FieldLiteDescriptor.JavaType.BOOLEAN, + /* encodingType= */ EncodingType.SINGULAR, + /* protoFieldType= */ FieldLiteDescriptor.Type.BOOL, + /* isPacked= */ false, + /* fieldProtoTypeName= */ "")); + fieldDescriptors.add( + new FieldLiteDescriptor( + /* fieldNumber= */ 5, + /* fieldName= */ "struct_value", + /* javaType= */ FieldLiteDescriptor.JavaType.MESSAGE, + /* encodingType= */ EncodingType.SINGULAR, + /* protoFieldType= */ FieldLiteDescriptor.Type.MESSAGE, + /* isPacked= */ false, + /* fieldProtoTypeName= */ "google.protobuf.Struct")); + fieldDescriptors.add( + new FieldLiteDescriptor( + /* fieldNumber= */ 6, + /* fieldName= */ "list_value", + /* javaType= */ FieldLiteDescriptor.JavaType.MESSAGE, + /* encodingType= */ EncodingType.SINGULAR, + /* protoFieldType= */ FieldLiteDescriptor.Type.MESSAGE, + /* isPacked= */ false, + /* fieldProtoTypeName= */ "google.protobuf.ListValue")); + break; + case JSON_LIST_VALUE: + messageBuilder = ListValue::newBuilder; + fieldDescriptors.add( + new FieldLiteDescriptor( + /* fieldNumber= */ 1, + /* fieldName= */ "values", + /* javaType= */ FieldLiteDescriptor.JavaType.MESSAGE, + /* encodingType= */ EncodingType.LIST, + /* protoFieldType= */ FieldLiteDescriptor.Type.MESSAGE, + /* isPacked= */ false, + /* fieldProtoTypeName= */ "google.protobuf.Value")); + break; + case DURATION: + messageBuilder = Duration::newBuilder; + fieldDescriptors + .add( + newPrimitiveFieldDescriptor( + 1, + "seconds", + FieldLiteDescriptor.JavaType.LONG, + FieldLiteDescriptor.Type.INT64)) + .add( + newPrimitiveFieldDescriptor( + 2, "nanos", FieldLiteDescriptor.JavaType.INT, FieldLiteDescriptor.Type.INT32)); + break; + case TIMESTAMP: + messageBuilder = Timestamp::newBuilder; + fieldDescriptors + .add( + newPrimitiveFieldDescriptor( + 1, + "seconds", + FieldLiteDescriptor.JavaType.LONG, + FieldLiteDescriptor.Type.INT64)) + .add( + newPrimitiveFieldDescriptor( + 2, "nanos", FieldLiteDescriptor.JavaType.INT, FieldLiteDescriptor.Type.INT32)); + break; + case EMPTY: + messageBuilder = Empty::newBuilder; + } + + return new MessageLiteDescriptor( + wellKnownProto.typeName(), fieldDescriptors.build(), messageBuilder); + } + + private static FieldLiteDescriptor newPrimitiveFieldDescriptor( + int fieldNumber, + String fieldName, + FieldLiteDescriptor.JavaType javaType, + FieldLiteDescriptor.Type protoFieldType) { + return new FieldLiteDescriptor( + /* fieldNumber= */ fieldNumber, + /* fieldName= */ fieldName, + /* javaType= */ javaType, + /* encodingType= */ EncodingType.SINGULAR, + /* protoFieldType= */ protoFieldType, + /* isPacked= */ false, + /* fieldProtoTypeName= */ ""); + } + + private DefaultLiteDescriptorPool(ImmutableSet descriptors) { + ImmutableMap.Builder protoFqnMapBuilder = ImmutableMap.builder(); + ImmutableMap.Builder, MessageLiteDescriptor> classMapBuilder = ImmutableMap.builder(); + for (WellKnownProto wellKnownProto : WellKnownProto.values()) { + MessageLiteDescriptor wktMessageInfo = newMessageInfo(wellKnownProto); + protoFqnMapBuilder.put(wellKnownProto.typeName(), wktMessageInfo); + classMapBuilder.put(wellKnownProto.messageClass(), wktMessageInfo); + } + + for (CelLiteDescriptor descriptor : descriptors) { + protoFqnMapBuilder.putAll(descriptor.getProtoTypeNamesToDescriptors()); + + for (MessageLiteDescriptor messageLiteDescriptor : + descriptor.getProtoTypeNamesToDescriptors().values()) { + // Note: message builder is null for proto maps. + Optional.ofNullable(messageLiteDescriptor.newMessageBuilder()) + .ifPresent( + builder -> + classMapBuilder.put( + builder.getDefaultInstanceForType().getClass(), messageLiteDescriptor)); + } + } + + this.protoFqnToMessageInfo = protoFqnMapBuilder.buildOrThrow(); + this.classToMessageInfo = classMapBuilder.buildOrThrow(); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/DefaultMessageFactory.java b/common/src/main/java/dev/cel/common/internal/DefaultMessageFactory.java new file mode 100644 index 000000000..68d05e127 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/DefaultMessageFactory.java @@ -0,0 +1,64 @@ +// Copyright 2023 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.internal; + +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.Message; +import dev.cel.common.annotations.Internal; +import java.util.Optional; + +/** DefaultMessageFactory produces {@link Message.Builder} instances by protobuf name. */ +@Internal +public final class DefaultMessageFactory implements ProtoMessageFactory { + + /** A default message factory instance that can construct well known typed messages. */ + public static final DefaultMessageFactory INSTANCE = create(DefaultDescriptorPool.INSTANCE); + + private final CelDescriptorPool celDescriptorPool; + + public static DefaultMessageFactory create(CelDescriptorPool celDescriptorPool) { + return new DefaultMessageFactory(celDescriptorPool); + } + + @Override + public CelDescriptorPool getDescriptorPool() { + return celDescriptorPool; + } + + @Override + public Optional newBuilder(String messageName) { + Optional descriptor = celDescriptorPool.findDescriptor(messageName); + if (!descriptor.isPresent()) { + return Optional.empty(); + } + + // If the descriptor that's resolved does not match the descriptor instance in the message + // factory, the call to fetch the prototype will return null, and a dynamic proto message + // should be used as a fallback. + Optional message = + DefaultInstanceMessageFactory.getInstance().getPrototype(descriptor.get()); + + if (message.isPresent()) { + return message.map(Message::newBuilderForType); + } + + return Optional.of(DynamicMessage.newBuilder(descriptor.get())); + } + + private DefaultMessageFactory(CelDescriptorPool celDescriptorPool) { + this.celDescriptorPool = celDescriptorPool; + } +} diff --git a/common/src/main/java/dev/cel/common/internal/DynamicProto.java b/common/src/main/java/dev/cel/common/internal/DynamicProto.java new file mode 100644 index 000000000..903c6b9b6 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/DynamicProto.java @@ -0,0 +1,144 @@ +// Copyright 2022 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.internal; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Any; +import com.google.protobuf.ByteString; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.Message; +import dev.cel.common.annotations.Internal; +import java.util.Optional; + +/** + * The {@code DynamicProto} class supports the conversion of {@link Any} values to concrete {@code + * Message} types based on provided descriptors. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@CheckReturnValue +@Internal +public final class DynamicProto { + private final ProtoMessageFactory protoMessageFactory; + + public static DynamicProto create(ProtoMessageFactory protoMessageFactory) { + return new DynamicProto(protoMessageFactory); + } + + DynamicProto(ProtoMessageFactory protoMessageFactory) { + this.protoMessageFactory = checkNotNull(protoMessageFactory); + } + + /** + * Gets the underlying message factory used to construct new protobuf messages upon unpacking an + * Any message. + */ + public ProtoMessageFactory getProtoMessageFactory() { + return protoMessageFactory; + } + + /** Attempts to unpack an Any message. */ + public Optional maybeUnpackAny(Message msg) { + try { + Any any = + msg instanceof Any + ? (Any) msg + : Any.parseFrom( + msg.toByteString(), + protoMessageFactory.getDescriptorPool().getExtensionRegistry()); + + return Optional.of(unpack(any)); + } catch (InvalidProtocolBufferException e) { + return Optional.empty(); + } + } + + /** + * Unpack an {@code Any} value to a concrete {@code Message} value. + * + *

For protobuf types which have been linked into the binary, the method will return an + * instance of a derived {@code Message} type. However, for messages unpacked from the configured + * descriptors, the result will be a {@link DynamicMessage} instance. + */ + public Message unpack(Any any) throws InvalidProtocolBufferException { + String messageTypeName = + getTypeNameFromTypeUrl(any.getTypeUrl()) + .orElseThrow( + () -> + new InvalidProtocolBufferException( + String.format("malformed type URL: %s", any.getTypeUrl()))); + + Message.Builder builder = + protoMessageFactory + .newBuilder(messageTypeName) + .orElseThrow( + () -> + new InvalidProtocolBufferException( + String.format("no such descriptor for type: %s", messageTypeName))); + + return merge(builder, any.getValue()); + } + + /** + * This method will attempt to adapt a {@code DynamicMessage} instance to a generated {@code + * Message} instance if possible. This scenario can occur during field selection on a higher level + * dynamic message whose type isn't linked in the binary, but the field's type is. + */ + public Message maybeAdaptDynamicMessage(DynamicMessage input) { + Optional maybeBuilder = + protoMessageFactory.newBuilder(input.getDescriptorForType().getFullName()); + if (!maybeBuilder.isPresent() || maybeBuilder.get() instanceof DynamicMessage.Builder) { + // Just return the same input if: + // 1. We didn't get a builder back because there's no descriptor (nothing we can do) + // 2. We got a DynamicBuilder back because a different descriptor was found (nothing we need + // to do) + return input; + } + + return merge(maybeBuilder.get(), input.toByteString()); + } + + /** + * Merge takes in a Message builder and merges another message bytes into the builder. Some + * example usages are: + * + *

    + *
  1. 1. Merging a DynamicMessage content into a concrete message + *
  2. 2. Merging an Any packed message content into a concrete message + *
+ */ + private Message merge(Message.Builder builder, ByteString inputBytes) { + try { + return builder + .mergeFrom(inputBytes, protoMessageFactory.getDescriptorPool().getExtensionRegistry()) + .build(); + } catch (InvalidProtocolBufferException e) { + throw new AssertionError("Failed to merge input message into the message builder", e); + } + } + + private static Optional getTypeNameFromTypeUrl(String typeUrl) { + int pos = typeUrl.lastIndexOf('/'); + if (pos != -1) { + return Optional.of(typeUrl.substring(pos + 1)); + } + return Optional.empty(); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/EmptyCodePointArray.java b/common/src/main/java/dev/cel/common/internal/EmptyCodePointArray.java new file mode 100644 index 000000000..8bca7bf31 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/EmptyCodePointArray.java @@ -0,0 +1,68 @@ +// Copyright 2022 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.internal; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.DoNotCall; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; + +/** + * Represents an empty code point. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +final class EmptyCodePointArray extends CelCodePointArray { + + static final EmptyCodePointArray INSTANCE = new EmptyCodePointArray(); + + private EmptyCodePointArray() {} + + @Override + public BasicCodePointArray slice(int i, int j) { + if (i < 0) { + throw new IndexOutOfBoundsException(String.format("index (%s) must not be negative", i)); + } + throw new IndexOutOfBoundsException( + String.format("index (%s) must not be greater than size (0)", i)); + } + + @Override + @DoNotCall + public int get(int index) { + if (index < 0) { + throw new IndexOutOfBoundsException(String.format("index (%s) must not be negative", index)); + } + throw new IndexOutOfBoundsException( + String.format("index (%s) must not be greater than size (0)", index)); + } + + @Override + public int size() { + return 0; + } + + @Override + public ImmutableList lineOffsets() { + return ImmutableList.of(1); + } + + @Override + public String toString() { + return ""; + } +} diff --git a/common/src/main/java/dev/cel/common/internal/EnvVisitable.java b/common/src/main/java/dev/cel/common/internal/EnvVisitable.java new file mode 100644 index 000000000..5e5851e00 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/EnvVisitable.java @@ -0,0 +1,21 @@ +// Copyright 2022 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.internal; + +/** Simple API for exposing a class with a visitable CEL environment. */ +public interface EnvVisitable { + + void accept(EnvVisitor visitor); +} diff --git a/common/src/main/java/dev/cel/common/internal/EnvVisitor.java b/common/src/main/java/dev/cel/common/internal/EnvVisitor.java new file mode 100644 index 000000000..edb46a1dd --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/EnvVisitor.java @@ -0,0 +1,38 @@ +// Copyright 2022 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.internal; + +import dev.cel.expr.Decl; +import dev.cel.common.annotations.Internal; +import dev.cel.parser.CelMacro; +import java.util.List; + +/** + * Simple API for visiting the declarations of a CEL environment + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public interface EnvVisitor { + + /** + * Visit the declaration {@code name} and associated types, identifiers, and functions associated + * with that name. + */ + void visitDecl(String name, List decls); + + /** Visit the CEL macro. */ + void visitMacro(CelMacro macro); +} diff --git a/common/src/main/java/dev/cel/common/internal/Errors.java b/common/src/main/java/dev/cel/common/internal/Errors.java new file mode 100644 index 000000000..3796b642a --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/Errors.java @@ -0,0 +1,318 @@ +// Copyright 2023 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.internal; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Joiner; +import com.google.common.base.Preconditions; +import com.google.common.base.Splitter; +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.ImmutableIntArray; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.List; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** + * An object which manages error reporting. Enriches error messages by source context pointing to + * the position in the source where the error occurred. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class Errors { + + private static final String NEWLINE = System.lineSeparator(); + private static final Splitter LINE_SPLITTER = Splitter.on(NEWLINE); + + /** + * Represents an error context. A context consists of a description (like a file name), and an + * optional source. It is capable of calculating a line/column pair if the source is provided. + */ + @Immutable + private static class Context { + private final String description; + @Nullable private final String source; + private final ImmutableIntArray codePoints; + private final ImmutableIntArray linePositions; + + private Context(String description, @Nullable String source) { + this.description = description; + this.source = source; + this.codePoints = + source == null + ? ImmutableIntArray.of() + : ImmutableIntArray.copyOf(source.codePoints().toArray()); + + ImmutableIntArray.Builder linePositionsBuilder = ImmutableIntArray.builder(); + if (source != null) { + int linePosition = 0; + for (String line : LINE_SPLITTER.split(source)) { + linePosition += (int) (line.codePoints().count() + 1); + linePositionsBuilder.add(linePosition); + } + } + this.linePositions = linePositionsBuilder.build(); + } + + /** Compute the source line offset positions within the input file. */ + private ImmutableIntArray getLineOffsets() { + return linePositions; + } + + private SourceLocation getPositionLocation(int position) { + int line = 1; + for (int index = 0; index < linePositions.length(); index++) { + if (linePositions.get(index) > position) { + break; + } + line++; + } + if (line == 1) { + return SourceLocation.of(line, position + 1); + } + int lineStartPosition = linePositions.get(line - 2); + return SourceLocation.of(line, position - lineStartPosition + 1); + } + + /** Get the snippet of source at the given {@code line}, if present. */ + private Optional getSnippet(int line) { + if (source == null) { + // Source not available, can't calculate. + return Optional.empty(); + } + + if (line - 1 < linePositions.length()) { + int lineStart = linePositions.length() == 1 || line == 1 ? 0 : linePositions.get(line - 2); + int lineEnd = linePositions.get(line - 1); + return Optional.of(new String(codePoints.toArray(), lineStart, (lineEnd - lineStart - 1))); + } + return Optional.empty(); + } + } + + /** SourceLocation gives the line and column where an expression starts. */ + @AutoValue + @Immutable + public abstract static class SourceLocation { + + /** Return the line where the source appears. */ + public abstract int line(); + + /** Return the column where the source starts. */ + public abstract int column(); + + /** Create a new {@code SourceLocation} from {@code line} and {@code column}. */ + public static SourceLocation of(int line, int column) { + return new AutoValue_Errors_SourceLocation(line, column); + } + } + + /** + * Represents an error. An error is associated with a context, a position, and a message. This + * information is opaque currently, and the only public method on an error is to convert it into a + * string. + */ + @SuppressWarnings("JavaLangClash") + @Immutable + public static class Error { + + private final Context context; + private final int position; + private final String message; + private final long exprId; + + private Error(long exprId, Context context, int position, String message) { + this.exprId = exprId; + this.context = context; + this.position = position; + this.message = message; + } + + /** Returns the code point position assigned to the expression with the error. */ + public int position() { + return position; + } + + /** Returns the raw error message without the container or line number. */ + public String rawMessage() { + return message; + } + + /** + * Returns the expression ID associated with this error. May return 0 if the error is not caused + * by an expression (ex: environment misconfiguration). + */ + public long exprId() { + return exprId; + } + + /** Formats the error into a string which indicates where it occurs within the expression. */ + public String toDisplayString(@Nullable ErrorFormatter formatter) { + String marker = formatter != null ? formatter.formatError("ERROR") : "ERROR"; + SourceLocation location = context.getPositionLocation(position); + Optional sourceLine = context.getSnippet(location.line()); + if (!sourceLine.isPresent()) { + // Without source information, report error with absolute position. + return String.format("%s: %s:%s: %s", marker, context.description, position, message); + } + int line = location.line(); + int column = location.column(); + StringBuilder result = + new StringBuilder( + String.format( + "%s: %s:%s:%s: %s", marker, context.description, line, column, message)); + result.append(NEWLINE); + result.append(" | "); + result.append(sourceLine.get().replace("%", "%%")); + result.append(NEWLINE); + result.append(" | "); + result.append(Strings.repeat(".", column - 1)); + result.append("^"); + return result.toString(); + } + + @Override + public String toString() { + return toDisplayString(null); + } + } + + // The list of errors reported so far. + private final List errors = new ArrayList<>(); + + // A stack of error contexts. + private final Deque context = new ArrayDeque<>(); + + /** + * Creates an errors object. + * + * @param description description of the root error context used in error messages, e.g. a + * filename. + * @param source the (optional) source string associated with the root error context. + */ + public Errors(String description, @Nullable String source) { + enterContext(description, source); + } + + /** + * Enters a new error context. Errors reported in this context will use given description and + * source. + */ + public void enterContext(String description, @Nullable String source) { + context.addFirst(new Context(Preconditions.checkNotNull(description), source)); + } + + /** Exits the last entered error context. */ + public void exitContext() { + Preconditions.checkState(!context.isEmpty(), "cannot exit top-level error context"); + context.removeFirst(); + } + + /** Returns the line offet positions for the currently active error context. */ + public ImmutableIntArray getLineOffsets() { + return context.peekFirst().getLineOffsets(); + } + + public String getContent() { + return context.peekFirst().source; + } + + /** Returns description of the currently active error context. */ + public String getDescription() { + return context.peek().description; + } + + /** Returns a location description at the current offset position. */ + public String getLocationAt(int position) { + Context current = context.peekFirst(); + SourceLocation location = current.getPositionLocation(position); + int line = location.line(); + int column = location.column(); + return String.format("%s:%d:%d", current.description, line, column); + } + + /** Returns the raw codepoint offset for the given line and column. */ + public int getLocationPosition(int line, int column) { + ImmutableIntArray lineOffsets = getLineOffsets(); + if (line == 1) { + return column - 1; + } + if (line > 1 && line - 1 < lineOffsets.length()) { + return lineOffsets.get(line - 2) + column - 1; + } + return -1; + } + + /** Returns the {@code SourceLocation} for the given codepoint offset {@code position}. */ + public SourceLocation getPositionLocation(int position) { + Context current = context.peekFirst(); + return current.getPositionLocation(position); + } + + /** Returns the snippet of source at the given line, if present. */ + public Optional getSnippet(int line) { + Context current = context.peekFirst(); + return current.getSnippet(line); + } + + /** Returns the number of errors reported via this object. */ + public int getErrorCount() { + return errors.size(); + } + + /** Return the list of errors reported so far. */ + public ImmutableList getErrors() { + return ImmutableList.copyOf(errors); + } + + /** Returns a string will all errors reported via this object. */ + public String getAllErrorsAsString() { + return Joiner.on(NEWLINE).join(errors); + } + + /** + * Note: Used by codegen + * + * @deprecated Use {@link #reportError(long, int, String, Object...) instead} + */ + @Deprecated + public void reportError(int position, String message, Object... args) { + reportError(0L, position, message, args); + } + + /** Reports an error. */ + // TODO: Consider adding @FormatMethod here and updating all upstream callers. + public void reportError(long exprId, int position, String message, Object... args) { + if (args.length > 0) { + message = String.format(message, args); + } + errors.add(new Error(exprId, context.peekFirst(), position, message)); + } + + /** + * Helper interface to format an error string. + * + *

For example, this interface may be used to alter the code-coding of an error string. + */ + public interface ErrorFormatter { + String formatError(String errorMessage); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/FileDescriptorSetConverter.java b/common/src/main/java/dev/cel/common/internal/FileDescriptorSetConverter.java new file mode 100644 index 000000000..5bde34097 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/FileDescriptorSetConverter.java @@ -0,0 +1,102 @@ +// Copyright 2022 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.internal; + +import com.google.common.base.VerifyException; +import com.google.common.collect.ImmutableCollection; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.protobuf.DescriptorProtos.FileDescriptorProto; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.DescriptorValidationException; +import com.google.protobuf.Descriptors.FileDescriptor; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Utility class for converting from a {@code FileDescriptorSet} to a collection of {@code + * FileDescriptor} instances. + * + *

CEL Library Internals. Do Not Use. + */ +@CheckReturnValue +public final class FileDescriptorSetConverter { + + /** + * Extracts all FileDescriptors from the FileDescriptorSet + * + *

Warning: This will produce a unique FileDescriptor instances. Use with care especially in + * hermetic environments. + */ + public static ImmutableSet convert(FileDescriptorSet fileDescriptorSet) { + Map descriptorProtos = new HashMap<>(); + for (FileDescriptorProto fileProto : fileDescriptorSet.getFileList()) { + descriptorProtos.put(fileProto.getName(), fileProto); + } + Map fileDescriptors = new HashMap<>(); + for (FileDescriptorProto fileProto : fileDescriptorSet.getFileList()) { + readDescriptor(fileProto.getName(), descriptorProtos, fileDescriptors); + } + return ImmutableSet.copyOf(fileDescriptors.values()); + } + + /** + * Helper method for the DescriptorTypeProvider constructor which takes a file descriptor set + * proto as produced by tools like the protocol compiler. In order to turn the proto into an + * in-memory descriptor, we need to call {@link FileDescriptor#buildFrom(FileDescriptorProto, + * FileDescriptor[])} in the expected way, having all dependencies already recursively built. + */ + @CanIgnoreReturnValue + private static FileDescriptor readDescriptor( + String fileName, + Map descriptorProtos, + Map descriptors) { + if (descriptors.containsKey(fileName)) { + return descriptors.get(fileName); + } + if (!descriptorProtos.containsKey(fileName)) { + throw new IllegalArgumentException( + "file descriptor set with unresolved proto file: " + fileName); + } + FileDescriptorProto fileProto = descriptorProtos.get(fileName); + // Read dependencies first, they are needed to create the logical descriptor from the proto. + List deps = new ArrayList<>(); + for (String dep : fileProto.getDependencyList()) { + ImmutableCollection wktProtos = WellKnownProto.getByPathName(dep); + if (wktProtos.isEmpty()) { + deps.add(readDescriptor(dep, descriptorProtos, descriptors)); + } else { + // Ensure the generated message's descriptor is used as a dependency for WKTs to avoid + // issues with descriptor instance mismatch. + WellKnownProto wellKnownProto = wktProtos.iterator().next(); + deps.add(DefaultDescriptorPool.getWellKnownProtoDescriptor(wellKnownProto).getFile()); + } + } + // Create the file descriptor, cache, and return. + try { + FileDescriptor result = + FileDescriptor.buildFrom(fileProto, deps.toArray(new FileDescriptor[0])); + descriptors.put(fileName, result); + return result; + } catch (DescriptorValidationException e) { + throw new VerifyException(e); + } + } + + private FileDescriptorSetConverter() {} +} diff --git a/common/src/main/java/dev/cel/common/internal/Latin1CodePointArray.java b/common/src/main/java/dev/cel/common/internal/Latin1CodePointArray.java new file mode 100644 index 000000000..42cc0445c --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/Latin1CodePointArray.java @@ -0,0 +1,70 @@ +// Copyright 2022 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.internal; + +import static com.google.common.base.Preconditions.checkElementIndex; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkPositionIndexes; +import static java.nio.charset.StandardCharsets.ISO_8859_1; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; + +/** + * Represents an in-memory contiguous source of ISO-LATIN-1 code points. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +@AutoValue +@AutoValue.CopyAnnotations +@SuppressWarnings("Immutable") // byte[] is not exposed externally, thus cannot be mutated. +public abstract class Latin1CodePointArray extends CelCodePointArray { + + @SuppressWarnings("mutable") + abstract byte[] codePoints(); + + abstract int offset(); + + static Latin1CodePointArray create( + byte[] codePoints, int size, ImmutableList lineOffsets) { + return create(codePoints, 0, lineOffsets, size); + } + + static Latin1CodePointArray create( + byte[] codePoints, int offset, ImmutableList lineOffsets, int size) { + return new AutoValue_Latin1CodePointArray(size, checkNotNull(lineOffsets), codePoints, offset); + } + + @Override + public Latin1CodePointArray slice(int i, int j) { + checkPositionIndexes(i, j, size()); + return create(codePoints(), offset() + i, lineOffsets(), j - i); + } + + @Override + public int get(int index) { + checkElementIndex(index, size()); + return Byte.toUnsignedInt(codePoints()[offset() + index]); + } + + @Override + public final String toString() { + return new String(codePoints(), offset(), size(), ISO_8859_1); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/ProtoAdapter.java b/common/src/main/java/dev/cel/common/internal/ProtoAdapter.java new file mode 100644 index 000000000..7e3910433 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/ProtoAdapter.java @@ -0,0 +1,464 @@ +// Copyright 2022 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.internal; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.primitives.Ints; +import com.google.common.primitives.UnsignedInts; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Any; +import com.google.protobuf.ByteString; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.EnumValueDescriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.MapEntry; +import com.google.protobuf.Message; +import com.google.protobuf.MessageOrBuilder; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** + * The {@code ProtoAdapter} utilities handle conversion between native Java objects which represent + * CEL values and well-known protobuf counterparts. + * + *

How a protobuf is adapted can depend on both the set of {@code Descriptor} values as well as + * on feature-flags. Whereas in the past such conversions were performed as static method calls, + * this class represents an evolving trend toward conditional conversion. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@CheckReturnValue +@Internal +public final class ProtoAdapter { + + /** + * Int converter handles bidirectional conversions between int32 <-> int64 values. + * + *

Note: Unlike the {@code RuntimeHelpers#INT32_TO_INT64} and {@code + * RuntimeHelpers#INT64_TO_INT32} converter objects, the converter takes a {@code Number} as input + * and produces a {@code Number} as output in an effort to make the coverters more tolerant of + * Java native values which may enter the evaluation via {@code DYN} inputs. + */ + public static final BidiConverter INT_CONVERTER = + BidiConverter.of(Number::longValue, value -> intCheckedCast(value.longValue())); + + /** + * Signed uint converter handles bidirectional conversions between uint32 <-> uint64 values. + * + *

Note: Unlike the {@code RuntimeHelpers#UINT32_TO_UINT64} and {@code + * RuntimeHelpers#UINT64_TO_UINT32} converter objects, the converter takes a {@code Number} as + * input and produces a {@code Number} as output in an effort to make the coverters more tolerant + * of Java native values which may enter the evaluation via {@code DYN} inputs. + * + *

If the long being converted to a uint exceeds 32 bits, an {@code IllegalArgumentException} + * will be thrown. + */ + public static final BidiConverter SIGNED_UINT32_CONVERTER = + BidiConverter.of( + value -> UnsignedInts.toLong(value.intValue()), + value -> unsignedIntCheckedCast(value.longValue())); + + /** + * Unigned uint converter handles bidirectional conversions between uint32 <-> uint64 values. + * + *

Note: Unlike the {@code RuntimeHelpers#UINT32_TO_UINT64} and {@code + * RuntimeHelpers#UINT64_TO_UINT32} converter objects, the converter takes a {@code Number} as + * input and produces a {@code Number} as output in an effort to make the coverters more tolerant + * of Java native values which may enter the evaluation via {@code DYN} inputs. + * + *

If the long being converted to a uint exceeds 32 bits, an {@code IllegalArgumentException} + * will be thrown. + */ + public static final BidiConverter UNSIGNED_UINT32_CONVERTER = + BidiConverter.of( + value -> UnsignedLong.fromLongBits(Integer.toUnsignedLong(value.intValue())), + value -> unsignedIntCheckedCast(value.longValue())); + + /** + * Unsigned uint64 converter which adapts from a {@code long} value on the wire to an {@code + * UnsignedLong}. + */ + public static final BidiConverter UNSIGNED_UINT64_CONVERTER = + BidiConverter.of(value -> UnsignedLong.fromLongBits(value.longValue()), Number::longValue); + + /** + * Double converter handles bidirectional conversions between float32 <-> float64 values. + * + *

Note: Unlike the {@code RuntimeHelpers#FLOAT_TO_DOUBLE} and {@code + * RuntimeHelpers#DOUBLE_TO_FLOAT} converter objects, the converter takes a {@code Number} as + * input and produces a {@code Number} as output in an effort to make the coverters more tolerant + * of Java native values which may enter the evaluation via {@code DYN} inputs. + */ + public static final BidiConverter DOUBLE_CONVERTER = + BidiConverter.of(Number::doubleValue, Number::floatValue); + + private final ProtoLiteAdapter protoLiteAdapter; + private final CelOptions celOptions; + private final DynamicProto dynamicProto; + + public ProtoAdapter(DynamicProto dynamicProto, CelOptions celOptions) { + this.dynamicProto = checkNotNull(dynamicProto); + this.protoLiteAdapter = new ProtoLiteAdapter(celOptions); + this.celOptions = celOptions; + } + + /** + * Adapts a protobuf {@code MessageOrBuilder} into a Java object understood by CEL. + * + *

In some instances the input message is also the output value. + */ + public Object adaptProtoToValue(MessageOrBuilder proto) { + // Attempt to convert the proto from a dynamic message into a linked protobuf type if possible. + if (proto instanceof DynamicMessage) { + proto = dynamicProto.maybeAdaptDynamicMessage((DynamicMessage) proto); + } + // If the proto is not a well-known type, then the input Message is what's expected as the + // output return value. + WellKnownProto wellKnownProto = + WellKnownProto.getByTypeName(typeName(proto.getDescriptorForType())).orElse(null); + if (wellKnownProto == null) { + return proto; + } + // Exhaustive switch over the conversion and adaptation of well-known protobuf types to Java + // values. + switch (wellKnownProto) { + case ANY_VALUE: + return unpackAnyProto((Any) proto); + default: + return protoLiteAdapter.adaptWellKnownProtoToValue(proto, wellKnownProto); + } + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + public Optional adaptFieldToValue(FieldDescriptor fieldDescriptor, Object fieldValue) { + if (fieldDescriptor.isMapField()) { + Descriptor entryDescriptor = fieldDescriptor.getMessageType(); + FieldDescriptor keyFieldDescriptor = entryDescriptor.findFieldByNumber(1); + FieldDescriptor valueFieldDescriptor = entryDescriptor.findFieldByNumber(2); + BidiConverter keyConverter = fieldToValueConverter(keyFieldDescriptor); + BidiConverter valueConverter = fieldToValueConverter(valueFieldDescriptor); + + Map map = new HashMap<>(); + Object mapKey; + Object mapValue; + for (Object entry : ((List) fieldValue)) { + if (entry instanceof MapEntry) { + MapEntry mapEntry = (MapEntry) entry; + mapKey = mapEntry.getKey(); + mapValue = mapEntry.getValue(); + } else if (entry instanceof DynamicMessage) { + DynamicMessage dynamicMessage = (DynamicMessage) entry; + mapKey = dynamicMessage.getField(keyFieldDescriptor); + mapValue = dynamicMessage.getField(valueFieldDescriptor); + } else { + throw new IllegalStateException("Unexpected map field type: " + entry); + } + + map.put( + keyConverter.forwardConverter().convert(mapKey), + valueConverter.forwardConverter().convert(mapValue)); + } + + return Optional.of(map); + } + if (fieldDescriptor.isRepeated()) { + BidiConverter bidiConverter = fieldToValueConverter(fieldDescriptor); + if (bidiConverter == BidiConverter.IDENTITY) { + return Optional.of(fieldValue); + } + ArrayList convertedList = + new ArrayList<>(AdaptingTypes.adaptingList((List) fieldValue, bidiConverter)); + return Optional.of(convertedList); + } + + return Optional.of( + fieldToValueConverter(fieldDescriptor).forwardConverter().convert(fieldValue)); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + public Optional adaptValueToFieldType( + FieldDescriptor fieldDescriptor, Object fieldValue) { + if (fieldValue instanceof NullValue) { + // `null` assignment to fields indicate that the field would not be set + // in a protobuf message (e.g: Message{msg_field: null} -> Message{}) + // + // We explicitly check below for invalid null assignments, such as repeated + // or map fields. (e.g: Message{repeated_field: null} -> Error) + if (fieldDescriptor.isMapField() + || fieldDescriptor.isRepeated() + || fieldDescriptor.getJavaType() != FieldDescriptor.JavaType.MESSAGE + || WellKnownProto.JSON_STRUCT_VALUE + .typeName() + .equals(fieldDescriptor.getMessageType().getFullName()) + || WellKnownProto.JSON_LIST_VALUE + .typeName() + .equals(fieldDescriptor.getMessageType().getFullName())) { + throw new IllegalArgumentException("Unsupported field type"); + } + + if (!isFieldAnyOrJson(fieldDescriptor)) { + return Optional.empty(); + } + } + if (fieldDescriptor.isMapField()) { + Descriptor entryDescriptor = fieldDescriptor.getMessageType(); + FieldDescriptor keyDescriptor = entryDescriptor.findFieldByNumber(1); + FieldDescriptor valueDescriptor = entryDescriptor.findFieldByNumber(2); + BidiConverter keyConverter = fieldToValueConverter(keyDescriptor); + BidiConverter valueConverter = fieldToValueConverter(valueDescriptor); + List mapEntries = new ArrayList<>(); + MapEntry protoMapEntry = + MapEntry.newDefaultInstance( + entryDescriptor, + keyDescriptor.getLiteType(), + getDefaultValueForMaybeMessage(keyDescriptor), + valueDescriptor.getLiteType(), + getDefaultValueForMaybeMessage(valueDescriptor)); + boolean isValueAnyOrJson = isFieldAnyOrJson(valueDescriptor); + for (Map.Entry entry : ((Map) fieldValue).entrySet()) { + if (!isValueAnyOrJson && entry.getValue() instanceof NullValue) { + continue; + } + mapEntries.add( + protoMapEntry.toBuilder() + .setKey(keyConverter.backwardConverter().convert(entry.getKey())) + .setValue(valueConverter.backwardConverter().convert(entry.getValue())) + .build()); + } + return Optional.of(mapEntries); + } + if (fieldDescriptor.isRepeated()) { + List listValue = (List) fieldValue; + + if (!isFieldAnyOrJson(fieldDescriptor)) { + listValue = filterOutNullValues(listValue); + } + + return Optional.of( + AdaptingTypes.adaptingList(listValue, fieldToValueConverter(fieldDescriptor).reverse())); + } + + return Optional.of( + fieldToValueConverter(fieldDescriptor).backwardConverter().convert(fieldValue)); + } + + private static List filterOutNullValues(List originalList) { + List filteredList = null; + + for (int i = 0; i < originalList.size(); i++) { + Object elem = originalList.get(i); + + if (elem instanceof NullValue) { + if (filteredList == null) { + filteredList = new ArrayList<>(originalList.size() - 1); + if (i > 0) { + filteredList.addAll(originalList.subList(0, i)); + } + } + } else if (filteredList != null) { + filteredList.add(elem); + } + } + + // Return the original list if no nulls were found to avoid unnecessary allocations + return filteredList != null ? filteredList : originalList; + } + + private static boolean isFieldAnyOrJson(FieldDescriptor fieldDescriptor) { + if (!fieldDescriptor.getType().equals(FieldDescriptor.Type.MESSAGE)) { + return false; + } + + String typeFullName = fieldDescriptor.getMessageType().getFullName(); + + return WellKnownProto.getByTypeName(typeFullName) + .map(wkp -> wkp.equals(WellKnownProto.ANY_VALUE) || wkp.equals(WellKnownProto.JSON_VALUE)) + .orElse(false); + } + + @SuppressWarnings("rawtypes") + private BidiConverter fieldToValueConverter(FieldDescriptor fieldDescriptor) { + switch (fieldDescriptor.getType()) { + case SFIXED32: + case SINT32: + case INT32: + return unwrapAndConvert(INT_CONVERTER); + case FIXED32: + case UINT32: + if (celOptions.enableUnsignedLongs()) { + return unwrapAndConvert(UNSIGNED_UINT32_CONVERTER); + } + return unwrapAndConvert(SIGNED_UINT32_CONVERTER); + case FIXED64: + case UINT64: + if (celOptions.enableUnsignedLongs()) { + return unwrapAndConvert(UNSIGNED_UINT64_CONVERTER); + } + return BidiConverter.of( + BidiConverter.IDENTITY.forwardConverter(), + value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value))); + case FLOAT: + return unwrapAndConvert(DOUBLE_CONVERTER); + case DOUBLE: + case SFIXED64: + case SINT64: + case INT64: + return BidiConverter.of( + BidiConverter.IDENTITY.forwardConverter(), + value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value))); + case BYTES: + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return BidiConverter.of( + ProtoAdapter::adaptProtoByteStringToValue, + value -> adaptCelByteStringToProto(maybeUnwrap(value))); + } + + return BidiConverter.of( + BidiConverter.IDENTITY.forwardConverter(), + value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value))); + case STRING: + return BidiConverter.of( + BidiConverter.IDENTITY.forwardConverter(), + value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value))); + case BOOL: + return BidiConverter.of( + BidiConverter.IDENTITY.forwardConverter(), + value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value))); + case ENUM: + return BidiConverter.of( + value -> (long) ((EnumValueDescriptor) value).getNumber(), + number -> + fieldDescriptor + .getEnumType() + .findValueByNumberCreatingIfUnknown(number.intValue())); + case MESSAGE: + return BidiConverter.of( + this::adaptProtoToValue, + value -> adaptValueToProto(value, fieldDescriptor.getMessageType().getFullName())); + default: + return BidiConverter.IDENTITY; + } + } + + private static CelByteString adaptProtoByteStringToValue(Object proto) { + if (proto instanceof CelByteString) { + return (CelByteString) proto; + } + + return CelByteString.of(((ByteString) proto).toByteArray()); + } + + private static ByteString adaptCelByteStringToProto(Object value) { + if (value instanceof ByteString) { + return (ByteString) value; + } + + return ByteString.copyFrom(((CelByteString) value).toByteArray()); + } + + /** + * Adapt the Java object {@code value} to the given protobuf {@code protoTypeName} if possible. + * + *

If the Java value can be represented as a proto {@code Message}, then a conversion will be + * performed. In some cases, the input {@code value} will be a {@code Message}, but the {@code + * protoTypeName} will indicate an alternative packaging of the value which needs to be + * considered, such as a packing an {@code google.protobuf.StringValue} into a {@code Any} value. + */ + public Message adaptValueToProto(Object value, String protoTypeName) { + WellKnownProto wellKnownProto = WellKnownProto.getByTypeName(protoTypeName).orElse(null); + if (wellKnownProto == null) { + if (value instanceof Message) { + return (Message) value; + } + + throw new IllegalStateException(String.format("value not convertible to proto: %s", value)); + } + + switch (wellKnownProto) { + case ANY_VALUE: + if (value instanceof Message) { + protoTypeName = ((Message) value).getDescriptorForType().getFullName(); + } + return protoLiteAdapter.adaptValueToAny(value, protoTypeName); + default: + return (Message) protoLiteAdapter.adaptValueToWellKnownProto(value, wellKnownProto); + } + } + + private Object unpackAnyProto(Any anyProto) { + try { + return adaptProtoToValue(dynamicProto.unpack(anyProto)); + } catch (InvalidProtocolBufferException e) { + throw new IllegalArgumentException(e); + } + } + + /** Returns the default value for a field that can be a proto message */ + private static Object getDefaultValueForMaybeMessage(FieldDescriptor descriptor) { + if (descriptor.getJavaType() == FieldDescriptor.JavaType.MESSAGE) { + return DynamicMessage.getDefaultInstance(descriptor.getMessageType()); + } + + return descriptor.getDefaultValue(); + } + + private static String typeName(Descriptor protoType) { + return protoType.getFullName(); + } + + private static int intCheckedCast(long value) { + try { + return Ints.checkedCast(value); + } catch (IllegalArgumentException e) { + throw new CelNumericOverflowException(e); + } + } + + private static int unsignedIntCheckedCast(long value) { + try { + return UnsignedInts.checkedCast(value); + } catch (IllegalArgumentException e) { + throw new CelNumericOverflowException(e); + } + } + + private Object maybeUnwrap(Object value) { + if (value instanceof Message) { + return adaptProtoToValue((MessageOrBuilder) value); + } + return value; + } + + private BidiConverter unwrapAndConvert( + final BidiConverter original) { + return BidiConverter.of( + original.forwardConverter()::convert, + value -> original.backwardConverter().convert((Number) maybeUnwrap(value))); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/ProtoEquality.java b/common/src/main/java/dev/cel/common/internal/ProtoEquality.java new file mode 100644 index 000000000..57130b7b7 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/ProtoEquality.java @@ -0,0 +1,198 @@ +// Copyright 2022 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.internal; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Any; +import com.google.protobuf.ByteString; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Message; +import dev.cel.common.annotations.Internal; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** + * The {@code ProtoEquality} implementation is an alternative to the {@link Message#equals} + * implementation that is consistent with the C++ {@code MessageDifferencer::Equals} definition. + * + *

These are the key differences between CEL's proto equality and Java's proto equality: + * + *

    + *
  • NaN is not equal to itself. + *
  • Any values are unpacked before comparison. + *
  • If two Any values cannot be unpacked, they are compared by bytes. + *
+ * + *

CEL Library Internals. Do Not Use. + */ +@CheckReturnValue +@Immutable +@Internal +public final class ProtoEquality { + + private static final String ANY_FULL_NAME = Any.getDescriptor().getFullName(); + + private final DynamicProto dynamicProto; + + public ProtoEquality(DynamicProto dynamicProto) { + this.dynamicProto = dynamicProto; + } + + public boolean equals(Message message1, Message message2) { + if (message1 == message2) { + return true; + } + if (!message1.getDescriptorForType().equals(message2.getDescriptorForType())) { + return false; + } + // both messages must share the same descriptor, so if one is an Any, then both are. + if (isAny(message1)) { + // Convert from Any. The value here could be either Any or DynamicMessage + // Test whether the typeUrl values are the same, if not return false. + // Use the dynamicProto.unpack(message1), dynamicProto.unpack(message2) + // and assign the results to message1 and message2. + Optional unpackedAny1 = dynamicProto.maybeUnpackAny(message1); + Optional unpackedAny2 = dynamicProto.maybeUnpackAny(message2); + if (unpackedAny1.isPresent() && unpackedAny2.isPresent()) { + return equals(unpackedAny1.get(), unpackedAny2.get()); + } + return anyValue(message1).equals(anyValue(message2)); + } + if (!message1.getUnknownFields().equals(message2.getUnknownFields())) { + return false; + } + Map message1Fields = message1.getAllFields(); + Map message2Fields = message2.getAllFields(); + if (message1Fields.size() != message2Fields.size()) { + return false; + } + // No need to do a generic for-each, can use an iterator more efficiently. + for (Map.Entry entry : message1Fields.entrySet()) { + FieldDescriptor field = entry.getKey(); + Object value1 = entry.getValue(); + Object value2 = message2Fields.get(entry.getKey()); + if (value2 == null) { + return false; + } + if (field.isMapField()) { + List mapEntries1 = (List) value1; + List mapEntries2 = (List) value2; + if (mapEntries1.size() != mapEntries2.size()) { + return false; + } + ProtoMap protoMap1 = protoMap(mapEntries1); + ProtoMap protoMap2 = protoMap(mapEntries2); + if (!protoMap1.valueField().equals(protoMap2.valueField())) { + return false; + } + for (Map.Entry mapEntry1 : protoMap1.map().entrySet()) { + Object mapKey = mapEntry1.getKey(); + Object mapValue1 = mapEntry1.getValue(); + if (!protoMap2.map().containsKey(mapKey)) { + return false; + } + Object mapValue2 = protoMap2.map().get(mapKey); + if (!equalsFieldValues(protoMap1.valueField(), mapValue1, mapValue2)) { + return false; + } + } + } else if (field.isRepeated()) { + if (!equalsRepeatedFieldValues(field, (List) value1, (List) value2)) { + return false; + } + } else if (!equalsFieldValues(field, value1, value2)) { + return false; + } + } + return true; + } + + private boolean equalsFieldValues(FieldDescriptor field, Object value1, Object value2) { + switch (field.getJavaType()) { + case MESSAGE: + return equals((Message) value1, (Message) value2); + case DOUBLE: + // fallthrough + case FLOAT: + Number num1 = (Number) value1; + Number num2 = (Number) value2; + boolean num1IsNaN = Double.isNaN(num1.doubleValue()); + boolean num2IsNaN = Double.isNaN(num2.doubleValue()); + // handle the NaN case + if (num1IsNaN && num2IsNaN) { + return false; + } + return num1.equals(num2); + default: + return value1.equals(value2); + } + } + + private boolean equalsRepeatedFieldValues(FieldDescriptor field, List value1, List value2) { + if (value1.size() != value2.size()) { + return false; + } + for (int i = 0; i < value1.size(); i++) { + Object elem1 = value1.get(i); + Object elem2 = value2.get(i); + if (!equalsFieldValues(field, elem1, elem2)) { + return false; + } + } + return true; + } + + private ByteString anyValue(Message msg) { + FieldDescriptor value = msg.getDescriptorForType().findFieldByName("value"); + return (ByteString) msg.getField(value); + } + + private static ProtoMap protoMap(List entries) { + ImmutableMap.Builder protoMap = ImmutableMap.builder(); + FieldDescriptor keyField = null; + FieldDescriptor valueField = null; + for (Object entry : entries) { + Message mapEntry = (Message) entry; + if (keyField == null && valueField == null) { + Descriptor descriptor = mapEntry.getDescriptorForType(); + keyField = descriptor.findFieldByNumber(1); + valueField = descriptor.findFieldByNumber(2); + } + protoMap.put(mapEntry.getField(keyField), mapEntry.getField(valueField)); + } + return ProtoMap.create(valueField, protoMap.buildOrThrow()); + } + + private static boolean isAny(Message msg) { + return msg instanceof Any || msg.getDescriptorForType().getFullName().equals(ANY_FULL_NAME); + } + + @AutoValue + abstract static class ProtoMap { + + abstract FieldDescriptor valueField(); + + abstract ImmutableMap map(); + + static ProtoMap create(FieldDescriptor valueField, ImmutableMap map) { + return new AutoValue_ProtoEquality_ProtoMap(valueField, map); + } + } +} diff --git a/common/src/main/java/dev/cel/common/internal/ProtoLiteAdapter.java b/common/src/main/java/dev/cel/common/internal/ProtoLiteAdapter.java new file mode 100644 index 000000000..3b13ecea1 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/ProtoLiteAdapter.java @@ -0,0 +1,360 @@ +// Copyright 2025 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.internal; + +import static com.google.common.collect.ImmutableMap.toImmutableMap; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.Ints; +import com.google.common.primitives.UnsignedInts; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.Message; +import com.google.protobuf.MessageLite; +import com.google.protobuf.MessageLiteOrBuilder; +import com.google.protobuf.NullValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import dev.cel.common.CelOptions; +import dev.cel.common.CelProtoJsonAdapter; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.common.values.CelByteString; +import java.time.Instant; +import java.util.Map; +import java.util.Map.Entry; + +/** + * {@code ProtoLiteAdapter} utilities handle conversion between native Java objects which represent + * CEL values and well-known protobuf counterparts. + * + *

This adapter does not leverage descriptors, thus is compatible with lite-variants of protobuf + * messages. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +@Immutable +public final class ProtoLiteAdapter { + + private final CelOptions celOptions; + + @SuppressWarnings("unchecked") + public MessageLite adaptValueToWellKnownProto(Object value, WellKnownProto wellKnownProto) { + switch (wellKnownProto) { + case JSON_VALUE: + return CelProtoJsonAdapter.adaptValueToJsonValue(value); + case JSON_STRUCT_VALUE: + return CelProtoJsonAdapter.adaptToJsonStructValue((Map) value); + case JSON_LIST_VALUE: + return CelProtoJsonAdapter.adaptToJsonListValue((Iterable) value); + case BOOL_VALUE: + return BoolValue.of((Boolean) value); + case BYTES_VALUE: + CelByteString byteString = (CelByteString) value; + return BytesValue.of(ByteString.copyFrom(byteString.toByteArray())); + case DOUBLE_VALUE: + return adaptValueToDouble(value); + case FLOAT_VALUE: + return adaptValueToFloat(value); + case INT32_VALUE: + return adaptValueToInt32(value); + case INT64_VALUE: + return adaptValueToInt64(value); + case STRING_VALUE: + return StringValue.of((String) value); + case UINT32_VALUE: + return adaptValueToUint32(value); + case UINT64_VALUE: + return adaptValueToUint64(value); + case DURATION: + return adaptValueToProtoDuration(value); + case TIMESTAMP: + return adaptValueToProtoTimestamp(value); + case EMPTY: + case FIELD_MASK: + // These two WKTs are typically used in context of JSON conversions, in which they are + // automatically unwrapped into equivalent primitive types. + // In other cases, just return the original message itself. + return (MessageLite) value; + default: + throw new IllegalArgumentException( + "Unexpected wellKnownProto kind: " + wellKnownProto + " for value: " + value); + } + } + + public Any adaptValueToAny(Object value, String typeName) { + if (value instanceof MessageLite) { + return packAnyMessage((MessageLite) value, typeName); + } + + if (value instanceof dev.cel.common.values.NullValue) { + return packAnyMessage( + Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build(), WellKnownProto.JSON_VALUE); + } + + WellKnownProto wellKnownProto; + + if (value instanceof Boolean) { + wellKnownProto = WellKnownProto.BOOL_VALUE; + } else if (value instanceof CelByteString) { + wellKnownProto = WellKnownProto.BYTES_VALUE; + } else if (value instanceof String) { + wellKnownProto = WellKnownProto.STRING_VALUE; + } else if (value instanceof Float) { + wellKnownProto = WellKnownProto.FLOAT_VALUE; + } else if (value instanceof Double) { + wellKnownProto = WellKnownProto.DOUBLE_VALUE; + } else if (value instanceof Long) { + wellKnownProto = WellKnownProto.INT64_VALUE; + } else if (value instanceof UnsignedLong) { + wellKnownProto = WellKnownProto.UINT64_VALUE; + } else if (value instanceof Iterable) { + wellKnownProto = WellKnownProto.JSON_LIST_VALUE; + } else if (value instanceof Map) { + wellKnownProto = WellKnownProto.JSON_STRUCT_VALUE; + } else if (value instanceof Instant) { + wellKnownProto = WellKnownProto.TIMESTAMP; + } else if (value instanceof java.time.Duration) { + wellKnownProto = WellKnownProto.DURATION; + } else { + throw new IllegalArgumentException("Unsupported value conversion to any: " + value); + } + + MessageLite wellKnownProtoMsg = adaptValueToWellKnownProto(value, wellKnownProto); + return packAnyMessage(wellKnownProtoMsg, wellKnownProto); + } + + public Object adaptWellKnownProtoToValue( + MessageLiteOrBuilder proto, WellKnownProto wellKnownProto) { + // Exhaustive switch over the conversion and adaptation of well-known protobuf types to Java + // values. + switch (wellKnownProto) { + case JSON_VALUE: + return adaptJsonToValue((Value) proto); + case JSON_STRUCT_VALUE: + return adaptJsonStructToValue((Struct) proto); + case JSON_LIST_VALUE: + return adaptJsonListToValue((ListValue) proto); + case BOOL_VALUE: + return ((BoolValue) proto).getValue(); + case BYTES_VALUE: + ByteString byteString = ((BytesValue) proto).getValue(); + return CelByteString.of(byteString.toByteArray()); + case DOUBLE_VALUE: + return ((DoubleValue) proto).getValue(); + case FLOAT_VALUE: + return (double) ((FloatValue) proto).getValue(); + case INT32_VALUE: + return (long) ((Int32Value) proto).getValue(); + case INT64_VALUE: + return ((Int64Value) proto).getValue(); + case STRING_VALUE: + return ((StringValue) proto).getValue(); + case UINT32_VALUE: + if (celOptions.enableUnsignedLongs()) { + return UnsignedLong.fromLongBits( + Integer.toUnsignedLong(((UInt32Value) proto).getValue())); + } + return (long) ((UInt32Value) proto).getValue(); + case UINT64_VALUE: + if (celOptions.enableUnsignedLongs()) { + return UnsignedLong.fromLongBits(((UInt64Value) proto).getValue()); + } + return ((UInt64Value) proto).getValue(); + case TIMESTAMP: + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return ProtoTimeUtils.toJavaInstant((Timestamp) proto); + } + return proto; + case DURATION: + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return ProtoTimeUtils.toJavaDuration((Duration) proto); + } + return proto; + default: + return proto; + } + } + + private Object adaptJsonToValue(Value value) { + switch (value.getKindCase()) { + case BOOL_VALUE: + return value.getBoolValue(); + case NULL_VALUE: + case KIND_NOT_SET: + return dev.cel.common.values.NullValue.NULL_VALUE; + case NUMBER_VALUE: + return value.getNumberValue(); + case STRING_VALUE: + return value.getStringValue(); + case LIST_VALUE: + return adaptJsonListToValue(value.getListValue()); + case STRUCT_VALUE: + return adaptJsonStructToValue(value.getStructValue()); + } + throw new IllegalArgumentException("unexpected value kind: " + value.getKindCase()); + } + + private ImmutableList adaptJsonListToValue(ListValue listValue) { + return listValue.getValuesList().stream() + .map(this::adaptJsonToValue) + .collect(ImmutableList.toImmutableList()); + } + + private ImmutableMap adaptJsonStructToValue(Struct struct) { + return struct.getFieldsMap().entrySet().stream() + .collect(toImmutableMap(Entry::getKey, e -> adaptJsonToValue(e.getValue()))); + } + + private Message adaptValueToDouble(Object value) { + if (value instanceof Double) { + return DoubleValue.of((Double) value); + } + if (value instanceof Float) { + return DoubleValue.of(((Float) value).doubleValue()); + } + throw new IllegalArgumentException("Unexpected value type: " + value); + } + + private Message adaptValueToFloat(Object value) { + if (value instanceof Double) { + return FloatValue.of(((Double) value).floatValue()); + } + if (value instanceof Float) { + return FloatValue.of((Float) value); + } + throw new IllegalArgumentException("Unexpected value type: " + value); + } + + private Message adaptValueToInt32(Object value) { + if (value instanceof Integer) { + return Int32Value.of((Integer) value); + } + if (value instanceof Long) { + return Int32Value.of(intCheckedCast((Long) value)); + } + throw new IllegalArgumentException("Unexpected value type: " + value); + } + + private Message adaptValueToInt64(Object value) { + if (value instanceof Integer) { + return Int64Value.of(((Integer) value).longValue()); + } + if (value instanceof Long) { + return Int64Value.of((Long) value); + } + + throw new IllegalArgumentException("Unexpected value type: " + value); + } + + private Message adaptValueToUint32(Object value) { + if (value instanceof Integer) { + return UInt32Value.of((Integer) value); + } + if (value instanceof Long) { + try { + return UInt32Value.of(unsignedIntCheckedCast((Long) value)); + } catch (IllegalArgumentException e) { + throw new CelNumericOverflowException(e); + } + } + if (value instanceof UnsignedLong) { + try { + return UInt32Value.of(unsignedIntCheckedCast(((UnsignedLong) value).longValue())); + } catch (IllegalArgumentException e) { + throw new CelNumericOverflowException(e); + } + } + + throw new IllegalArgumentException("Unexpected value type: " + value); + } + + private Message adaptValueToUint64(Object value) { + if (value instanceof Integer) { + return UInt64Value.of(UnsignedInts.toLong((Integer) value)); + } + if (value instanceof Long) { + return UInt64Value.of((Long) value); + } + if (value instanceof UnsignedLong) { + return UInt64Value.of(((UnsignedLong) value).longValue()); + } + + throw new IllegalArgumentException("Unexpected value type: " + value); + } + + private static int intCheckedCast(long value) { + try { + return Ints.checkedCast(value); + } catch (IllegalArgumentException e) { + throw new CelNumericOverflowException(e); + } + } + + private static int unsignedIntCheckedCast(long value) { + try { + return UnsignedInts.checkedCast(value); + } catch (IllegalArgumentException e) { + throw new CelNumericOverflowException(e); + } + } + + private static Any packAnyMessage(MessageLite msg, WellKnownProto wellKnownProto) { + return packAnyMessage(msg, wellKnownProto.typeName()); + } + + private static Any packAnyMessage(MessageLite msg, String typeUrl) { + return Any.newBuilder() + .setValue(msg.toByteString()) + .setTypeUrl("type.googleapis.com/" + typeUrl) + .build(); + } + + private Timestamp adaptValueToProtoTimestamp(Object value) { + if (!celOptions.evaluateCanonicalTypesToNativeValues()) { + return (Timestamp) value; + } + + return ProtoTimeUtils.toProtoTimestamp((Instant) value); + } + + private Duration adaptValueToProtoDuration(Object value) { + if (!celOptions.evaluateCanonicalTypesToNativeValues()) { + return (Duration) value; + } + + return ProtoTimeUtils.toProtoDuration((java.time.Duration) value); + } + + public ProtoLiteAdapter(CelOptions celOptions) { + this.celOptions = celOptions; + } +} diff --git a/common/src/main/java/dev/cel/common/internal/ProtoMessageFactory.java b/common/src/main/java/dev/cel/common/internal/ProtoMessageFactory.java new file mode 100644 index 000000000..d7719ff4f --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/ProtoMessageFactory.java @@ -0,0 +1,63 @@ +// Copyright 2023 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.internal; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Message; +import java.util.Optional; + +/** {@code ProtoMessageFactory} provides a method to create a protobuf builder objects by name. */ +@Immutable +@FunctionalInterface +public interface ProtoMessageFactory { + + /** + * Constructs a new {@link Message.Builder} for a fully qualified proto message type. An empty + * result is returned if a descriptor is missing for the message type name. + */ + Optional newBuilder(String messageName); + + /** Gets the underlying descriptor pool used to construct proto messages. */ + default CelDescriptorPool getDescriptorPool() { + return DefaultDescriptorPool.INSTANCE; + } + + /** + * The {@link CombinedMessageFactory} takes one or more {@link ProtoMessageFactory} instances and + * attempts to create a {@code Message.Builder} instance for a given message name by calling each + * message factory in the order that they are provided to the constructor. + */ + @Immutable + final class CombinedMessageFactory implements ProtoMessageFactory { + + private final ImmutableList messageFactories; + + public CombinedMessageFactory(Iterable messageFactories) { + this.messageFactories = ImmutableList.copyOf(messageFactories); + } + + @Override + public Optional newBuilder(String messageName) { + for (ProtoMessageFactory messageFactory : messageFactories) { + Optional builder = messageFactory.newBuilder(messageName); + if (builder.isPresent()) { + return builder; + } + } + return Optional.empty(); + } + } +} diff --git a/common/src/main/java/dev/cel/common/internal/ProtoTimeUtils.java b/common/src/main/java/dev/cel/common/internal/ProtoTimeUtils.java new file mode 100644 index 000000000..36671842d --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/ProtoTimeUtils.java @@ -0,0 +1,572 @@ +// Copyright 2025 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.internal; + +import static com.google.common.math.LongMath.checkedAdd; +import static com.google.common.math.LongMath.checkedMultiply; +import static com.google.common.math.LongMath.checkedSubtract; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Strings; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.annotations.Internal; +import java.io.Serializable; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.Instant; +import java.util.Comparator; +import java.util.Date; +import java.util.GregorianCalendar; +import java.util.Locale; +import java.util.TimeZone; + +/** + * Utility methods for handling {@code protobuf/duration.proto} and {@code + * protobuf/timestamp.proto}. + * + *

Forked from com.google.protobuf.util package. These exist because there's not an equivalent + * util JAR published in maven central that's compatible with protolite. See relevant github issue. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +// Forked from protobuf-java-utils. Retaining units/date API for parity. +@SuppressWarnings({"GoodTime-ApiWithNumericTimeUnit", "JavaUtilDate"}) +public final class ProtoTimeUtils { + + // Timestamp for "0001-01-01T00:00:00Z" + @VisibleForTesting + static final long TIMESTAMP_SECONDS_MIN = -62135596800L; + // Timestamp for "9999-12-31T23:59:59Z" + @VisibleForTesting + static final long TIMESTAMP_SECONDS_MAX = 253402300799L; + @VisibleForTesting + static final long DURATION_SECONDS_MIN = -315576000000L; + @VisibleForTesting + static final long DURATION_SECONDS_MAX = 315576000000L; + + private static final int MILLIS_PER_SECOND = 1000; + + private static final int NANOS_PER_SECOND = 1000000000; + private static final int NANOS_PER_MILLISECOND = 1000000; + private static final int NANOS_PER_MICROSECOND = 1000; + + private static final long SECONDS_PER_MINUTE = 60L; + private static final long SECONDS_PER_HOUR = SECONDS_PER_MINUTE * 60; + + private static final ThreadLocal TIMESTAMP_FORMAT = + new ThreadLocal() { + @Override + protected SimpleDateFormat initialValue() { + return createTimestampFormat(); + } + }; + + private enum TimestampComparator implements Comparator, Serializable { + INSTANCE; + + @Override + public int compare(Timestamp t1, Timestamp t2) { + checkValid(t1); + checkValid(t2); + int secDiff = Long.compare(t1.getSeconds(), t2.getSeconds()); + return (secDiff != 0) ? secDiff : Integer.compare(t1.getNanos(), t2.getNanos()); + } + } + + private enum DurationComparator implements Comparator, Serializable { + INSTANCE; + + @Override + public int compare(Duration d1, Duration d2) { + checkValid(d1); + checkValid(d2); + int secDiff = Long.compare(d1.getSeconds(), d2.getSeconds()); + return (secDiff != 0) ? secDiff : Integer.compare(d1.getNanos(), d2.getNanos()); + } + } + + /** + * A constant holding the {@link Timestamp} of epoch time, {@code 1970-01-01T00:00:00.000000000Z}. + */ + public static final Timestamp TIMESTAMP_EPOCH = + Timestamp.newBuilder().setSeconds(0).setNanos(0).build(); + + /** A constant holding the duration of zero. */ + public static final Duration DURATION_ZERO = + Duration.newBuilder().setSeconds(0L).setNanos(0).build(); + + private static SimpleDateFormat createTimestampFormat() { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.ENGLISH); + GregorianCalendar calendar = new GregorianCalendar(TimeZone.getTimeZone("UTC")); + // We use Proleptic Gregorian Calendar (i.e., Gregorian calendar extends + // backwards to year one) for timestamp formatting. + calendar.setGregorianChange(new Date(Long.MIN_VALUE)); + sdf.setCalendar(calendar); + return sdf; + } + + /** Convert a {@link Instant} object to proto-based {@link Timestamp}. */ + public static Timestamp toProtoTimestamp(Instant instant) { + return normalizedTimestamp(instant.getEpochSecond(), instant.getNano()); + } + + /** Convert a {@link java.time.Duration} object to proto-based {@link Duration}. */ + public static Duration toProtoDuration(java.time.Duration duration) { + return normalizedDuration(duration.getSeconds(), duration.getNano()); + } + + /** Convert a {@link Timestamp} object to java-based {@link Instant}. */ + public static Instant toJavaInstant(Timestamp timestamp) { + timestamp = normalizedTimestamp(timestamp.getSeconds(), timestamp.getNanos()); + return Instant.ofEpochSecond(timestamp.getSeconds(), timestamp.getNanos()); + } + + /** Convert a {@link Duration} object to java-based {@link java.time.Duration}. */ + public static java.time.Duration toJavaDuration(Duration duration) { + duration = normalizedDuration(duration.getSeconds(), duration.getNanos()); + return java.time.Duration.ofSeconds(duration.getSeconds(), duration.getNanos()); + } + + /** Convert a Timestamp to the number of seconds elapsed from the epoch. */ + public static long toSeconds(Timestamp timestamp) { + return checkValid(timestamp).getSeconds(); + } + + /** + * Convert a Duration to the number of seconds. The result will be rounded towards 0 to the + * nearest second. E.g., if the duration represents -1 nanosecond, it will be rounded to 0. + */ + public static long toSeconds(Duration duration) { + return checkValid(duration).getSeconds(); + } + + /** + * Convert a Duration to the number of hours. The result will be rounded towards 0 to the nearest + * hour. + */ + public static long toHours(Duration duration) { + return checkValid(duration).getSeconds() / SECONDS_PER_HOUR; + } + + /** + * Convert a Duration to the number of minutes. The result will be rounded towards 0 to the + * nearest minute. + */ + public static long toMinutes(Duration duration) { + return checkValid(duration).getSeconds() / SECONDS_PER_MINUTE; + } + + /** + * Convert a Duration to the number of milliseconds. The result will be rounded towards 0 to the + * nearest millisecond. E.g., if the duration represents -1 nanosecond, it will be rounded to 0. + */ + public static long toMillis(Duration duration) { + checkValid(duration); + return checkedAdd( + checkedMultiply(duration.getSeconds(), MILLIS_PER_SECOND), + duration.getNanos() / NANOS_PER_MILLISECOND); + } + + /** Create a Timestamp from the number of seconds elapsed from the epoch. */ + public static Timestamp fromSecondsToTimestamp(long seconds) { + return normalizedTimestamp(seconds, 0); + } + + /** Create a Timestamp from the number of seconds elapsed from the epoch. */ + public static Duration fromSecondsToDuration(long seconds) { + return normalizedDuration(seconds, 0); + } + + /** Create a Timestamp from the number of seconds elapsed from the epoch. */ + public static Duration fromMillisToDuration(long milliseconds) { + return normalizedDuration( + milliseconds / MILLIS_PER_SECOND, + (int) (milliseconds % MILLIS_PER_SECOND * NANOS_PER_MILLISECOND)); + } + + /** Throws an {@link IllegalArgumentException} if the given {@link Duration} is not valid. */ + @CanIgnoreReturnValue + private static Duration checkValid(Duration duration) { + long seconds = duration.getSeconds(); + int nanos = duration.getNanos(); + if (!isDurationValid(seconds, nanos)) { + throw new IllegalArgumentException( + Strings.lenientFormat( + "Duration is not valid. See proto definition for valid values. " + + "Seconds (%s) must be in range [-315,576,000,000, +315,576,000,000]. " + + "Nanos (%s) must be in range [-999,999,999, +999,999,999]. " + + "Nanos must have the same sign as seconds", + seconds, nanos)); + } + return duration; + } + + /** Throws an {@link IllegalArgumentException} if the given {@link Timestamp} is not valid. */ + @CanIgnoreReturnValue + private static Timestamp checkValid(Timestamp timestamp) { + long seconds = timestamp.getSeconds(); + int nanos = timestamp.getNanos(); + if (!isTimestampValid(seconds, nanos)) { + throw new IllegalArgumentException( + Strings.lenientFormat( + "Timestamp is not valid. See proto definition for valid values. " + + "Seconds (%s) must be in range [-62,135,596,800, +253,402,300,799]. " + + "Nanos (%s) must be in range [0, +999,999,999].", + seconds, nanos)); + } + return timestamp; + } + + /** + * Convert Timestamp to RFC 3339 date string format. The output will always be Z-normalized and + * uses 0, 3, 6 or 9 fractional digits as required to represent the exact value. Note that + * Timestamp can only represent time from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. + * See https://www.ietf.org/rfc/rfc3339.txt + * + *

Example of generated format: "1972-01-01T10:00:20.021Z" + * + * @return The string representation of the given timestamp. + * @throws IllegalArgumentException if the given timestamp is not in the valid range. + */ + public static String toString(Timestamp timestamp) { + checkValid(timestamp); + + long seconds = timestamp.getSeconds(); + int nanos = timestamp.getNanos(); + + StringBuilder result = new StringBuilder(); + // Format the seconds part. + Date date = new Date(seconds * MILLIS_PER_SECOND); + result.append(TIMESTAMP_FORMAT.get().format(date)); + // Format the nanos part. + if (nanos != 0) { + result.append("."); + result.append(formatNanos(nanos)); + } + result.append("Z"); + return result.toString(); + } + + /** + * Convert Duration to string format. The string format will contains 3, 6, or 9 fractional digits + * depending on the precision required to represent the exact Duration value. For example: "1s", + * "1.010s", "1.000000100s", "-3.100s" The range that can be represented by Duration is from + * -315,576,000,000 to +315,576,000,000 inclusive (in seconds). + * + * @return The string representation of the given duration. + * @throws IllegalArgumentException if the given duration is not in the valid range. + */ + public static String toString(Duration duration) { + checkValid(duration); + + long seconds = duration.getSeconds(); + int nanos = duration.getNanos(); + + StringBuilder result = new StringBuilder(); + if (seconds < 0 || nanos < 0) { + result.append("-"); + seconds = -seconds; + nanos = -nanos; + } + result.append(seconds); + if (nanos != 0) { + result.append("."); + result.append(formatNanos(nanos)); + } + result.append("s"); + return result.toString(); + } + + /** + * Parse from RFC 3339 date string to Timestamp. This method accepts all outputs of {@link + * #toString(Timestamp)} and it also accepts any fractional digits (or none) and any offset as + * long as they fit into nano-seconds precision. + * + *

Example of accepted format: "1972-01-01T10:00:20.021-05:00" + * + * @return a Timestamp parsed from the string + * @throws ParseException if parsing fails + */ + public static Timestamp parse(String value) throws ParseException { + int dayOffset = value.indexOf('T'); + if (dayOffset == -1) { + throw new ParseException("Failed to parse timestamp: invalid timestamp \"" + value + "\"", 0); + } + int timezoneOffsetPosition = value.indexOf('Z', dayOffset); + if (timezoneOffsetPosition == -1) { + timezoneOffsetPosition = value.indexOf('+', dayOffset); + } + if (timezoneOffsetPosition == -1) { + timezoneOffsetPosition = value.indexOf('-', dayOffset); + } + if (timezoneOffsetPosition == -1) { + throw new ParseException("Failed to parse timestamp: missing valid timezone offset.", 0); + } + // Parse seconds and nanos. + String timeValue = value.substring(0, timezoneOffsetPosition); + String secondValue = timeValue; + String nanoValue = ""; + int pointPosition = timeValue.indexOf('.'); + if (pointPosition != -1) { + secondValue = timeValue.substring(0, pointPosition); + nanoValue = timeValue.substring(pointPosition + 1); + } + Date date = TIMESTAMP_FORMAT.get().parse(secondValue); + long seconds = date.getTime() / MILLIS_PER_SECOND; + int nanos = nanoValue.isEmpty() ? 0 : parseNanos(nanoValue); + // Parse timezone offsets. + if (value.charAt(timezoneOffsetPosition) == 'Z') { + if (value.length() != timezoneOffsetPosition + 1) { + throw new ParseException( + "Failed to parse timestamp: invalid trailing data \"" + + value.substring(timezoneOffsetPosition) + + "\"", + 0); + } + } else { + String offsetValue = value.substring(timezoneOffsetPosition + 1); + long offset = parseTimezoneOffset(offsetValue); + if (value.charAt(timezoneOffsetPosition) == '+') { + seconds -= offset; + } else { + seconds += offset; + } + } + try { + Timestamp timestamp = normalizedTimestamp(seconds, nanos); + return checkValid(timestamp); + } catch (IllegalArgumentException e) { + ParseException ex = + new ParseException( + "Failed to parse timestamp " + value + " Timestamp is out of range.", 0); + ex.initCause(e); + throw ex; + } + } + + /** Adds two durations */ + public static Duration add(Duration d1, Duration d2) { + java.time.Duration javaDuration1 = ProtoTimeUtils.toJavaDuration(checkValid(d1)); + java.time.Duration javaDuration2 = ProtoTimeUtils.toJavaDuration(checkValid(d2)); + + java.time.Duration sum = javaDuration1.plus(javaDuration2); + + return ProtoTimeUtils.toProtoDuration(sum); + } + + /** Adds two timestamps. */ + public static Timestamp add(Timestamp ts, Duration dur) { + Instant javaInstant = ProtoTimeUtils.toJavaInstant(checkValid(ts)); + java.time.Duration javaDuration = ProtoTimeUtils.toJavaDuration(checkValid(dur)); + + Instant newInstant = javaInstant.plus(javaDuration); + + return ProtoTimeUtils.toProtoTimestamp(newInstant); + } + + /** Subtract a duration from another. */ + public static Duration subtract(Duration d1, Duration d2) { + java.time.Duration javaDuration1 = ProtoTimeUtils.toJavaDuration(checkValid(d1)); + java.time.Duration javaDuration2 = ProtoTimeUtils.toJavaDuration(checkValid(d2)); + + java.time.Duration sum = javaDuration1.minus(javaDuration2); + + return ProtoTimeUtils.toProtoDuration(sum); + } + + /** Subtracts two timestamps */ + public static Timestamp subtract(Timestamp ts, Duration dur) { + Instant javaInstant = ProtoTimeUtils.toJavaInstant(checkValid(ts)); + java.time.Duration javaDuration = ProtoTimeUtils.toJavaDuration(checkValid(dur)); + + Instant newInstant = javaInstant.minus(javaDuration); + + return ProtoTimeUtils.toProtoTimestamp(newInstant); + } + + /** Calculate the difference between two timestamps. */ + public static Duration between(Timestamp from, Timestamp to) { + Instant javaFrom = ProtoTimeUtils.toJavaInstant(checkValid(from)); + Instant javaTo = ProtoTimeUtils.toJavaInstant(checkValid(to)); + + java.time.Duration between = java.time.Duration.between(javaFrom, javaTo); + + return ProtoTimeUtils.toProtoDuration(between); + } + + /** + * Compares two durations. The value returned is identical to what would be returned by: {@code + * Durations.comparator().compare(x, y)}. + * + * @return the value {@code 0} if {@code x == y}; a value less than {@code 0} if {@code x < y}; + * and a value greater than {@code 0} if {@code x > y} + */ + public static int compare(Duration x, Duration y) { + return DurationComparator.INSTANCE.compare(x, y); + } + + /** + * Compares two timestamps. The value returned is identical to what would be returned by: {@code + * Timestamps.comparator().compare(x, y)}. + * + * @return the value {@code 0} if {@code x == y}; a value less than {@code 0} if {@code x < y}; + * and a value greater than {@code 0} if {@code x > y} + */ + public static int compare(Timestamp x, Timestamp y) { + return TimestampComparator.INSTANCE.compare(x, y); + } + + /** + * Create a {@link Timestamp} using the best-available (in terms of precision) system clock. + * + *

Note: that while this API is convenient, it may harm the testability of your code, as + * you're unable to mock the current time. Instead, you may want to consider injecting a clock + * instance to read the current time. + */ + public static Timestamp now() { + Instant nowInstant = Instant.now(); + + return Timestamp.newBuilder() + .setSeconds(nowInstant.getEpochSecond()) + .setNanos(nowInstant.getNano()) + .build(); + } + + private static long parseTimezoneOffset(String value) throws ParseException { + int pos = value.indexOf(':'); + if (pos == -1) { + throw new ParseException("Invalid offset value: " + value, 0); + } + String hours = value.substring(0, pos); + String minutes = value.substring(pos + 1); + try { + return (Long.parseLong(hours) * 60 + Long.parseLong(minutes)) * 60; + } catch (NumberFormatException e) { + ParseException ex = new ParseException("Invalid offset value: " + value, 0); + ex.initCause(e); + throw ex; + } + } + + private static int parseNanos(String value) throws ParseException { + int result = 0; + for (int i = 0; i < 9; ++i) { + result = result * 10; + if (i < value.length()) { + if (value.charAt(i) < '0' || value.charAt(i) > '9') { + throw new ParseException("Invalid nanoseconds.", 0); + } + result += value.charAt(i) - '0'; + } + } + return result; + } + + /** + * Returns true if the given number of seconds and nanos is a valid {@link Duration}. The {@code + * seconds} value must be in the range [-315,576,000,000, +315,576,000,000]. The {@code nanos} + * value must be in the range [-999,999,999, +999,999,999]. + * + *

Note: Durations less than one second are represented with a 0 {@code seconds} field + * and a positive or negative {@code nanos} field. For durations of one second or more, a non-zero + * value for the {@code nanos} field must be of the same sign as the {@code seconds} field. + */ + private static boolean isDurationValid(long seconds, int nanos) { + if (seconds < DURATION_SECONDS_MIN || seconds > DURATION_SECONDS_MAX) { + return false; + } + if (nanos < -999999999L || nanos >= NANOS_PER_SECOND) { + return false; + } + if (seconds < 0 || nanos < 0) { + if (seconds > 0 || nanos > 0) { + return false; + } + } + return true; + } + + /** + * Returns true if the given number of seconds and nanos is a valid {@link Timestamp}. The {@code + * seconds} value must be in the range [-62,135,596,800, +253,402,300,799] (i.e., between + * 0001-01-01T00:00:00Z and 9999-12-31T23:59:59Z). The {@code nanos} value must be in the range + * [0, +999,999,999]. + * + *

Note: Negative second values with fractional seconds must still have non-negative + * nanos values that count forward in time. + */ + private static boolean isTimestampValid(long seconds, int nanos) { + if (!isTimestampSecondsValid(seconds)) { + return false; + } + + return nanos >= 0 && nanos < NANOS_PER_SECOND; + } + + /** + * Returns true if the given number of seconds is valid, if combined with a valid number of nanos. + * The {@code seconds} value must be in the range [-62,135,596,800, +253,402,300,799] (i.e., + * between 0001-01-01T00:00:00Z and 9999-12-31T23:59:59Z). + */ + @SuppressWarnings("GoodTime") // this is a legacy conversion API + private static boolean isTimestampSecondsValid(long seconds) { + return seconds >= TIMESTAMP_SECONDS_MIN && seconds <= TIMESTAMP_SECONDS_MAX; + } + + private static Timestamp normalizedTimestamp(long seconds, int nanos) { + if (nanos <= -NANOS_PER_SECOND || nanos >= NANOS_PER_SECOND) { + seconds = checkedAdd(seconds, nanos / NANOS_PER_SECOND); + nanos = nanos % NANOS_PER_SECOND; + } + if (nanos < 0) { + nanos = nanos + NANOS_PER_SECOND; // no overflow since nanos is negative (and we're adding) + seconds = checkedSubtract(seconds, 1); + } + return Timestamp.newBuilder().setSeconds(seconds).setNanos(nanos).build(); + } + + private static Duration normalizedDuration(long seconds, int nanos) { + if (nanos <= -NANOS_PER_SECOND || nanos >= NANOS_PER_SECOND) { + seconds = checkedAdd(seconds, nanos / NANOS_PER_SECOND); + nanos %= NANOS_PER_SECOND; + } + if (seconds > 0 && nanos < 0) { + nanos += NANOS_PER_SECOND; // no overflow since nanos is negative (and we're adding) + seconds--; // no overflow since seconds is positive (and we're decrementing) + } + if (seconds < 0 && nanos > 0) { + nanos -= NANOS_PER_SECOND; // no overflow since nanos is positive (and we're subtracting) + seconds++; // no overflow since seconds is negative (and we're incrementing) + } + return Duration.newBuilder().setSeconds(seconds).setNanos(nanos).build(); + } + + private static String formatNanos(int nanos) { + // Determine whether to use 3, 6, or 9 digits for the nano part. + if (nanos % NANOS_PER_MILLISECOND == 0) { + return String.format(Locale.ENGLISH, "%1$03d", nanos / NANOS_PER_MILLISECOND); + } else if (nanos % NANOS_PER_MICROSECOND == 0) { + return String.format(Locale.ENGLISH, "%1$06d", nanos / NANOS_PER_MICROSECOND); + } else { + return String.format(Locale.ENGLISH, "%1$09d", nanos); + } + } + + private ProtoTimeUtils() {} +} diff --git a/common/src/main/java/dev/cel/common/internal/ReflectionUtil.java b/common/src/main/java/dev/cel/common/internal/ReflectionUtil.java new file mode 100644 index 000000000..97bed650f --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/ReflectionUtil.java @@ -0,0 +1,67 @@ +// Copyright 2025 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.internal; + +import com.google.common.reflect.TypeToken; +import dev.cel.common.annotations.Internal; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Type; + +/** + * Utility class for invoking Java reflection. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class ReflectionUtil { + + public static Method getMethod(Class clazz, String methodName, Class... params) { + try { + return clazz.getMethod(methodName, params); + } catch (NoSuchMethodException e) { + throw new LinkageError( + String.format("method [%s] does not exist in class: [%s].", methodName, clazz.getName()), + e); + } + } + + public static Object invoke(Method method, Object object, Object... params) { + try { + return method.invoke(object, params); + } catch (IllegalArgumentException | InvocationTargetException | IllegalAccessException e) { + throw new LinkageError( + String.format( + "method [%s] invocation failed on class [%s].", + method.getName(), method.getDeclaringClass()), + e); + } + } + + /** Resolves a generic parameter of a base class from a type token. */ + public static Type resolveGenericParameter(TypeToken token, Class baseClass, int index) { + return token.resolveType(baseClass.getTypeParameters()[index]).getType(); + } + + /** + * Extracts the raw Class from a Type. Handles Class, ParameterizedType, and WildcardType (returns + * upper bound). Returns Object.class as fallback. + */ + public static Class getRawType(Type type) { + return TypeToken.of(type).getRawType(); + } + + private ReflectionUtil() {} +} diff --git a/common/src/main/java/dev/cel/common/internal/SafeStringFormatter.java b/common/src/main/java/dev/cel/common/internal/SafeStringFormatter.java new file mode 100644 index 000000000..7c22e834d --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/SafeStringFormatter.java @@ -0,0 +1,48 @@ +// Copyright 2024 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.internal; + +import com.google.re2j.Pattern; +import dev.cel.common.annotations.Internal; + +/** + * {@link SafeStringFormatter} is a wrapper around JDK's {@link String#format}. It prevents any + * unsafe string.format calls by only allowing known formatting specifiers to be provided. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class SafeStringFormatter { + // Allow format specifiers of %d, %f, %s and %n only. + private static final Pattern FORBIDDEN_FORMAT_SPECIFIERS = Pattern.compile("%[^dfsn]"); + + /** + * Performs a safe {@link String#format}. + * + * @param format A format string. Only %d, %f, %s and %n are allowed as formatting specifiers. All + * other formatting specifiers will be stripped out. + * @return A formatted string + */ + public static String format(String format, Object... args) { + if (args.length == 0) { + return format; + } + + String sanitizedMessage = FORBIDDEN_FORMAT_SPECIFIERS.matcher(format).replaceAll(""); + return String.format(sanitizedMessage, args); + } + + private SafeStringFormatter() {} +} diff --git a/common/src/main/java/dev/cel/common/internal/SupplementalCodePointArray.java b/common/src/main/java/dev/cel/common/internal/SupplementalCodePointArray.java new file mode 100644 index 000000000..0c9214410 --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/SupplementalCodePointArray.java @@ -0,0 +1,71 @@ +// Copyright 2022 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.internal; + +import static com.google.common.base.Preconditions.checkElementIndex; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkPositionIndexes; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; + +/** + * Array of code points that contain code points from Latin-1 character set, basic multilingual + * plane or the supplemental multilingual plane. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +@AutoValue +@AutoValue.CopyAnnotations +@SuppressWarnings("Immutable") // int[] is not exposed externally, thus cannot be mutated. +public abstract class SupplementalCodePointArray extends CelCodePointArray { + + @SuppressWarnings("mutable") + abstract int[] codePoints(); + + abstract int offset(); + + static SupplementalCodePointArray create( + int[] codePoints, int size, ImmutableList lineOffsets) { + return create(codePoints, 0, lineOffsets, size); + } + + static SupplementalCodePointArray create( + int[] codePoints, int offset, ImmutableList lineOffsets, int size) { + return new AutoValue_SupplementalCodePointArray( + size, checkNotNull(lineOffsets), codePoints, offset); + } + + @Override + public SupplementalCodePointArray slice(int i, int j) { + checkPositionIndexes(i, j, size()); + return create(codePoints(), offset() + i, lineOffsets(), j - i); + } + + @Override + public int get(int index) { + checkElementIndex(index, size()); + return codePoints()[offset() + index]; + } + + @Override + public final String toString() { + return new String(codePoints(), offset(), size()); + } +} diff --git a/common/src/main/java/dev/cel/common/internal/WellKnownProto.java b/common/src/main/java/dev/cel/common/internal/WellKnownProto.java new file mode 100644 index 000000000..21ee8053e --- /dev/null +++ b/common/src/main/java/dev/cel/common/internal/WellKnownProto.java @@ -0,0 +1,196 @@ +// Copyright 2023 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.internal; + +import static com.google.common.collect.ImmutableMap.toImmutableMap; +import static java.util.Arrays.stream; + +import com.google.common.collect.ImmutableCollection; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableMultimap; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.Empty; +import com.google.protobuf.FieldMask; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import dev.cel.common.annotations.Internal; +import java.util.Optional; +import java.util.function.Function; + +/** + * WellKnownProto types used throughout CEL. These types are specially handled to ensure that + * bidirectional conversion between CEL native values and these well-known types is performed + * consistently across runtimes. + */ +@Internal +public enum WellKnownProto { + ANY_VALUE("google.protobuf.Any", "google/protobuf/any.proto", Any.class), + DURATION("google.protobuf.Duration", "google/protobuf/duration.proto", Duration.class), + JSON_LIST_VALUE("google.protobuf.ListValue", "google/protobuf/struct.proto", ListValue.class), + JSON_STRUCT_VALUE("google.protobuf.Struct", "google/protobuf/struct.proto", Struct.class), + JSON_VALUE("google.protobuf.Value", "google/protobuf/struct.proto", Value.class), + TIMESTAMP("google.protobuf.Timestamp", "google/protobuf/timestamp.proto", Timestamp.class), + // Wrapper types + FLOAT_VALUE( + "google.protobuf.FloatValue", + "google/protobuf/wrappers.proto", + FloatValue.class, + /* isWrapperType= */ true), + INT32_VALUE( + "google.protobuf.Int32Value", + "google/protobuf/wrappers.proto", + Int32Value.class, + /* isWrapperType= */ true), + INT64_VALUE( + "google.protobuf.Int64Value", + "google/protobuf/wrappers.proto", + Int64Value.class, + /* isWrapperType= */ true), + STRING_VALUE( + "google.protobuf.StringValue", + "google/protobuf/wrappers.proto", + StringValue.class, + /* isWrapperType= */ true), + BOOL_VALUE( + "google.protobuf.BoolValue", + "google/protobuf/wrappers.proto", + BoolValue.class, + /* isWrapperType= */ true), + BYTES_VALUE( + "google.protobuf.BytesValue", + "google/protobuf/wrappers.proto", + BytesValue.class, + /* isWrapperType= */ true), + DOUBLE_VALUE( + "google.protobuf.DoubleValue", + "google/protobuf/wrappers.proto", + DoubleValue.class, + /* isWrapperType= */ true), + UINT32_VALUE( + "google.protobuf.UInt32Value", + "google/protobuf/wrappers.proto", + UInt32Value.class, + /* isWrapperType= */ true), + UINT64_VALUE( + "google.protobuf.UInt64Value", + "google/protobuf/wrappers.proto", + UInt64Value.class, + /* isWrapperType= */ true), + // These aren't explicitly called out as wrapper types in the spec, but behave like one, because + // they are still converted into an equivalent primitive type. + + EMPTY( + "google.protobuf.Empty", + "google/protobuf/empty.proto", + Empty.class, + /* isWrapperType= */ true), + FIELD_MASK( + "google.protobuf.FieldMask", + "google/protobuf/field_mask.proto", + FieldMask.class, + /* isWrapperType= */ true); + + private static final ImmutableMap TYPE_NAME_TO_WELL_KNOWN_PROTO_MAP = + stream(WellKnownProto.values()) + .collect(toImmutableMap(WellKnownProto::typeName, Function.identity())); + + private static final ImmutableMap, WellKnownProto> + CLASS_TO_NAME_TO_WELL_KNOWN_PROTO_MAP = + stream(WellKnownProto.values()) + .collect(toImmutableMap(WellKnownProto::messageClass, Function.identity())); + + private static final ImmutableMultimap PATH_NAME_TO_WELL_KNOWN_PROTO_MAP = + initPathNameMap(); + + private static ImmutableMultimap initPathNameMap() { + ImmutableMultimap.Builder builder = ImmutableMultimap.builder(); + for (WellKnownProto proto : values()) { + builder.put(proto.pathName(), proto); + } + return builder.build(); + } + + private final String wellKnownProtoTypeName; + private final String pathName; + private final Class clazz; + private final boolean isWrapperType; + + /** Gets the full proto path name (ex: google/protobuf/any.proto) */ + public String pathName() { + return pathName; + } + + /** Gets the fully qualified prototype name (ex: google.protobuf.FloatValue) */ + public String typeName() { + return wellKnownProtoTypeName; + } + + /** Gets the underlying java class for this WellKnownProto. */ + public Class messageClass() { + return clazz; + } + + /** + * Returns the well known proto given the full proto path (example: + * google/protobuf/timestamp.proto) + */ + public static ImmutableCollection getByPathName(String typeName) { + return PATH_NAME_TO_WELL_KNOWN_PROTO_MAP.get(typeName); + } + + public static Optional getByTypeName(String typeName) { + return Optional.ofNullable(TYPE_NAME_TO_WELL_KNOWN_PROTO_MAP.get(typeName)); + } + + public static Optional getByClass(Class clazz) { + return Optional.ofNullable(CLASS_TO_NAME_TO_WELL_KNOWN_PROTO_MAP.get(clazz)); + } + + /** + * Returns true if the provided {@code typeName} is a well known type, and it's a wrapper. False + * otherwise. + */ + public static boolean isWrapperType(String typeName) { + return getByTypeName(typeName).map(WellKnownProto::isWrapperType).orElse(false); + } + + public boolean isWrapperType() { + return isWrapperType; + } + + WellKnownProto(String wellKnownProtoTypeName, String pathName, Class clazz) { + this(wellKnownProtoTypeName, pathName, clazz, /* isWrapperType= */ false); + } + + WellKnownProto( + String wellKnownProtoFullName, String pathName, Class clazz, boolean isWrapperType) { + this.wellKnownProtoTypeName = wellKnownProtoFullName; + this.pathName = pathName; + this.clazz = clazz; + this.isWrapperType = isWrapperType; + } +} diff --git a/common/src/main/java/dev/cel/common/navigation/BUILD.bazel b/common/src/main/java/dev/cel/common/navigation/BUILD.bazel new file mode 100644 index 000000000..b43f3c289 --- /dev/null +++ b/common/src/main/java/dev/cel/common/navigation/BUILD.bazel @@ -0,0 +1,68 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//common/navigation:__pkg__", + ], +) + +java_library( + name = "common", + srcs = [ + "BaseNavigableExpr.java", + "CelNavigableExprVisitor.java", + "ExprPropertyCalculator.java", + "TraversalOrder.java", + ], + tags = [ + ], + deps = [ + "//:auto_value", + "//common/ast", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "navigation", + srcs = [ + "CelNavigableAst.java", + "CelNavigableExpr.java", + ], + tags = [ + ], + deps = [ + ":common", + "//:auto_value", + "//common:cel_ast", + "//common/ast", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "mutable_navigation", + srcs = [ + "CelNavigableMutableAst.java", + "CelNavigableMutableExpr.java", + ], + tags = [ + ], + deps = [ + ":common", + "//:auto_value", + "//common:mutable_ast", + "//common/ast:mutable_expr", + "//common/types:type_providers", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) diff --git a/common/src/main/java/dev/cel/common/navigation/BaseNavigableExpr.java b/common/src/main/java/dev/cel/common/navigation/BaseNavigableExpr.java new file mode 100644 index 000000000..1699b4a96 --- /dev/null +++ b/common/src/main/java/dev/cel/common/navigation/BaseNavigableExpr.java @@ -0,0 +1,140 @@ +// Copyright 2024 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.navigation; + +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.ExprKind; +import dev.cel.common.ast.Expression; +import java.util.Optional; +import java.util.stream.Stream; + +/** + * BaseNavigableExpr represents the base navigable expression value with methods to inspect the + * parent and child expressions. + */ +@SuppressWarnings("unchecked") // Generic types are properly bound to Expression +abstract class BaseNavigableExpr { + + public abstract E expr(); + + public long id() { + return expr().id(); + } + + public abstract > Optional parent(); + + /** Represents the count of transitive parents. Depth of an AST's root is 0. */ + public abstract int depth(); + + /** + * Represents the maximum ID of the tree. Note that if the underlying expression tree held by this + * navigable expression is mutated, its max ID becomes stale and must be recomputed. + */ + public abstract long maxId(); + + /** + * Represents the maximum count of children from any of its branches. Height of a leaf node is 0. + * For example, the height of the call node 'func' in expression `(1 + 2 + 3).func(4 + 5)` is 3. + */ + public abstract int height(); + + /** + * Returns a stream of {@link BaseNavigableExpr} collected from the current node down to the last + * leaf-level member using post-order traversal. + */ + public > Stream allNodes() { + return allNodes(TraversalOrder.POST_ORDER); + } + + /** + * Returns a stream of {@link BaseNavigableExpr} collected from the current node down to the last + * leaf-level member using the specified traversal order. + */ + public > Stream allNodes(TraversalOrder traversalOrder) { + return CelNavigableExprVisitor.collect((T) this, traversalOrder); + } + + /** + * Returns a stream of {@link BaseNavigableExpr} collected down to the last leaf-level member + * using post-order traversal. + */ + public > Stream descendants() { + return descendants(TraversalOrder.POST_ORDER); + } + + /** + * Returns a stream of {@link BaseNavigableExpr} collected down to the last leaf-level member + * using the specified traversal order. + */ + public > Stream descendants(TraversalOrder traversalOrder) { + return CelNavigableExprVisitor.collect((T) this, traversalOrder) + .filter(node -> node.depth() > this.depth()); + } + + /** + * Returns a stream of {@link BaseNavigableExpr} collected from its immediate children using + * post-order traversal. + */ + public > Stream children() { + return children(TraversalOrder.POST_ORDER); + } + + /** + * Returns a stream of {@link BaseNavigableExpr} collected from its immediate children using the + * specified traversal order. + */ + public > Stream children(TraversalOrder traversalOrder) { + return CelNavigableExprVisitor.collect((T) this, this.depth() + 1, traversalOrder) + .filter(node -> node.depth() > this.depth()); + } + + /** Returns the underlying kind of the {@link CelExpr}. */ + public ExprKind.Kind getKind() { + return expr().getKind(); + } + + public abstract > Builder builderFromInstance(); + + interface Builder> { + + E expr(); + + int depth(); + + default ExprKind.Kind getKind() { + return expr().getKind(); + } + + @CanIgnoreReturnValue + Builder setExpr(E value); + + @CanIgnoreReturnValue + Builder setParent(T value); + + @CanIgnoreReturnValue + Builder setDepth(int value); + + @CanIgnoreReturnValue + Builder setHeight(int value); + + @CanIgnoreReturnValue + Builder setMaxId(long value); + + @CheckReturnValue + T build(); + } +} diff --git a/common/src/main/java/dev/cel/common/navigation/CelNavigableAst.java b/common/src/main/java/dev/cel/common/navigation/CelNavigableAst.java new file mode 100644 index 000000000..3fe4f558a --- /dev/null +++ b/common/src/main/java/dev/cel/common/navigation/CelNavigableAst.java @@ -0,0 +1,46 @@ +// Copyright 2023 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.navigation; + +import dev.cel.common.CelAbstractSyntaxTree; + +/** + * Decorates a {@link CelAbstractSyntaxTree} with navigational properties. This allows us to visit a + * node's children, descendants or its parent with ease. + */ +public final class CelNavigableAst { + private final CelAbstractSyntaxTree ast; + private final CelNavigableExpr root; + + private CelNavigableAst(CelAbstractSyntaxTree ast) { + this.ast = ast; + this.root = CelNavigableExpr.fromExpr(ast.getExpr()); + } + + /** Constructs a new instance of {@link CelNavigableAst} from {@link CelAbstractSyntaxTree}. */ + public static CelNavigableAst fromAst(CelAbstractSyntaxTree ast) { + return new CelNavigableAst(ast); + } + + /** Returns the root of the AST. */ + public CelNavigableExpr getRoot() { + return root; + } + + /** Returns the underlying {@link CelAbstractSyntaxTree}. */ + public CelAbstractSyntaxTree getAst() { + return ast; + } +} diff --git a/common/src/main/java/dev/cel/common/navigation/CelNavigableExpr.java b/common/src/main/java/dev/cel/common/navigation/CelNavigableExpr.java new file mode 100644 index 000000000..69453b900 --- /dev/null +++ b/common/src/main/java/dev/cel/common/navigation/CelNavigableExpr.java @@ -0,0 +1,110 @@ +// Copyright 2023 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.navigation; + +import com.google.auto.value.AutoValue; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.navigation.ExprPropertyCalculator.ExprProperty; +import java.util.Optional; +import java.util.stream.Stream; + +/** + * CelNavigableExpr decorates {@link CelExpr} with capabilities to inspect the parent and its + * descendants with ease. + */ +@AutoValue +// unchecked: Generic types are properly bound to BaseNavigableExpr +// redundant override: Overriding is required to specify the return type to a concrete type. +@SuppressWarnings({"unchecked", "RedundantOverride"}) +public abstract class CelNavigableExpr extends BaseNavigableExpr { + + /** Constructs a new instance of {@link CelNavigableExpr} from {@link CelExpr}. */ + public static CelNavigableExpr fromExpr(CelExpr expr) { + ExprPropertyCalculator exprHeightCalculator = new ExprPropertyCalculator<>(expr); + ExprProperty exprProperty = exprHeightCalculator.getProperty(expr.id()); + + return builder() + .setExpr(expr) + .setHeight(exprProperty.height()) + .setMaxId(exprProperty.maxId()) + .build(); + } + + @Override + public Stream allNodes() { + return super.allNodes(); + } + + @Override + public Stream allNodes(TraversalOrder traversalOrder) { + return super.allNodes(traversalOrder); + } + + @Override + public abstract Optional parent(); + + @Override + public Stream descendants() { + return super.descendants(); + } + + @Override + public Stream descendants(TraversalOrder traversalOrder) { + return super.descendants(traversalOrder); + } + + @Override + public Stream children() { + return super.children(); + } + + @Override + public Stream children(TraversalOrder traversalOrder) { + return super.children(traversalOrder); + } + + @Override + public Builder builderFromInstance() { + return builder(); + } + + /** Create a new builder to construct a {@link CelNavigableExpr} instance. */ + public static Builder builder() { + return new AutoValue_CelNavigableExpr.Builder().setDepth(0).setHeight(0).setMaxId(0); + } + + /** Builder to configure {@link CelNavigableExpr}. */ + @AutoValue.Builder + public abstract static class Builder + implements BaseNavigableExpr.Builder { + + @Override + public abstract Builder setParent(CelNavigableExpr value); + + @Override + public abstract Builder setExpr(CelExpr value); + + @Override + public abstract Builder setDepth(int value); + + @Override + public abstract Builder setMaxId(long value); + + @Override + public abstract Builder setHeight(int value); + } + + public abstract Builder toBuilder(); +} diff --git a/common/src/main/java/dev/cel/common/navigation/CelNavigableExprVisitor.java b/common/src/main/java/dev/cel/common/navigation/CelNavigableExprVisitor.java new file mode 100644 index 000000000..c8eb57d53 --- /dev/null +++ b/common/src/main/java/dev/cel/common/navigation/CelNavigableExprVisitor.java @@ -0,0 +1,191 @@ +// Copyright 2023 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.navigation; + +import dev.cel.common.ast.Expression; +import dev.cel.common.ast.Expression.List; +import dev.cel.common.navigation.ExprPropertyCalculator.ExprProperty; +import java.util.stream.Stream; + +/** Visitor implementation to navigate an AST. */ +final class CelNavigableExprVisitor> { + private static final int MAX_DESCENDANTS_RECURSION_DEPTH = 500; + + private final Stream.Builder streamBuilder; + private final ExprPropertyCalculator exprPropertyCalculator; + private final TraversalOrder traversalOrder; + private final int maxDepth; + + private CelNavigableExprVisitor( + int maxDepth, + ExprPropertyCalculator exprPropertyCalculator, + TraversalOrder traversalOrder) { + this.maxDepth = maxDepth; + this.exprPropertyCalculator = exprPropertyCalculator; + this.traversalOrder = traversalOrder; + this.streamBuilder = Stream.builder(); + } + + /** + * Returns a stream containing all the nodes using the specified traversal order. Note that the + * collection occurs eagerly. + * + * 

+   * For example, given the following tree:
+   *             a
+   *          b     c
+   *       d    e
+   *
+   * The collected nodes are as follows using pre-order traversal:
+   *
+   * maxDepth of -1: none
+   * maxDepth of 0: a
+   * maxDepth of 1: a, b, c
+   * maxDepth of 2: a, b, d, e, c
+   *
+ */ + static > Stream collect( + T navigableExpr, TraversalOrder traversalOrder) { + return collect(navigableExpr, MAX_DESCENDANTS_RECURSION_DEPTH, traversalOrder); + } + + /** + * Returns a stream containing all the nodes upto the maximum depth specified using the specified + * traversal order. Note that the collection occurs eagerly. + * + * 
+   * For example, given the following tree:
+   *             a
+   *          b     c
+   *       d    e
+   *
+   * The collected nodes are as follows using pre-order traversal:
+   *
+   * maxDepth of -1: none
+   * maxDepth of 0: a
+   * maxDepth of 1: a, b, c
+   * maxDepth of 2: a, b, d, e, c
+   *
+ */ + static > Stream collect( + T navigableExpr, int maxDepth, TraversalOrder traversalOrder) { + ExprPropertyCalculator exprHeightCalculator = + new ExprPropertyCalculator<>(navigableExpr.expr()); + CelNavigableExprVisitor visitor = + new CelNavigableExprVisitor<>(maxDepth, exprHeightCalculator, traversalOrder); + + visitor.visit(navigableExpr); + + return visitor.streamBuilder.build(); + } + + private void visit(T navigableExpr) { + if (navigableExpr.depth() > MAX_DESCENDANTS_RECURSION_DEPTH - 1) { + throw new IllegalStateException("Max recursion depth reached."); + } + + boolean addToStream = navigableExpr.depth() <= maxDepth; + if (addToStream && traversalOrder.equals(TraversalOrder.PRE_ORDER)) { + streamBuilder.add(navigableExpr); + } + + switch (navigableExpr.getKind()) { + case CALL: + visit(navigableExpr, navigableExpr.expr().call()); + break; + case LIST: + visit(navigableExpr, navigableExpr.expr().list()); + break; + case SELECT: + visit(navigableExpr, navigableExpr.expr().select()); + break; + case STRUCT: + visitStruct(navigableExpr, navigableExpr.expr().struct()); + break; + case MAP: + visitMap(navigableExpr, navigableExpr.expr().map()); + break; + case COMPREHENSION: + visit(navigableExpr, navigableExpr.expr().comprehension()); + break; + default: + break; + } + + if (addToStream && traversalOrder.equals(TraversalOrder.POST_ORDER)) { + streamBuilder.add(navigableExpr); + } + } + + private void visit(T navigableExpr, Expression.Call call) { + if (call.target().isPresent()) { + visit(newNavigableChild(navigableExpr, call.target().get())); + } + + visitExprList(call.args(), navigableExpr); + } + + private void visit(T navigableExpr, List list) { + visitExprList(list.elements(), navigableExpr); + } + + private void visit(T navigableExpr, Expression.Select selectExpr) { + T operand = newNavigableChild(navigableExpr, selectExpr.operand()); + visit(operand); + } + + private void visit(T navigableExpr, Expression.Comprehension comprehension) { + visit(newNavigableChild(navigableExpr, comprehension.iterRange())); + visit(newNavigableChild(navigableExpr, comprehension.accuInit())); + visit(newNavigableChild(navigableExpr, comprehension.loopCondition())); + visit(newNavigableChild(navigableExpr, comprehension.loopStep())); + visit(newNavigableChild(navigableExpr, comprehension.result())); + } + + private void visitStruct(T navigableExpr, Expression.Struct> struct) { + for (Expression.Struct.Entry entry : struct.entries()) { + visit(newNavigableChild(navigableExpr, entry.value())); + } + } + + private void visitMap(T navigableExpr, Expression.Map> map) { + for (Expression.Map.Entry entry : map.entries()) { + T key = newNavigableChild(navigableExpr, entry.key()); + visit(key); + + T value = newNavigableChild(navigableExpr, entry.value()); + visit(value); + } + } + + private void visitExprList(java.util.List list, T parent) { + for (E expr : list) { + visit(newNavigableChild(parent, expr)); + } + } + + private T newNavigableChild(T parent, E expr) { + ExprProperty exprProperty = exprPropertyCalculator.getProperty(expr.id()); + + return parent + .builderFromInstance() + .setExpr(expr) + .setDepth(parent.depth() + 1) + .setHeight(exprProperty.height()) + .setMaxId(exprProperty.maxId()) + .setParent(parent) + .build(); + } +} diff --git a/common/src/main/java/dev/cel/common/navigation/CelNavigableMutableAst.java b/common/src/main/java/dev/cel/common/navigation/CelNavigableMutableAst.java new file mode 100644 index 000000000..70d33ab41 --- /dev/null +++ b/common/src/main/java/dev/cel/common/navigation/CelNavigableMutableAst.java @@ -0,0 +1,60 @@ +// Copyright 2024 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.navigation; + +import dev.cel.common.CelMutableAst; +import dev.cel.common.types.CelType; +import java.util.Optional; + +/** + * Decorates a {@link CelMutableAst} with navigational properties. This allows us to visit a node's + * children, descendants or its parent with ease. + */ +public final class CelNavigableMutableAst { + + private final CelMutableAst ast; + private final CelNavigableMutableExpr root; + + private CelNavigableMutableAst(CelMutableAst mutableAst) { + this.ast = mutableAst; + this.root = CelNavigableMutableExpr.fromExpr(mutableAst.expr()); + } + + /** Constructs a new instance of {@link CelNavigableMutableAst} from {@link CelMutableAst}. */ + public static CelNavigableMutableAst fromAst(CelMutableAst ast) { + return new CelNavigableMutableAst(ast); + } + + /** Returns the root of the AST. */ + public CelNavigableMutableExpr getRoot() { + return root; + } + + /** Returns the underlying {@link CelMutableAst}. */ + public CelMutableAst getAst() { + return ast; + } + + /** + * Returns the type of the expression node for a type-checked AST. This simply proxies down the + * call to {@link CelMutableAst#getType(long)}. + * + * @return Optional of {@link CelType} or {@link Optional#empty} if the type does not exist at the + * ID. + */ + public Optional getType(long exprId) { + return ast.getType(exprId); + } +} diff --git a/common/src/main/java/dev/cel/common/navigation/CelNavigableMutableExpr.java b/common/src/main/java/dev/cel/common/navigation/CelNavigableMutableExpr.java new file mode 100644 index 000000000..b9af67675 --- /dev/null +++ b/common/src/main/java/dev/cel/common/navigation/CelNavigableMutableExpr.java @@ -0,0 +1,109 @@ +// Copyright 2024 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.navigation; + +import com.google.auto.value.AutoValue; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.navigation.ExprPropertyCalculator.ExprProperty; +import java.util.Optional; +import java.util.stream.Stream; + +/** + * CelNavigableMutableExpr decorates {@link CelMutableExpr} with capabilities to inspect the parent + * and its descendants with ease. + */ +@AutoValue +// unchecked: Generic types are properly bound to BaseNavigableExpr +// redundant override: Overriding is required to specify the return type to a concrete type. +@SuppressWarnings({"unchecked", "RedundantOverride"}) +public abstract class CelNavigableMutableExpr extends BaseNavigableExpr { + + /** Constructs a new instance of {@link CelNavigableMutableExpr} from {@link CelMutableExpr}. */ + public static CelNavigableMutableExpr fromExpr(CelMutableExpr expr) { + ExprPropertyCalculator exprHeightCalculator = + new ExprPropertyCalculator<>(expr); + ExprProperty exprProperty = exprHeightCalculator.getProperty(expr.id()); + + return builder() + .setExpr(expr) + .setHeight(exprProperty.height()) + .setMaxId(exprProperty.maxId()) + .build(); + } + + @Override + public Stream allNodes() { + return super.allNodes(); + } + + @Override + public Stream allNodes(TraversalOrder traversalOrder) { + return super.allNodes(traversalOrder); + } + + @Override + public abstract Optional parent(); + + @Override + public Stream descendants() { + return super.descendants(); + } + + @Override + public Stream descendants(TraversalOrder traversalOrder) { + return super.descendants(traversalOrder); + } + + @Override + public Stream children() { + return super.children(); + } + + @Override + public Stream children(TraversalOrder traversalOrder) { + return super.children(traversalOrder); + } + + @Override + public Builder builderFromInstance() { + return builder(); + } + + /** Create a new builder to construct a {@link CelNavigableExpr} instance. */ + public static CelNavigableMutableExpr.Builder builder() { + return new AutoValue_CelNavigableMutableExpr.Builder().setDepth(0).setHeight(0).setMaxId(0); + } + + /** Builder to configure {@link CelNavigableExpr}. */ + @AutoValue.Builder + public abstract static class Builder + implements BaseNavigableExpr.Builder { + + @Override + public abstract Builder setParent(CelNavigableMutableExpr value); + + @Override + public abstract Builder setExpr(CelMutableExpr value); + + @Override + public abstract Builder setDepth(int value); + + @Override + public abstract Builder setMaxId(long value); + + @Override + public abstract Builder setHeight(int value); + } +} diff --git a/common/src/main/java/dev/cel/common/navigation/ExprPropertyCalculator.java b/common/src/main/java/dev/cel/common/navigation/ExprPropertyCalculator.java new file mode 100644 index 000000000..be2c07221 --- /dev/null +++ b/common/src/main/java/dev/cel/common/navigation/ExprPropertyCalculator.java @@ -0,0 +1,156 @@ +// Copyright 2024 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.navigation; + +import static java.lang.Math.max; + +import com.google.auto.value.AutoValue; +import dev.cel.common.ast.Expression; +import dev.cel.common.ast.Expression.List; +import dev.cel.common.ast.Expression.Map; +import dev.cel.common.ast.Expression.Struct; +import java.util.HashMap; + +/** Package-private class to assist computing the height and the max ID of expression nodes. */ +final class ExprPropertyCalculator { + // Store hashmap instead of immutable map for performance, such that this helper class can be + // instantiated faster. + private final HashMap idToProperty; + + ExprPropertyCalculator(E celExpr) { + this.idToProperty = new HashMap<>(); + visit(celExpr); + } + + /** + * Retrieves the property containing the expression's maximum ID and the height of the subtree. + * + * @throws IllegalArgumentException If the provided expression ID does not exist. + */ + ExprProperty getProperty(Long exprId) { + if (!idToProperty.containsKey(exprId)) { + throw new IllegalArgumentException("Property not found for expression id: " + exprId); + } + + return idToProperty.get(exprId); + } + + private ExprProperty visit(E expr) { + int baseHeight = 1; + ExprProperty visitedProperty; + switch (expr.getKind()) { + case CALL: + visitedProperty = visit(expr.call()); + break; + case LIST: + visitedProperty = visit(expr.list()); + break; + case SELECT: + visitedProperty = visit(expr.select()); + break; + case STRUCT: + visitedProperty = visitStruct(expr.struct()); + break; + case MAP: + visitedProperty = visitMap(expr.map()); + break; + case COMPREHENSION: + visitedProperty = visit(expr.comprehension()); + break; + default: + // This is a leaf node + baseHeight = 0; + visitedProperty = ExprProperty.create(baseHeight, expr.id()); + break; + } + + ExprProperty exprProperty = + ExprProperty.create( + baseHeight + visitedProperty.height(), max(visitedProperty.maxId(), expr.id())); + idToProperty.put(expr.id(), exprProperty); + + return exprProperty; + } + + private ExprProperty visit(Expression.Call call) { + ExprProperty visitedTarget = ExprProperty.create(0, 0); + if (call.target().isPresent()) { + visitedTarget = visit(call.target().get()); + } + + ExprProperty visitedArgument = visitExprList(call.args()); + return ExprProperty.merge(visitedArgument, visitedTarget); + } + + private ExprProperty visit(List list) { + return visitExprList(list.elements()); + } + + private ExprProperty visit(Expression.Select selectExpr) { + return visit(selectExpr.operand()); + } + + private ExprProperty visit(Expression.Comprehension comprehension) { + ExprProperty visitedProperty = visit(comprehension.iterRange()); + visitedProperty = ExprProperty.merge(visitedProperty, visit(comprehension.accuInit())); + visitedProperty = ExprProperty.merge(visitedProperty, visit(comprehension.loopCondition())); + visitedProperty = ExprProperty.merge(visitedProperty, visit(comprehension.loopStep())); + visitedProperty = ExprProperty.merge(visitedProperty, visit(comprehension.result())); + + return visitedProperty; + } + + private ExprProperty visitStruct(Expression.Struct> struct) { + ExprProperty visitedProperty = ExprProperty.create(0, 0); + for (Struct.Entry entry : struct.entries()) { + visitedProperty = ExprProperty.merge(visitedProperty, visit(entry.value())); + } + return visitedProperty; + } + + private ExprProperty visitMap(Expression.Map> map) { + ExprProperty visitedProperty = ExprProperty.create(0, 0); + for (Map.Entry entry : map.entries()) { + visitedProperty = ExprProperty.merge(visitedProperty, visit(entry.key())); + visitedProperty = ExprProperty.merge(visitedProperty, visit(entry.value())); + } + return visitedProperty; + } + + private ExprProperty visitExprList(java.util.List list) { + ExprProperty visitedProperty = ExprProperty.create(0, 0); + for (E expr : list) { + visitedProperty = ExprProperty.merge(visitedProperty, visit(expr)); + } + return visitedProperty; + } + + /** Value class to store the height and the max ID at a specific expression ID. */ + @AutoValue + abstract static class ExprProperty { + abstract int height(); + + abstract long maxId(); + + /** Merges the two {@link ExprProperty}, taking their maximum values from the properties. */ + private static ExprProperty merge(ExprProperty e1, ExprProperty e2) { + return create(max(e1.height(), e2.height()), max(e1.maxId(), e2.maxId())); + } + + private static ExprProperty create(int height, long maxId) { + return new AutoValue_ExprPropertyCalculator_ExprProperty(height, maxId); + } + } +} diff --git a/common/src/main/java/dev/cel/common/navigation/TraversalOrder.java b/common/src/main/java/dev/cel/common/navigation/TraversalOrder.java new file mode 100644 index 000000000..80aafbf74 --- /dev/null +++ b/common/src/main/java/dev/cel/common/navigation/TraversalOrder.java @@ -0,0 +1,37 @@ +// Copyright 2024 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.navigation; + +import dev.cel.common.ast.CelExpr.CelComprehension; + +/** + * Specifies the traversal order of AST navigation. + * + *

For call expressions, the target is visited before its arguments. + * + *

For comprehensions, the visiting order is as follows: + * + *

    + *
  1. {@link CelComprehension#iterRange} + *
  2. {@link CelComprehension#accuInit} + *
  3. {@link CelComprehension#loopCondition} + *
  4. {@link CelComprehension#loopStep} + *
  5. {@link CelComprehension#result} + *
+ */ +public enum TraversalOrder { + PRE_ORDER, + POST_ORDER +} diff --git a/common/src/main/java/dev/cel/common/testing/BUILD.bazel b/common/src/main/java/dev/cel/common/testing/BUILD.bazel new file mode 100644 index 000000000..574638e35 --- /dev/null +++ b/common/src/main/java/dev/cel/common/testing/BUILD.bazel @@ -0,0 +1,23 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//common/testing:__pkg__", + ], +) + +java_library( + name = "testing", + srcs = [ + "RepeatedTestProvider.java", + ], + deps = [ + "//common/annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + ], +) diff --git a/common/src/main/java/dev/cel/common/testing/RepeatedTestProvider.java b/common/src/main/java/dev/cel/common/testing/RepeatedTestProvider.java new file mode 100644 index 000000000..974c504b7 --- /dev/null +++ b/common/src/main/java/dev/cel/common/testing/RepeatedTestProvider.java @@ -0,0 +1,44 @@ +// Copyright 2022 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.testing; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; +import com.google.testing.junit.testparameterinjector.TestParameterValuesProvider; +import dev.cel.common.annotations.Internal; +import java.util.stream.IntStream; + +/** + * A simple test provider for repeating a test {@link #REPEATED_TEST_RUN_COUNT} times. To use: + * + *
    + *
  1. Annotate your test class with @RunWith(TestParameterInjector.class) + *
  2. Provide a @TestParameter as an argument with RepeatedTestProvider set as the + * valuesProvider. (Example: @TestParameter(valuesProvider = RepeatedTestProvider.class) int + * testRunIndex) + *
+ */ +@Internal +@VisibleForTesting +public final class RepeatedTestProvider extends TestParameterValuesProvider { + private static final int REPEATED_TEST_RUN_COUNT = 50; + + @Override + public ImmutableList provideValues(Context context) { + return IntStream.rangeClosed(1, REPEATED_TEST_RUN_COUNT).boxed().collect(toImmutableList()); + } +} diff --git a/common/src/main/java/dev/cel/common/types/BUILD.bazel b/common/src/main/java/dev/cel/common/types/BUILD.bazel new file mode 100644 index 000000000..de65d0b1f --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/BUILD.bazel @@ -0,0 +1,264 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//common/types:__pkg__", + "//publish:__pkg__", + ], +) + +# Collection of CEL type implementations and type-inference related classes. + +# keep sorted +CEL_TYPE_SOURCES = [ + "EnumType.java", + "ListType.java", + "MapType.java", + "NullableType.java", + "OpaqueType.java", + "OptionalType.java", + "ProtoMessageType.java", + "SimpleType.java", + "StructType.java", + "StructTypeReference.java", + "TypeParamType.java", + "TypeType.java", +] + +# keep sorted +CEL_INTERNAL_TYPE_SOURCES = [ + "UnspecifiedType.java", +] + +# keep sorted +CEL_TYPE_PROVIDER_SOURCES = [ + "CelKind.java", + "CelType.java", + "CelTypeProvider.java", +] + +java_library( + name = "types", + srcs = CEL_TYPE_SOURCES, + tags = [ + ], + deps = [ + ":type_providers", + "//:auto_value", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "cel_internal_types", + srcs = CEL_INTERNAL_TYPE_SOURCES, + deps = [ + ":type_providers", + "//:auto_value", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "cel_types", + srcs = ["CelTypes.java"], + tags = [ + ], + deps = [ + ":type_providers", + ":types", + "//common/annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "cel_proto_types", + srcs = ["CelProtoTypes.java"], + tags = [ + ], + deps = [ + ":cel_internal_types", + ":cel_types", + ":type_providers", + ":types", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "cel_proto_types_android", + srcs = ["CelProtoTypes.java"], + tags = [ + ], + deps = [ + ":cel_internal_types_android", + ":cel_types_android", + ":type_providers_android", + ":types_android", + "@cel_spec//proto/cel/expr:checked_java_proto_lite", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "cel_proto_message_types", + srcs = ["CelProtoMessageTypes.java"], + tags = [ + ], + deps = [ + ":cel_proto_types", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "cel_v1alpha1_types", + srcs = ["CelV1AlphaTypes.java"], + tags = [ + ], + deps = [ + ":type_providers", + ":types", + "//common/annotations", + "@com_google_googleapis//google/api/expr/v1alpha1:expr_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "json", + srcs = ["JsonType.java"], + tags = [ + ], + deps = [ + ":type_providers", + ":types", + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "type_providers", + srcs = CEL_TYPE_PROVIDER_SOURCES, + tags = [ + ], + deps = [ + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "message_type_provider", + srcs = [ + "ProtoMessageTypeProvider.java", + ], + tags = [ + ], + deps = [ + ":cel_types", + ":type_providers", + ":types", + "//:auto_value", + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "//common/internal:file_descriptor_converter", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "default_type_provider", + srcs = [ + "DefaultTypeProvider.java", + ], + tags = [ + ], + deps = [ + ":type_providers", + ":types", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "default_type_provider_android", + srcs = [ + "DefaultTypeProvider.java", + ], + tags = [ + ], + deps = [ + ":type_providers_android", + ":types_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "cel_types_android", + srcs = ["CelTypes.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/types:type_providers_android", + "//common/types:types_android", + "@maven_android//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "type_providers_android", + srcs = CEL_TYPE_PROVIDER_SOURCES, + tags = [ + ], + deps = [ + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "types_android", + srcs = CEL_TYPE_SOURCES, + tags = [ + ], + deps = [ + ":type_providers_android", + "//:auto_value", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "cel_internal_types_android", + srcs = CEL_INTERNAL_TYPE_SOURCES, + deps = [ + "//:auto_value", + "//common/annotations", + "//common/types:type_providers_android", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) diff --git a/common/src/main/java/dev/cel/common/types/CelKind.java b/common/src/main/java/dev/cel/common/types/CelKind.java new file mode 100644 index 000000000..7d55ddaf1 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/CelKind.java @@ -0,0 +1,67 @@ +// Copyright 2022 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.types; + +import com.google.errorprone.annotations.CheckReturnValue; + +/** + * The {@code CelKind} indicates the type category. + * + *

In most cases, the type category maps to a well-defined CEL type, but there are a handful of + * types which are either internal or used to extend the type set natively understood by CEL. + */ +@CheckReturnValue +public enum CelKind { + UNSPECIFIED, + ERROR, + DYN, + ANY, + BOOL, + BYTES, + DOUBLE, + DURATION, + INT, + LIST, + MAP, + NULL_TYPE, + OPAQUE, + STRING, + STRUCT, + TIMESTAMP, + TYPE, + TYPE_PARAM, + UINT; + + public boolean isDyn() { + return this == DYN || this == ANY; + } + + public boolean isTypeParam() { + return this == TYPE_PARAM; + } + + public boolean isError() { + return this == ERROR; + } + + public boolean isPrimitive() { + return this == BOOL + || this == INT + || this == UINT + || this == DOUBLE + || this == STRING + || this == BYTES; + } +} diff --git a/common/src/main/java/dev/cel/common/types/CelProtoMessageTypes.java b/common/src/main/java/dev/cel/common/types/CelProtoMessageTypes.java new file mode 100644 index 000000000..108305e13 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/CelProtoMessageTypes.java @@ -0,0 +1,32 @@ +// Copyright 2025 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.types; + +import dev.cel.expr.Type; +import com.google.protobuf.Descriptors.Descriptor; + +/** + * Utility class for working with {@link Type} that require a full protobuf dependency (i.e: + * descriptors). + */ +public final class CelProtoMessageTypes { + + /** Create a message {@code Type} for {@code Descriptor}. */ + public static Type createMessage(Descriptor descriptor) { + return CelProtoTypes.createMessage(descriptor.getFullName()); + } + + private CelProtoMessageTypes() {} +} diff --git a/common/src/main/java/dev/cel/common/types/CelProtoTypes.java b/common/src/main/java/dev/cel/common/types/CelProtoTypes.java new file mode 100644 index 000000000..feddb02db --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/CelProtoTypes.java @@ -0,0 +1,275 @@ +// Copyright 2024 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.types; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import dev.cel.expr.Type; +import dev.cel.expr.Type.AbstractType; +import dev.cel.expr.Type.PrimitiveType; +import dev.cel.expr.Type.WellKnownType; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Empty; +import com.google.protobuf.NullValue; + +/** + * Utility class for working with {@link Type}. + * + *

This is equivalent to {@link CelTypes}, except this works specifically with canonical CEL expr + * protos. + */ +public final class CelProtoTypes { + + public static final Type ERROR = Type.newBuilder().setError(Empty.getDefaultInstance()).build(); + public static final Type DYN = Type.newBuilder().setDyn(Empty.getDefaultInstance()).build(); + public static final Type NULL_TYPE = Type.newBuilder().setNull(NullValue.NULL_VALUE).build(); + public static final Type BOOL = create(PrimitiveType.BOOL); + public static final Type BYTES = create(PrimitiveType.BYTES); + public static final Type STRING = create(PrimitiveType.STRING); + public static final Type DOUBLE = create(PrimitiveType.DOUBLE); + public static final Type UINT64 = create(PrimitiveType.UINT64); + public static final Type INT64 = create(PrimitiveType.INT64); + public static final Type ANY = create(WellKnownType.ANY); + public static final Type TIMESTAMP = create(WellKnownType.TIMESTAMP); + public static final Type DURATION = create(WellKnownType.DURATION); + + private static final ImmutableMap SIMPLE_CEL_KIND_TO_TYPE = + ImmutableMap.builder() + .put(CelKind.ERROR, ERROR) + .put(CelKind.DYN, DYN) + .put(CelKind.ANY, ANY) + .put(CelKind.BOOL, BOOL) + .put(CelKind.BYTES, BYTES) + .put(CelKind.DOUBLE, DOUBLE) + .put(CelKind.DURATION, DURATION) + .put(CelKind.INT, INT64) + .put(CelKind.NULL_TYPE, NULL_TYPE) + .put(CelKind.STRING, STRING) + .put(CelKind.TIMESTAMP, TIMESTAMP) + .put(CelKind.UINT, UINT64) + .buildOrThrow(); + + private static final ImmutableMap PROTOBUF_TYPE_TO_CEL_TYPE_MAP = + ImmutableMap.builder() + .put(BOOL, SimpleType.BOOL) + .put(BYTES, SimpleType.BYTES) + .put(DOUBLE, SimpleType.DOUBLE) + .put(INT64, SimpleType.INT) + .put(STRING, SimpleType.STRING) + .put(UINT64, SimpleType.UINT) + .put(ANY, SimpleType.ANY) + .put(DURATION, SimpleType.DURATION) + .put(TIMESTAMP, SimpleType.TIMESTAMP) + .put(DYN, SimpleType.DYN) + .put(NULL_TYPE, SimpleType.NULL_TYPE) + .put(ERROR, SimpleType.ERROR) + .buildOrThrow(); + + /** Create a primitive {@code Type}. */ + public static Type create(PrimitiveType type) { + return Type.newBuilder().setPrimitive(type).build(); + } + + /** Create a well-known {@code Type}. */ + public static Type create(WellKnownType type) { + return Type.newBuilder().setWellKnown(type).build(); + } + + /** Create a type {@code Type}. */ + public static Type create(Type target) { + return Type.newBuilder().setType(target).build(); + } + + /** Create a list with {@code elemType}. */ + public static Type createList(Type elemType) { + return Type.newBuilder().setListType(Type.ListType.newBuilder().setElemType(elemType)).build(); + } + + /** Create a map with {@code keyType} and {@code valueType}. */ + public static Type createMap(Type keyType, Type valueType) { + return Type.newBuilder() + .setMapType(Type.MapType.newBuilder().setKeyType(keyType).setValueType(valueType)) + .build(); + } + + /** Create a message {@code Type} for {@code messageName}. */ + public static Type createMessage(String messageName) { + return Type.newBuilder().setMessageType(messageName).build(); + } + + /** Create a type param {@code Type}. */ + public static Type createTypeParam(String name) { + return Type.newBuilder().setTypeParam(name).build(); + } + + /** Create a wrapper type for the {@code primitive}. */ + public static Type createWrapper(PrimitiveType primitive) { + return Type.newBuilder().setWrapper(primitive).build(); + } + + /** Create a wrapper type where the input is a {@code Type} of primitive types. */ + public static Type createWrapper(Type type) { + Preconditions.checkArgument(type.getTypeKindCase() == Type.TypeKindCase.PRIMITIVE); + return createWrapper(type.getPrimitive()); + } + + /** + * Create an abstract type indicating that the parameterized type may be contained within the + * object. + */ + public static Type createOptionalType(Type paramType) { + return Type.newBuilder() + .setAbstractType( + AbstractType.newBuilder() + .setName(OptionalType.NAME) + .addParameterTypes(paramType) + .build()) + .build(); + } + + /** Checks if the provided parameter is an optional type */ + public static boolean isOptionalType(Type type) { + return type.hasAbstractType() && type.getAbstractType().getName().equals(OptionalType.NAME); + } + + /** + * Method to adapt a simple {@code Type} into a {@code String} representation. + * + *

This method can also format global functions. See the {@link CelTypes#formatFunction} + * methods for richer control over function formatting. + */ + public static String format(Type type) { + return CelTypes.format(typeToCelType(type), /* typeParamToDyn= */ false); + } + + /** Converts a Protobuf type into CEL native type. */ + public static Type celTypeToType(CelType celType) { + Type type = SIMPLE_CEL_KIND_TO_TYPE.get(celType.kind()); + if (type != null) { + if (celType instanceof NullableType) { + return createWrapper(type); + } + return type; + } + + switch (celType.kind()) { + case UNSPECIFIED: + return Type.getDefaultInstance(); + case LIST: + ListType listType = (ListType) celType; + if (listType.hasElemType()) { + return createList(celTypeToType(listType.elemType())); + } else { + // TODO: Exists for compatibility reason only. Remove after callers have been + // migrated. + return Type.newBuilder().setListType(Type.ListType.getDefaultInstance()).build(); + } + case MAP: + MapType mapType = (MapType) celType; + return createMap(celTypeToType(mapType.keyType()), celTypeToType(mapType.valueType())); + case OPAQUE: + if (celType.name().equals("function")) { + Type.FunctionType.Builder functionBuilder = Type.FunctionType.newBuilder(); + if (!celType.parameters().isEmpty()) { + functionBuilder + .setResultType(celTypeToType(celType.parameters().get(0))) + .addAllArgTypes( + celType.parameters().stream() + .skip(1) + .map(CelProtoTypes::celTypeToType) + .collect(toImmutableList())); + } + return Type.newBuilder().setFunction(functionBuilder).build(); + } else { + return Type.newBuilder() + .setAbstractType( + Type.AbstractType.newBuilder() + .setName(celType.name()) + .addAllParameterTypes( + celType.parameters().stream() + .map(CelProtoTypes::celTypeToType) + .collect(toImmutableList()))) + .build(); + } + case STRUCT: + return createMessage(celType.name()); + case TYPE: + TypeType typeType = (TypeType) celType; + return create(celTypeToType(typeType.type())); + case TYPE_PARAM: + return createTypeParam(celType.name()); + default: + throw new IllegalArgumentException(String.format("Unsupported type: %s", celType)); + } + } + + /** Converts a Protobuf type to CEL native type. */ + public static CelType typeToCelType(Type type) { + CelType celType = PROTOBUF_TYPE_TO_CEL_TYPE_MAP.get(type); + if (celType != null) { + return celType; + } + + switch (type.getTypeKindCase()) { + case TYPEKIND_NOT_SET: + return UnspecifiedType.create(); + case WRAPPER: + return NullableType.create(typeToCelType(create(type.getWrapper()))); + case MESSAGE_TYPE: + return StructTypeReference.create(type.getMessageType()); + case LIST_TYPE: + Type.ListType listType = type.getListType(); + if (listType.hasElemType()) { + return ListType.create(typeToCelType(listType.getElemType())); + } else { + // TODO: Exists for compatibility reason only. Remove after callers have been + // migrated. + return ListType.create(); + } + case MAP_TYPE: + Type.MapType mapType = type.getMapType(); + return MapType.create( + typeToCelType(mapType.getKeyType()), typeToCelType(mapType.getValueType())); + case TYPE_PARAM: + return TypeParamType.create(type.getTypeParam()); + case ABSTRACT_TYPE: + Type.AbstractType abstractType = type.getAbstractType(); + ImmutableList params = + abstractType.getParameterTypesList().stream() + .map(CelProtoTypes::typeToCelType) + .collect(toImmutableList()); + if (abstractType.getName().equals(OptionalType.NAME)) { + return OptionalType.create(params.get(0)); + } + return OpaqueType.create(abstractType.getName(), params); + case TYPE: + return TypeType.create(typeToCelType(type.getType())); + case FUNCTION: + Type.FunctionType functionType = type.getFunction(); + return CelTypes.createFunctionType( + typeToCelType(functionType.getResultType()), + functionType.getArgTypesList().stream() + .map(CelProtoTypes::typeToCelType) + .collect(toImmutableList())); + default: + // Add more cases as needed. + throw new IllegalArgumentException(String.format("Unsupported type: %s", type)); + } + } + + private CelProtoTypes() {} +} diff --git a/common/src/main/java/dev/cel/common/types/CelType.java b/common/src/main/java/dev/cel/common/types/CelType.java new file mode 100644 index 000000000..d75d682c0 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/CelType.java @@ -0,0 +1,88 @@ +// Copyright 2022 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.types; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.function.Function; + +/** + * Abstract representation of a CEL type which indicates its {@code CelKind}, {@code name}, and + * {@code parameters}. + * + *

Each type also exposes functions to generate a copy of the type containing fresh type + * variables, and a function for generating a new instance of the type with a different set of type + * parameters. These functions are critical for making type inferences. + */ +@Immutable +@CheckReturnValue +public abstract class CelType { + + protected CelType() {} + + /** Return the type {@code CelKind}. */ + public abstract CelKind kind(); + + /** + * Return the type name. + * + *

For struct types this should be the fully qualified name. Be wary of introducing unqualified + * type names as they may collide with future CEL type. + */ + public abstract String name(); + + /** Return the type parameters. e.g. a map's key and value {@code CelType}. */ + public ImmutableList parameters() { + return ImmutableList.of(); + } + + /** + * Determine whether {@code this} type is assignable from the {@code other} type value. + * + *

Defaults to an equality test. + */ + public boolean isAssignableFrom(CelType other) { + return this.equals(other); + } + + /** + * Instantiate a new copy of this type with alternative {@code parameters}. + * + *

If the {@code CelType} does not have any {@code parameters}, then the return value defaults + * to the original type instance. + */ + @CanIgnoreReturnValue + public CelType withParameters(ImmutableList parameters) { + return this; + } + + /** + * Instantiate a new copy of this type with alternative {@code parameters}. + * + *

If the {@code CelType} does not have any {@code parameters}, then the return value defaults + * to the original type instance. + */ + @CanIgnoreReturnValue + public CelType withFreshTypeParamVariables(Function varNameGenerator) { + return withParameters( + parameters().stream() + .map(p -> p.withFreshTypeParamVariables(varNameGenerator)) + .collect(toImmutableList())); + } +} diff --git a/common/src/main/java/dev/cel/common/types/CelTypeProvider.java b/common/src/main/java/dev/cel/common/types/CelTypeProvider.java new file mode 100644 index 000000000..c452a9dee --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/CelTypeProvider.java @@ -0,0 +1,74 @@ +// Copyright 2022 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.types; + +import com.google.common.collect.ImmutableCollection; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Optional; + +/** + * The {@code CelTypeProvider} is used to lookup {@code CelType} definitions by name, as well as + * enumerate supported {@link #types()}. + */ +@CheckReturnValue +@Immutable +public interface CelTypeProvider { + + /** Return the set of {@code CelType} instances supported by this provider. */ + ImmutableCollection types(); + + /** Return the {@code CelType} for the given {@code typeName} if supported. */ + Optional findType(String typeName); + + /** + * The {@code CombinedCelTypeProvider} implements the {@code CelTypeProvider} interface by merging + * the {@code CelType} instances supported by each together. + * + *

If there is more than one {@code CelType} for a given type, the first definition found is + * the one supported in the {@code CombinedCelTypeProvider}. + */ + @Immutable + final class CombinedCelTypeProvider implements CelTypeProvider { + + private final ImmutableMap allTypes; + + public CombinedCelTypeProvider(CelTypeProvider first, CelTypeProvider second) { + this(ImmutableList.of(first, second)); + } + + public CombinedCelTypeProvider(ImmutableList typeProviders) { + Map allTypes = new LinkedHashMap<>(); + typeProviders.forEach( + typeProvider -> + typeProvider.types().forEach(type -> allTypes.putIfAbsent(type.name(), type))); + this.allTypes = ImmutableMap.copyOf(allTypes); + } + + @Override + public ImmutableCollection types() { + return allTypes.values(); + } + + @Override + public Optional findType(String typeName) { + return Optional.ofNullable(allTypes.get(typeName)); + } + } +} diff --git a/common/src/main/java/dev/cel/common/types/CelTypes.java b/common/src/main/java/dev/cel/common/types/CelTypes.java new file mode 100644 index 000000000..34e0fa5ef --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/CelTypes.java @@ -0,0 +1,218 @@ +// Copyright 2022 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.types; + +import com.google.common.base.Joiner; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Iterables; +import dev.cel.common.annotations.Internal; +import java.util.Optional; + +/** Utility class for working with {@code CelType}. */ +public final class CelTypes { + + // Message type names with well-known type equivalents or special handling. + public static final String ANY_MESSAGE = "google.protobuf.Any"; + public static final String DURATION_MESSAGE = "google.protobuf.Duration"; + public static final String LIST_VALUE_MESSAGE = "google.protobuf.ListValue"; + public static final String STRUCT_MESSAGE = "google.protobuf.Struct"; + public static final String TIMESTAMP_MESSAGE = "google.protobuf.Timestamp"; + public static final String VALUE_MESSAGE = "google.protobuf.Value"; + + // Message names for wrapper types. + public static final String BOOL_WRAPPER_MESSAGE = "google.protobuf.BoolValue"; + public static final String BYTES_WRAPPER_MESSAGE = "google.protobuf.BytesValue"; + public static final String DOUBLE_WRAPPER_MESSAGE = "google.protobuf.DoubleValue"; + public static final String FLOAT_WRAPPER_MESSAGE = "google.protobuf.FloatValue"; + public static final String INT32_WRAPPER_MESSAGE = "google.protobuf.Int32Value"; + public static final String INT64_WRAPPER_MESSAGE = "google.protobuf.Int64Value"; + public static final String STRING_WRAPPER_MESSAGE = "google.protobuf.StringValue"; + public static final String UINT32_WRAPPER_MESSAGE = "google.protobuf.UInt32Value"; + public static final String UINT64_WRAPPER_MESSAGE = "google.protobuf.UInt64Value"; + + private static final ImmutableMap WELL_KNOWN_CEL_TYPE_MAP = + ImmutableMap.builder() + .put(BOOL_WRAPPER_MESSAGE, NullableType.create(SimpleType.BOOL)) + .put(BYTES_WRAPPER_MESSAGE, NullableType.create(SimpleType.BYTES)) + .put(FLOAT_WRAPPER_MESSAGE, NullableType.create(SimpleType.DOUBLE)) + .put(DOUBLE_WRAPPER_MESSAGE, NullableType.create(SimpleType.DOUBLE)) + .put(INT32_WRAPPER_MESSAGE, NullableType.create(SimpleType.INT)) + .put(INT64_WRAPPER_MESSAGE, NullableType.create(SimpleType.INT)) + .put(STRING_WRAPPER_MESSAGE, NullableType.create(SimpleType.STRING)) + .put(UINT32_WRAPPER_MESSAGE, NullableType.create(SimpleType.UINT)) + .put(UINT64_WRAPPER_MESSAGE, NullableType.create(SimpleType.UINT)) + .put(ANY_MESSAGE, SimpleType.ANY) + .put(DURATION_MESSAGE, SimpleType.DURATION) + .put(TIMESTAMP_MESSAGE, SimpleType.TIMESTAMP) + .put(LIST_VALUE_MESSAGE, ListType.create(SimpleType.DYN)) + .put(STRUCT_MESSAGE, MapType.create(SimpleType.STRING, SimpleType.DYN)) + .put(VALUE_MESSAGE, SimpleType.DYN) + .buildOrThrow(); + + /** Checks if the fully-qualified protobuf type name is a wrapper type. */ + public static boolean isWrapperType(String typeName) { + switch (typeName) { + case BOOL_WRAPPER_MESSAGE: + case BYTES_WRAPPER_MESSAGE: + case DOUBLE_WRAPPER_MESSAGE: + case FLOAT_WRAPPER_MESSAGE: + case INT32_WRAPPER_MESSAGE: + case INT64_WRAPPER_MESSAGE: + case STRING_WRAPPER_MESSAGE: + case UINT32_WRAPPER_MESSAGE: + case UINT64_WRAPPER_MESSAGE: + return true; + default: + return false; + } + } + + /** + * Create an abstract type with an expected result type (first argument in the parameter) and the + * argument types. + * + *

CEL Library Internals. Do Not Use. + */ + @Internal + public static OpaqueType createFunctionType(CelType resultType, Iterable argumentTypes) { + ImmutableList.Builder arguments = ImmutableList.builder(); + arguments.add(resultType); + arguments.addAll(argumentTypes); + return OpaqueType.create("function", arguments.build()); + } + + /** + * Method to adapt a simple {@code Type} into a {@code String} representation. + * + *

This method can also format global functions. See the {@link #formatFunction} methods for + * richer control over function formatting. + */ + public static String format(CelType type) { + return format(type, /* typeParamToDyn= */ false); + } + + static String format(CelType type, boolean typeParamToDyn) { + if (type instanceof NullableType) { + return String.format( + "wrapper(%s)", format(((NullableType) type).targetType(), typeParamToDyn)); + } + switch (type.kind()) { + case DYN: + return "dyn"; + case NULL_TYPE: + return "null"; + case BOOL: + return "bool"; + case INT: + return "int"; + case UINT: + return "uint"; + case DOUBLE: + return "double"; + case STRING: + return "string"; + case BYTES: + return "bytes"; + case TIMESTAMP: + return "google.protobuf.Timestamp"; + case DURATION: + return "google.protobuf.Duration"; + case ANY: + return "any"; + case LIST: + ListType listType = (ListType) type; + return String.format("list(%s)", format(listType.elemType(), typeParamToDyn)); + case MAP: + MapType mapType = (MapType) type; + return String.format( + "map(%s, %s)", + format(mapType.keyType(), typeParamToDyn), format(mapType.valueType(), typeParamToDyn)); + case TYPE: + TypeType typeType = (TypeType) type; + return String.format("type(%s)", format(typeType.type(), typeParamToDyn)); + case ERROR: + return "*error*"; + case STRUCT: + return type.name(); + case TYPE_PARAM: + return typeParamToDyn ? "dyn" : type.name(); + case OPAQUE: + if (type.name().equals("function")) { + return formatFunction( + type.parameters().get(0), + type.parameters().subList(1, type.parameters().size()), + false, + typeParamToDyn); + } else { + String result = type.name(); + if (!type.parameters().isEmpty()) { + result += formatTypeArgs(type.parameters(), typeParamToDyn); + } + return result; + } + default: + break; + } + return ""; + } + + /** + * Format a function signature string from the input {@code argTypes} and {@code resultType}. + * + *

When {@code isInstance} is {@code true}, the {@code argTypes[0]} type is used as the + * receiver type. + * + *

When {@code resultType} is {@code null}, the function signature omits the result type. This + * is useful for computing overload signatures. + * + *

When {@code typeParamToDyn} is {@code true}, parameterized type argument are represented as + * {@code Types.DYN} values. + */ + public static String formatFunction( + CelType resultType, Iterable argTypes, boolean isInstance, boolean typeParamToDyn) { + String argString; + if (isInstance) { + argString = + format(Iterables.get(argTypes, 0), typeParamToDyn) + + "." + + formatTypeArgs(Iterables.skip(argTypes, 1), typeParamToDyn); + } else { + argString = formatTypeArgs(argTypes, typeParamToDyn); + } + if (resultType == null) { + return argString; + } else { + return argString + " -> " + format(resultType, typeParamToDyn); + } + } + + public static boolean isWellKnownType(String typeName) { + return WELL_KNOWN_CEL_TYPE_MAP.containsKey(typeName); + } + + public static Optional getWellKnownCelType(String typeName) { + return Optional.ofNullable(WELL_KNOWN_CEL_TYPE_MAP.getOrDefault(typeName, null)); + } + + private static String formatTypeArgs(Iterable types, final boolean typeParamToDyn) { + return String.format( + "(%s)", + Joiner.on(", ") + .join(Iterables.transform(types, (CelType type) -> format(type, typeParamToDyn)))); + } + + private CelTypes() {} +} diff --git a/common/src/main/java/dev/cel/common/types/CelV1AlphaTypes.java b/common/src/main/java/dev/cel/common/types/CelV1AlphaTypes.java new file mode 100644 index 000000000..87fe9b6a0 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/CelV1AlphaTypes.java @@ -0,0 +1,401 @@ +// Copyright 2022 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.types; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.api.expr.v1alpha1.Type; +import com.google.api.expr.v1alpha1.Type.PrimitiveType; +import com.google.api.expr.v1alpha1.Type.WellKnownType; +import com.google.common.base.Joiner; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Empty; +import com.google.protobuf.NullValue; +import dev.cel.common.annotations.Internal; +import java.util.Optional; + +/** Utility class for working with {@link Type}. */ +public final class CelV1AlphaTypes { + + // Message type names with well-known type equivalents or special handling. + public static final String ANY_MESSAGE = "google.protobuf.Any"; + public static final String DURATION_MESSAGE = "google.protobuf.Duration"; + public static final String LIST_VALUE_MESSAGE = "google.protobuf.ListValue"; + public static final String STRUCT_MESSAGE = "google.protobuf.Struct"; + public static final String TIMESTAMP_MESSAGE = "google.protobuf.Timestamp"; + public static final String VALUE_MESSAGE = "google.protobuf.Value"; + + // Message names for wrapper types. + public static final String BOOL_WRAPPER_MESSAGE = "google.protobuf.BoolValue"; + public static final String BYTES_WRAPPER_MESSAGE = "google.protobuf.BytesValue"; + public static final String DOUBLE_WRAPPER_MESSAGE = "google.protobuf.DoubleValue"; + public static final String FLOAT_WRAPPER_MESSAGE = "google.protobuf.FloatValue"; + public static final String INT32_WRAPPER_MESSAGE = "google.protobuf.Int32Value"; + public static final String INT64_WRAPPER_MESSAGE = "google.protobuf.Int64Value"; + public static final String STRING_WRAPPER_MESSAGE = "google.protobuf.StringValue"; + public static final String UINT32_WRAPPER_MESSAGE = "google.protobuf.UInt32Value"; + public static final String UINT64_WRAPPER_MESSAGE = "google.protobuf.UInt64Value"; + + // Static types. + public static final Type ERROR = Type.newBuilder().setError(Empty.getDefaultInstance()).build(); + public static final Type DYN = Type.newBuilder().setDyn(Empty.getDefaultInstance()).build(); + public static final Type NULL_TYPE = Type.newBuilder().setNull(NullValue.NULL_VALUE).build(); + public static final Type BOOL = create(PrimitiveType.BOOL); + public static final Type BYTES = create(PrimitiveType.BYTES); + public static final Type STRING = create(PrimitiveType.STRING); + public static final Type DOUBLE = create(PrimitiveType.DOUBLE); + public static final Type UINT64 = create(PrimitiveType.UINT64); + public static final Type INT64 = create(PrimitiveType.INT64); + public static final Type ANY = create(WellKnownType.ANY); + public static final Type TIMESTAMP = create(WellKnownType.TIMESTAMP); + public static final Type DURATION = create(WellKnownType.DURATION); + + /** Map of well-known proto messages and their CEL {@code Type} equivalents. */ + static final ImmutableMap WELL_KNOWN_TYPE_MAP = + ImmutableMap.builder() + .put(DOUBLE_WRAPPER_MESSAGE, CelV1AlphaTypes.createWrapper(CelV1AlphaTypes.DOUBLE)) + .put(FLOAT_WRAPPER_MESSAGE, CelV1AlphaTypes.createWrapper(CelV1AlphaTypes.DOUBLE)) + .put(INT64_WRAPPER_MESSAGE, CelV1AlphaTypes.createWrapper(CelV1AlphaTypes.INT64)) + .put(INT32_WRAPPER_MESSAGE, CelV1AlphaTypes.createWrapper(CelV1AlphaTypes.INT64)) + .put(UINT64_WRAPPER_MESSAGE, CelV1AlphaTypes.createWrapper(CelV1AlphaTypes.UINT64)) + .put(UINT32_WRAPPER_MESSAGE, CelV1AlphaTypes.createWrapper(CelV1AlphaTypes.UINT64)) + .put(BOOL_WRAPPER_MESSAGE, CelV1AlphaTypes.createWrapper(CelV1AlphaTypes.BOOL)) + .put(STRING_WRAPPER_MESSAGE, CelV1AlphaTypes.createWrapper(CelV1AlphaTypes.STRING)) + .put(BYTES_WRAPPER_MESSAGE, CelV1AlphaTypes.createWrapper(CelV1AlphaTypes.BYTES)) + .put(TIMESTAMP_MESSAGE, CelV1AlphaTypes.TIMESTAMP) + .put(DURATION_MESSAGE, CelV1AlphaTypes.DURATION) + .put( + STRUCT_MESSAGE, + CelV1AlphaTypes.createMap(CelV1AlphaTypes.STRING, CelV1AlphaTypes.DYN)) + .put(VALUE_MESSAGE, CelV1AlphaTypes.DYN) + .put(LIST_VALUE_MESSAGE, CelV1AlphaTypes.createList(CelV1AlphaTypes.DYN)) + .put(ANY_MESSAGE, CelV1AlphaTypes.ANY) + .buildOrThrow(); + + static final ImmutableMap SIMPLE_CEL_KIND_TO_TYPE = + ImmutableMap.builder() + .put(CelKind.ERROR, CelV1AlphaTypes.ERROR) + .put(CelKind.DYN, CelV1AlphaTypes.DYN) + .put(CelKind.ANY, CelV1AlphaTypes.ANY) + .put(CelKind.BOOL, CelV1AlphaTypes.BOOL) + .put(CelKind.BYTES, CelV1AlphaTypes.BYTES) + .put(CelKind.DOUBLE, CelV1AlphaTypes.DOUBLE) + .put(CelKind.DURATION, CelV1AlphaTypes.DURATION) + .put(CelKind.INT, CelV1AlphaTypes.INT64) + .put(CelKind.NULL_TYPE, CelV1AlphaTypes.NULL_TYPE) + .put(CelKind.STRING, CelV1AlphaTypes.STRING) + .put(CelKind.TIMESTAMP, CelV1AlphaTypes.TIMESTAMP) + .put(CelKind.UINT, CelV1AlphaTypes.UINT64) + .buildOrThrow(); + + private static final ImmutableMap WELL_KNOWN_CEL_TYPE_MAP = + ImmutableMap.builder() + .put(BOOL_WRAPPER_MESSAGE, NullableType.create(SimpleType.BOOL)) + .put(BYTES_WRAPPER_MESSAGE, NullableType.create(SimpleType.BYTES)) + .put(FLOAT_WRAPPER_MESSAGE, NullableType.create(SimpleType.DOUBLE)) + .put(DOUBLE_WRAPPER_MESSAGE, NullableType.create(SimpleType.DOUBLE)) + .put(INT32_WRAPPER_MESSAGE, NullableType.create(SimpleType.INT)) + .put(INT64_WRAPPER_MESSAGE, NullableType.create(SimpleType.INT)) + .put(STRING_WRAPPER_MESSAGE, NullableType.create(SimpleType.STRING)) + .put(UINT32_WRAPPER_MESSAGE, NullableType.create(SimpleType.UINT)) + .put(UINT64_WRAPPER_MESSAGE, NullableType.create(SimpleType.UINT)) + .put(ANY_MESSAGE, SimpleType.ANY) + .put(DURATION_MESSAGE, SimpleType.DURATION) + .put(TIMESTAMP_MESSAGE, SimpleType.TIMESTAMP) + .put(LIST_VALUE_MESSAGE, ListType.create(SimpleType.DYN)) + .put(STRUCT_MESSAGE, MapType.create(SimpleType.STRING, SimpleType.DYN)) + .put(VALUE_MESSAGE, SimpleType.DYN) + .buildOrThrow(); + private static final ImmutableMap PROTOBUF_TYPE_TO_CEL_TYPE_MAP = + ImmutableMap.builder() + .put(CelV1AlphaTypes.BOOL, SimpleType.BOOL) + .put(CelV1AlphaTypes.BYTES, SimpleType.BYTES) + .put(CelV1AlphaTypes.DOUBLE, SimpleType.DOUBLE) + .put(CelV1AlphaTypes.INT64, SimpleType.INT) + .put(CelV1AlphaTypes.STRING, SimpleType.STRING) + .put(CelV1AlphaTypes.UINT64, SimpleType.UINT) + .put(CelV1AlphaTypes.ANY, SimpleType.ANY) + .put(CelV1AlphaTypes.DURATION, SimpleType.DURATION) + .put(CelV1AlphaTypes.TIMESTAMP, SimpleType.TIMESTAMP) + .put(CelV1AlphaTypes.DYN, SimpleType.DYN) + .put(CelV1AlphaTypes.NULL_TYPE, SimpleType.NULL_TYPE) + .put(CelV1AlphaTypes.ERROR, SimpleType.ERROR) + .buildOrThrow(); + + private CelV1AlphaTypes() {} + + /** Create a primitive {@code Type}. */ + public static Type create(PrimitiveType type) { + return Type.newBuilder().setPrimitive(type).build(); + } + + /** Create a well-known {@code Type}. */ + public static Type create(WellKnownType type) { + return Type.newBuilder().setWellKnown(type).build(); + } + + /** Create a type {@code Type}. */ + public static Type create(Type target) { + return Type.newBuilder().setType(target).build(); + } + + /** Create a list with {@code elemType}. */ + public static Type createList(Type elemType) { + return Type.newBuilder().setListType(Type.ListType.newBuilder().setElemType(elemType)).build(); + } + + /** Create a map with {@code keyType} and {@code valueType}. */ + public static Type createMap(Type keyType, Type valueType) { + return Type.newBuilder() + .setMapType(Type.MapType.newBuilder().setKeyType(keyType).setValueType(valueType)) + .build(); + } + + /** Create a message {@code Type} for {@code messageName}. */ + public static Type createMessage(String messageName) { + return Type.newBuilder().setMessageType(messageName).build(); + } + + /** Create a message {@code Type} for {@code Descriptor}. */ + public static Type createMessage(Descriptor descriptor) { + return createMessage(descriptor.getFullName()); + } + + /** Create a type param {@code Type}. */ + public static Type createTypeParam(String name) { + return Type.newBuilder().setTypeParam(name).build(); + } + + /** Create a wrapper type for the {@code primitive}. */ + public static Type createWrapper(PrimitiveType primitive) { + return Type.newBuilder().setWrapper(primitive).build(); + } + + /** Create a wrapper type where the input is a {@code Type} of primitive types. */ + public static Type createWrapper(Type type) { + Preconditions.checkArgument(type.getTypeKindCase() == Type.TypeKindCase.PRIMITIVE); + return createWrapper(type.getPrimitive()); + } + + /** + * Method to adapt a simple {@code Type} into a {@code String} representation. + * + *

This method can also format global functions. See the {@link #formatFunction} methods for + * richer control over function formatting. + */ + public static String format(Type type) { + return format(type, /* typeParamToDyn= */ false); + } + + private static String format(Type type, boolean typeParamToDyn) { + switch (type.getTypeKindCase()) { + case DYN: + return "dyn"; + case NULL: + return "null"; + case PRIMITIVE: + switch (type.getPrimitive()) { + case BOOL: + return "bool"; + case INT64: + return "int"; + case UINT64: + return "uint"; + case DOUBLE: + return "double"; + case STRING: + return "string"; + case BYTES: + return "bytes"; + default: + break; + } + break; + case WELL_KNOWN: + switch (type.getWellKnown()) { + case TIMESTAMP: + return "google.protobuf.Timestamp"; + case DURATION: + return "google.protobuf.Duration"; + case ANY: + return "any"; + default: + break; + } + break; + case LIST_TYPE: + return String.format("list(%s)", format(type.getListType().getElemType(), typeParamToDyn)); + case MAP_TYPE: + return String.format( + "map(%s, %s)", + format(type.getMapType().getKeyType(), typeParamToDyn), + format(type.getMapType().getValueType(), typeParamToDyn)); + case TYPE: + return String.format("type(%s)", format(type.getType(), typeParamToDyn)); + case WRAPPER: + return String.format("wrapper(%s)", format(create(type.getWrapper()), typeParamToDyn)); + case ERROR: + return "*error*"; + case MESSAGE_TYPE: + return type.getMessageType(); + case TYPE_PARAM: + return typeParamToDyn ? "dyn" : type.getTypeParam(); + case FUNCTION: + return formatFunction( + type.getFunction().getResultType(), + type.getFunction().getArgTypesList(), + false, + typeParamToDyn); + case ABSTRACT_TYPE: + String result = type.getAbstractType().getName(); + if (type.getAbstractType().getParameterTypesCount() > 0) { + result += formatTypeArgs(type.getAbstractType().getParameterTypesList(), typeParamToDyn); + } + return result; + default: + break; + } + return ""; + } + + /** + * Format a function signature string from the input {@code argTypes} and {@code resultType}. + * + *

When {@code isInstance} is {@code true}, the {@code argTypes[0]} type is used as the + * receiver type. + * + *

When {@code resultType} is {@code null}, the function signature omits the result type. This + * is useful for computing overload signatures. + * + *

When {@code typeParamToDyn} is {@code true}, parameterized type argument are represented as + * {@code Types.DYN} values. + */ + public static String formatFunction( + Type resultType, Iterable argTypes, boolean isInstance, boolean typeParamToDyn) { + String argString; + if (isInstance) { + argString = + format(Iterables.get(argTypes, 0), typeParamToDyn) + + "." + + formatTypeArgs(Iterables.skip(argTypes, 1), typeParamToDyn); + } else { + argString = formatTypeArgs(argTypes, typeParamToDyn); + } + if (resultType == null) { + return argString; + } else { + return argString + " -> " + format(resultType, typeParamToDyn); + } + } + + public static boolean isWellKnownType(String typeName) { + return WELL_KNOWN_TYPE_MAP.containsKey(typeName); + } + + public static Optional getWellKnownCelType(String typeName) { + return Optional.ofNullable(WELL_KNOWN_CEL_TYPE_MAP.getOrDefault(typeName, null)); + } + + /** Converts a Protobuf type into CEL native type. */ + @Internal + public static Type celTypeToType(CelType celType) { + Type type = SIMPLE_CEL_KIND_TO_TYPE.get(celType.kind()); + if (type != null) { + if (celType instanceof NullableType) { + return CelV1AlphaTypes.createWrapper(type); + } + return type; + } + + switch (celType.kind()) { + case LIST: + ListType listType = (ListType) celType; + return CelV1AlphaTypes.createList(celTypeToType(listType.elemType())); + case MAP: + MapType mapType = (MapType) celType; + return CelV1AlphaTypes.createMap( + celTypeToType(mapType.keyType()), celTypeToType(mapType.valueType())); + case OPAQUE: + return Type.newBuilder() + .setAbstractType( + Type.AbstractType.newBuilder() + .setName(celType.name()) + .addAllParameterTypes( + celType.parameters().stream() + .map(CelV1AlphaTypes::celTypeToType) + .collect(toImmutableList()))) + .build(); + case STRUCT: + return CelV1AlphaTypes.createMessage(celType.name()); + case TYPE: + TypeType typeType = (TypeType) celType; + return CelV1AlphaTypes.create(celTypeToType(typeType.type())); + case TYPE_PARAM: + return CelV1AlphaTypes.createTypeParam(celType.name()); + default: + throw new IllegalArgumentException(String.format("Unsupported type: %s", celType)); + } + } + + /** Converts a Protobuf type to CEL native type. */ + @Internal + public static CelType typeToCelType(Type type) { + CelType celType = PROTOBUF_TYPE_TO_CEL_TYPE_MAP.get(type); + if (celType != null) { + return celType; + } + + switch (type.getTypeKindCase()) { + case WRAPPER: + return NullableType.create(typeToCelType(CelV1AlphaTypes.create(type.getWrapper()))); + case MESSAGE_TYPE: + return ProtoMessageType.create( + type.getMessageType(), ImmutableSet.of(), (fieldName) -> Optional.empty()); + case LIST_TYPE: + Type.ListType listType = type.getListType(); + return ListType.create(typeToCelType(listType.getElemType())); + case MAP_TYPE: + Type.MapType mapType = type.getMapType(); + return MapType.create( + typeToCelType(mapType.getKeyType()), typeToCelType(mapType.getValueType())); + case TYPE_PARAM: + return TypeParamType.create(type.getTypeParam()); + case ABSTRACT_TYPE: + Type.AbstractType abstractType = type.getAbstractType(); + ImmutableList params = + abstractType.getParameterTypesList().stream() + .map(CelV1AlphaTypes::typeToCelType) + .collect(toImmutableList()); + return OpaqueType.create(abstractType.getName(), params); + case TYPE: + return TypeType.create(typeToCelType(type.getType())); + default: + // Add more cases as needed. + throw new IllegalArgumentException(String.format("Unsupported type: %s", type)); + } + } + + private static String formatTypeArgs(Iterable types, final boolean typeParamToDyn) { + return String.format( + "(%s)", + Joiner.on(", ") + .join(Iterables.transform(types, (Type type) -> format(type, typeParamToDyn)))); + } +} diff --git a/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java b/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java new file mode 100644 index 000000000..372a50e73 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java @@ -0,0 +1,55 @@ +// Copyright 2025 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.types; + +import com.google.common.collect.ImmutableCollection; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.Immutable; +import java.util.Optional; + +/** {@code DefaultTypeProvider} is a registry of common CEL types. */ +@Immutable +public class DefaultTypeProvider implements CelTypeProvider { + + private static final DefaultTypeProvider INSTANCE = new DefaultTypeProvider(); + private final ImmutableMap commonTypes; + + @Override + public ImmutableCollection types() { + return commonTypes.values(); + } + + @Override + public Optional findType(String typeName) { + return Optional.ofNullable(commonTypes.get(typeName)); + } + + public static DefaultTypeProvider getInstance() { + return INSTANCE; + } + + private DefaultTypeProvider() { + ImmutableMap.Builder typeMapBuilder = ImmutableMap.builder(); + typeMapBuilder.putAll(SimpleType.TYPE_MAP); + typeMapBuilder.put("list", ListType.create(SimpleType.DYN)); + typeMapBuilder.put("map", MapType.create(SimpleType.DYN, SimpleType.DYN)); + typeMapBuilder.put("type", TypeType.create(SimpleType.DYN)); + typeMapBuilder.put( + "optional_type", + // TODO: Move to CelOptionalLibrary and register it on demand + OptionalType.create(SimpleType.DYN)); + this.commonTypes = typeMapBuilder.buildOrThrow(); + } +} diff --git a/common/src/main/java/dev/cel/common/types/EnumType.java b/common/src/main/java/dev/cel/common/types/EnumType.java new file mode 100644 index 000000000..836b68a6c --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/EnumType.java @@ -0,0 +1,91 @@ +// Copyright 2022 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.types; + +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.Map; +import java.util.Optional; + +/** Enum types to support strongly typed enums with lookups by value name and number. */ +@CheckReturnValue +public final class EnumType extends CelType { + + private final String name; + private final EnumNumberResolver enumNumberResolver; + private final EnumNameResolver enumNameResolver; + + EnumType(String name, EnumNumberResolver enumNumberResolver, EnumNameResolver enumNameResolver) { + this.name = name; + this.enumNumberResolver = enumNumberResolver; + this.enumNameResolver = enumNameResolver; + } + + @Override + public CelKind kind() { + return CelKind.INT; + } + + @Override + public String name() { + return name; + } + + @Override + public boolean isAssignableFrom(CelType other) { + return super.isAssignableFrom(other) || other.kind().equals(CelKind.INT); + } + + /** Find an enum number by {@code enumName}. */ + public Optional findNumberByName(String enumName) { + return enumNumberResolver.findNumber(enumName); + } + + /** Find an enum name by {@code enumNumber}. */ + public Optional findNameByNumber(Integer enumNumber) { + return enumNameResolver.findName(enumNumber); + } + + /** Functional interface for lookup up an enum number by its local or fully qualified name. */ + @Immutable + @FunctionalInterface + public interface EnumNumberResolver { + Optional findNumber(String enumName); + } + + /** Functional interface for looking up an enum name by its number. */ + @Immutable + @FunctionalInterface + public interface EnumNameResolver { + Optional findName(Integer enumNumber); + } + + public static EnumType create(String name, ImmutableMap enumNameToNumber) { + return create( + name, + (enumName) -> Optional.ofNullable(enumNameToNumber.get(enumName)), + (num) -> + enumNameToNumber.entrySet().stream() + .filter(entry -> entry.getValue().equals(num)) + .findFirst() + .map(Map.Entry::getKey)); + } + + public static EnumType create( + String name, EnumNumberResolver enumNumberResolver, EnumNameResolver enumNameResolver) { + return new EnumType(name, enumNumberResolver, enumNameResolver); + } +} diff --git a/common/src/main/java/dev/cel/common/types/JsonType.java b/common/src/main/java/dev/cel/common/types/JsonType.java new file mode 100644 index 000000000..4cce9a161 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/JsonType.java @@ -0,0 +1,60 @@ +// Copyright 2022 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.types; + +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; + +/** The JSON type is a union of all of the types which can be represented as JSON values. */ +@CheckReturnValue +@Immutable +public final class JsonType extends CelType { + + public static final CelType JSON = new JsonType(); + + private JsonType() {} + + @Override + public CelKind kind() { + return CelKind.OPAQUE; + } + + @Override + public String name() { + return "json"; + } + + @Override + public boolean isAssignableFrom(CelType other) { + if (this.equals(other)) { + return true; + } + switch (other.kind()) { + case BOOL: + case DOUBLE: + case NULL_TYPE: + case STRING: + return true; + case LIST: + ListType list = (ListType) other; + return this.isAssignableFrom(list.elemType()); + case MAP: + MapType map = (MapType) other; + return map.keyType().kind() == CelKind.STRING && this.isAssignableFrom(map.valueType()); + default: + return false; + } + } +} diff --git a/common/src/main/java/dev/cel/common/types/ListType.java b/common/src/main/java/dev/cel/common/types/ListType.java new file mode 100644 index 000000000..9591d0bf0 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/ListType.java @@ -0,0 +1,68 @@ +// Copyright 2022 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.types; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; + +/** Lists are a parameterized type with the parameter indicating the {@code elemType}. */ +@AutoValue +@CheckReturnValue +@Immutable +public abstract class ListType extends CelType { + + @Override + public abstract CelKind kind(); + + @Override + public abstract String name(); + + @Override + public abstract ImmutableList parameters(); + + @Override + public CelType withParameters(ImmutableList parameters) { + Preconditions.checkArgument(parameters.size() == 1); + return create(parameters.get(0)); + } + + public boolean hasElemType() { + return !parameters().isEmpty(); + } + + public CelType elemType() { + return parameters().get(0); + } + + /** + * Do not use. This exists for compatibility reason with ListType from checked.proto. + * + *

Note that a parameterized collection, such as {@code List} or a {@code Map}, + * is a type-checker construct. An unparameterized list here is what the runtime looks at after + * type-erasure, typically for handling dynamic dispatch. + */ + @Internal + public static ListType create() { + return new AutoValue_ListType(CelKind.LIST, "list", ImmutableList.of()); + } + + public static ListType create(CelType elemType) { + return new AutoValue_ListType(CelKind.LIST, "list", ImmutableList.of(elemType)); + } +} diff --git a/common/src/main/java/dev/cel/common/types/MapType.java b/common/src/main/java/dev/cel/common/types/MapType.java new file mode 100644 index 000000000..18a433073 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/MapType.java @@ -0,0 +1,60 @@ +// Copyright 2022 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.types; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; + +/** + * Maps are a parameterized type where the two parameters supported indicate the {@code keyType} and + * {@code valueType} of map entries. + */ +@AutoValue +@CheckReturnValue +@Immutable +public abstract class MapType extends CelType { + + @Override + public abstract CelKind kind(); + + @Override + public abstract String name(); + + @Override + public abstract ImmutableList parameters(); + + @Override + public CelType withParameters(ImmutableList parameters) { + Preconditions.checkArgument(parameters().size() == 2); + return create(parameters.get(0), parameters.get(1)); + } + + public CelType keyType() { + return parameters().get(0); + } + + public CelType valueType() { + return parameters().get(1); + } + + public static MapType create(CelType keyType, CelType valueType) { + // Note, the set of supported key types should be configurable within the type checker + // as there may be cases where derivations from CEL alter the supported map key set. + return new AutoValue_MapType(CelKind.MAP, "map", ImmutableList.of(keyType, valueType)); + } +} diff --git a/common/src/main/java/dev/cel/common/types/NullableType.java b/common/src/main/java/dev/cel/common/types/NullableType.java new file mode 100644 index 000000000..41cd95b3d --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/NullableType.java @@ -0,0 +1,58 @@ +// Copyright 2022 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.types; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.function.Function; + +/** + * Nullable types are a union type which indicate that the value is either the {@code targetType} or + * {@code SimpleType.NULL_TYPE} + */ +@AutoValue +@CheckReturnValue +@Immutable +public abstract class NullableType extends CelType { + + @Override + public abstract CelKind kind(); + + @Override + public abstract String name(); + + @Override + public boolean isAssignableFrom(CelType other) { + return targetType().isAssignableFrom(other) || other.equals(SimpleType.NULL_TYPE); + } + + public abstract CelType targetType(); + + @Override + public CelType withParameters(ImmutableList parameters) { + return create(targetType().withParameters(parameters)); + } + + @Override + public CelType withFreshTypeParamVariables(Function varNameGenerator) { + return create(targetType().withFreshTypeParamVariables(varNameGenerator)); + } + + public static NullableType create(CelType targetType) { + return new AutoValue_NullableType(targetType.kind(), targetType.name(), targetType); + } +} diff --git a/common/src/main/java/dev/cel/common/types/OpaqueType.java b/common/src/main/java/dev/cel/common/types/OpaqueType.java new file mode 100644 index 000000000..6ba894c34 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/OpaqueType.java @@ -0,0 +1,55 @@ +// Copyright 2022 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.types; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.Arrays; + +/** + * An opaque type's properties may only be accessed via function calls associated with the type. + * + *

Apart from protobuf messages, opaque types are the preferred extension mechanism for + * introducing first-order types into CEL. + */ +@AutoValue +@CheckReturnValue +@Immutable +public abstract class OpaqueType extends CelType { + + @Override + public abstract CelKind kind(); + + @Override + public abstract String name(); + + @Override + public abstract ImmutableList parameters(); + + @Override + public CelType withParameters(ImmutableList parameters) { + return create(name(), parameters); + } + + public static OpaqueType create(String typeName, CelType... parameters) { + return create(typeName, ImmutableList.copyOf(Arrays.asList(parameters))); + } + + public static OpaqueType create(String typeName, ImmutableList parameters) { + return new AutoValue_OpaqueType(CelKind.OPAQUE, typeName, parameters); + } +} diff --git a/common/src/main/java/dev/cel/common/types/OptionalType.java b/common/src/main/java/dev/cel/common/types/OptionalType.java new file mode 100644 index 000000000..d14d4f83b --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/OptionalType.java @@ -0,0 +1,48 @@ +// Copyright 2023 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.types; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; + +/** OptionalType is an opaque type that that represents an optional value. */ +@AutoValue +@CheckReturnValue +@Immutable +public abstract class OptionalType extends CelType { + + public static final String NAME = "optional_type"; + + @Override + public CelKind kind() { + return CelKind.OPAQUE; + } + + @Override + public String name() { + return NAME; + } + + @Override + public abstract ImmutableList parameters(); + + public static OptionalType create(CelType parameter) { + Preconditions.checkNotNull(parameter); + return new AutoValue_OptionalType(ImmutableList.of(parameter)); + } +} diff --git a/common/src/main/java/dev/cel/common/types/ProtoMessageType.java b/common/src/main/java/dev/cel/common/types/ProtoMessageType.java new file mode 100644 index 000000000..11e48bbe6 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/ProtoMessageType.java @@ -0,0 +1,97 @@ +// Copyright 2022 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.types; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.Optional; + +/** + * The {@code ProtoMessageType} is a {@code StructType} with support for proto {@code Extension}s + * and field masks. + */ +@CheckReturnValue +@Immutable +public final class ProtoMessageType extends StructType { + + private final StructType.FieldResolver extensionResolver; + private final JsonNameResolver jsonNameResolver; + + ProtoMessageType( + String name, + ImmutableSet fieldNames, + StructType.FieldResolver fieldResolver, + StructType.FieldResolver extensionResolver, + JsonNameResolver jsonNameResolver) { + super(name, fieldNames, fieldResolver); + this.extensionResolver = extensionResolver; + this.jsonNameResolver = jsonNameResolver; + } + + /** Find an {@code Extension} by its fully-qualified {@code extensionName}. */ + public Optional findExtension(String extensionName) { + return extensionResolver + .findField(extensionName) + .map(type -> Extension.of(extensionName, type, this)); + } + + /** Returns true if the field name is a json name. */ + public boolean isJsonName(String fieldName) { + return jsonNameResolver.isJsonName(fieldName); + } + + /** + * Create a new instance of the {@code ProtoMessageType} using the {@code visibleFields} set as a + * mask of the fields from the backing proto. + */ + public ProtoMessageType withVisibleFields(ImmutableSet visibleFields) { + return new ProtoMessageType( + name, visibleFields, fieldResolver, extensionResolver, jsonNameResolver); + } + + public static ProtoMessageType create( + String name, + ImmutableSet fieldNames, + FieldResolver fieldResolver, + FieldResolver extensionResolver, + JsonNameResolver jsonNameResolver) { + return new ProtoMessageType( + name, fieldNames, fieldResolver, extensionResolver, jsonNameResolver); + } + + /** Functional interface for resolving whether a field name is a json name. */ + @FunctionalInterface + @Immutable + public interface JsonNameResolver { + boolean isJsonName(String fieldName); + } + + /** {@code Extension} contains the name, type, and target message type of the extension. */ + @Immutable + @AutoValue + public abstract static class Extension { + public abstract String name(); + + public abstract CelType type(); + + public abstract CelType messageType(); + + static Extension of(String name, CelType type, CelType messageType) { + return new AutoValue_ProtoMessageType_Extension(name, type, messageType); + } + } +} diff --git a/common/src/main/java/dev/cel/common/types/ProtoMessageTypeProvider.java b/common/src/main/java/dev/cel/common/types/ProtoMessageTypeProvider.java new file mode 100644 index 000000000..022f5cd8e --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/ProtoMessageTypeProvider.java @@ -0,0 +1,363 @@ +// Copyright 2022 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.types; + +import static com.google.common.collect.ImmutableMap.toImmutableMap; + +import com.google.common.collect.ImmutableCollection; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableMultimap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.EnumDescriptor; +import com.google.protobuf.Descriptors.EnumValueDescriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import dev.cel.common.internal.FileDescriptorSetConverter; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; + +/** + * The {@code ProtoMessageTypeProvider} implements the {@link CelTypeProvider} interface to provide + * {@code CelType} objects for the core CEL types and a list of protobuf message types. + */ +@CheckReturnValue +@Immutable +public final class ProtoMessageTypeProvider implements CelTypeProvider { + + private static final ImmutableMap PROTO_TYPE_TO_CEL_TYPE = + ImmutableMap.builder() + .put(FieldDescriptor.Type.BOOL, SimpleType.BOOL) + .put(FieldDescriptor.Type.BYTES, SimpleType.BYTES) + .put(FieldDescriptor.Type.DOUBLE, SimpleType.DOUBLE) + .put(FieldDescriptor.Type.FLOAT, SimpleType.DOUBLE) + .put(FieldDescriptor.Type.FIXED32, SimpleType.UINT) + .put(FieldDescriptor.Type.FIXED64, SimpleType.UINT) + .put(FieldDescriptor.Type.INT32, SimpleType.INT) + .put(FieldDescriptor.Type.INT64, SimpleType.INT) + .put(FieldDescriptor.Type.SFIXED32, SimpleType.INT) + .put(FieldDescriptor.Type.SFIXED64, SimpleType.INT) + .put(FieldDescriptor.Type.SINT32, SimpleType.INT) + .put(FieldDescriptor.Type.SINT64, SimpleType.INT) + .put(FieldDescriptor.Type.STRING, SimpleType.STRING) + .put(FieldDescriptor.Type.UINT32, SimpleType.UINT) + .put(FieldDescriptor.Type.UINT64, SimpleType.UINT) + .buildOrThrow(); + + private final ImmutableMap allTypes; + private final boolean allowJsonFieldNames; + + /** Returns a new builder for {@link ProtoMessageTypeProvider}. */ + public static Builder newBuilder() { + return new Builder(); + } + + /** + * @deprecated Use {@link #newBuilder()} instead. + */ + @Deprecated + public ProtoMessageTypeProvider() { + this(CelDescriptors.builder().build(), false); + } + + /** + * @deprecated Use {@link #newBuilder()} instead. + */ + @Deprecated + public ProtoMessageTypeProvider(FileDescriptorSet descriptorSet) { + this( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + FileDescriptorSetConverter.convert(descriptorSet)), + false); + } + + /** + * @deprecated Use {@link #newBuilder()} instead. + */ + @Deprecated + public ProtoMessageTypeProvider(Iterable descriptors) { + this( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + ImmutableSet.copyOf(Iterables.transform(descriptors, Descriptor::getFile))), + false); + } + + /** + * @deprecated Use {@link #newBuilder()} instead. + */ + @Deprecated + public ProtoMessageTypeProvider(ImmutableSet fileDescriptors) { + this(CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(fileDescriptors), false); + } + + private ProtoMessageTypeProvider(CelDescriptors celDescriptors, boolean allowJsonFieldNames) { + this.allowJsonFieldNames = allowJsonFieldNames; + this.allTypes = + ImmutableMap.builder() + .putAll(createEnumTypes(celDescriptors.enumDescriptors())) + .putAll( + createProtoMessageTypes( + celDescriptors.messageTypeDescriptors(), celDescriptors.extensionDescriptors())) + .buildOrThrow(); + } + + @Override + public ImmutableCollection types() { + return allTypes.values(); + } + + @Override + public Optional findType(String typeName) { + return Optional.ofNullable(allTypes.get(typeName)); + } + + // This method reference implements @Immutable interface FieldResolver, but the declaration of + // type 'com.google.api.expr.cel.ProtoMessageTypeProvider.FieldResolver' is not annotated with + // @com.google.errorprone.annotations.Immutable + @SuppressWarnings("Immutable") + private ImmutableMap createProtoMessageTypes( + Collection descriptors, ImmutableMultimap extensionMap) { + Map protoMessageTypes = new HashMap<>(); + for (Descriptor descriptor : descriptors) { + if (protoMessageTypes.containsKey(descriptor.getFullName())) { + continue; + } + + ImmutableSet.Builder fieldNamesBuilder = ImmutableSet.builder(); + ImmutableSet.Builder jsonNamesBuilder = ImmutableSet.builder(); + for (FieldDescriptor fd : descriptor.getFields()) { + if (allowJsonFieldNames) { + fieldNamesBuilder.add(fd.getJsonName()); + jsonNamesBuilder.add(fd.getJsonName()); + } else { + fieldNamesBuilder.add(fd.getName()); + } + } + ImmutableSet jsonNames = jsonNamesBuilder.build(); + + Map extensionFields = new HashMap<>(); + for (FieldDescriptor extension : extensionMap.get(descriptor.getFullName())) { + extensionFields.putIfAbsent(extension.getFullName(), extension); + } + ImmutableMap extensions = ImmutableMap.copyOf(extensionFields); + + protoMessageTypes.put( + descriptor.getFullName(), + ProtoMessageType.create( + descriptor.getFullName(), + fieldNamesBuilder.build(), + new FieldResolver(this, descriptor)::findField, + new FieldResolver(this, extensions)::findField, + jsonNames::contains)); + } + return ImmutableMap.copyOf(protoMessageTypes); + } + + private ImmutableMap createEnumTypes( + Collection enumDescriptors) { + HashMap enumTypes = new HashMap<>(); + for (EnumDescriptor enumDescriptor : enumDescriptors) { + if (enumTypes.containsKey(enumDescriptor.getFullName())) { + continue; + } + ImmutableMap values = + enumDescriptor.getValues().stream() + .collect( + toImmutableMap(EnumValueDescriptor::getName, EnumValueDescriptor::getNumber)); + enumTypes.put( + enumDescriptor.getFullName(), EnumType.create(enumDescriptor.getFullName(), values)); + } + return ImmutableMap.copyOf(enumTypes); + } + + private static class FieldResolver { + private final ProtoMessageTypeProvider protoMessageTypeProvider; + private final ImmutableMap fields; + + private static ImmutableMap collectJsonFieldDescriptorMap( + Descriptor descriptor) { + ImmutableMap.Builder builder = ImmutableMap.builder(); + for (FieldDescriptor fd : descriptor.getFields()) { + if (!fd.getJsonName().isEmpty()) { + builder.put(fd.getJsonName(), fd); + } else { + builder.put(fd.getName(), fd); + } + } + + return builder.buildOrThrow(); + } + + private static ImmutableMap collectFieldDescriptorMap( + Descriptor descriptor) { + return descriptor.getFields().stream() + .collect(toImmutableMap(FieldDescriptor::getName, Function.identity())); + } + + private FieldResolver( + ProtoMessageTypeProvider protoMessageTypeProvider, Descriptor descriptor) { + this( + protoMessageTypeProvider, + protoMessageTypeProvider.allowJsonFieldNames + ? collectJsonFieldDescriptorMap(descriptor) + : collectFieldDescriptorMap(descriptor)); + } + + private FieldResolver( + ProtoMessageTypeProvider protoMessageTypeProvider, + ImmutableMap fields) { + this.protoMessageTypeProvider = protoMessageTypeProvider; + this.fields = fields; + } + + private Optional findField(String fieldName) { + FieldDescriptor fieldDescriptor = fields.get(fieldName); + if (fieldDescriptor == null) { + return Optional.empty(); + } + return findFieldInternal(fieldDescriptor); + } + + private Optional findFieldInternal(FieldDescriptor fieldDescriptor) { + boolean isRepeated = fieldDescriptor.isRepeated(); + CelType fieldType; + switch (fieldDescriptor.getType()) { + case GROUP: + case MESSAGE: + Descriptor descriptor = fieldDescriptor.getMessageType(); + if (fieldDescriptor.isMapField()) { + // The key and value types are always guaranteed to be at index 0 and 1 respectively. + FieldDescriptor keyField = descriptor.getFields().get(0); + FieldDescriptor valueField = descriptor.getFields().get(1); + Optional key = findFieldInternal(keyField); + Optional value = findFieldInternal(valueField); + if (key.isPresent() && value.isPresent()) { + return Optional.of(MapType.create(key.get(), value.get())); + } + return Optional.empty(); + } + String messageName = descriptor.getFullName(); + fieldType = + CelTypes.getWellKnownCelType(messageName) + .orElse(protoMessageTypeProvider.findType(descriptor.getFullName()).orElse(null)); + break; + case ENUM: + EnumDescriptor enumDescriptor = fieldDescriptor.getEnumType(); + fieldType = protoMessageTypeProvider.findType(enumDescriptor.getFullName()).orElse(null); + break; + default: + fieldType = PROTO_TYPE_TO_CEL_TYPE.get(fieldDescriptor.getType()); + break; + } + if (fieldType == null) { + return Optional.empty(); + } + if (isRepeated) { + return Optional.of(ListType.create(fieldType)); + } + return Optional.of(fieldType); + } + } + + /** Builder for {@link ProtoMessageTypeProvider}. */ + public static final class Builder { + private final ImmutableSet.Builder fileDescriptors = ImmutableSet.builder(); + private boolean allowJsonFieldNames; + private boolean resolveTypeDependencies; + private CelDescriptors celDescriptors; + + /** Adds a {@link FileDescriptor} to the provider. */ + @CanIgnoreReturnValue + public Builder addFileDescriptors(FileDescriptor... fileDescriptors) { + return addFileDescriptors(Arrays.asList(fileDescriptors)); + } + + /** Adds a collection of {@link FileDescriptor}s to the provider. */ + @CanIgnoreReturnValue + public Builder addFileDescriptors(Iterable fileDescriptors) { + this.fileDescriptors.addAll(fileDescriptors); + return this; + } + + /** Adds a collection of {@link Descriptor}s. The parent file of each descriptor is added. */ + @CanIgnoreReturnValue + public Builder addDescriptors(Iterable descriptors) { + this.fileDescriptors.addAll(Iterables.transform(descriptors, Descriptor::getFile)); + return this; + } + + /** + * Use the `json_name` field option on a protobuf message as the name of the field. + * + *

If enabled, the type checker will only accept the `json_name` and will no longer recognize + * the original protobuf field name. This is to avoid ambiguity between the two names. + */ + @CanIgnoreReturnValue + public Builder setAllowJsonFieldNames(boolean allowJsonFieldNames) { + this.allowJsonFieldNames = allowJsonFieldNames; + return this; + } + + /** + * If true, all transitive dependencies of the added {@link FileDescriptor}s will be resolved + * and their types will be made available to the type provider. By default, this is disabled. + */ + @CanIgnoreReturnValue + public Builder setResolveTypeDependencies(boolean resolveTypeDependencies) { + this.resolveTypeDependencies = resolveTypeDependencies; + return this; + } + + /** + * Sets the CEL descriptors. Note this cannot be used in conjunction with other descriptor + * adders such as {@link #addDescriptors}. + */ + @CanIgnoreReturnValue + public Builder setCelDescriptors(CelDescriptors celDescriptors) { + this.celDescriptors = celDescriptors; + return this; + } + + /** Builds the {@link ProtoMessageTypeProvider}. */ + public ProtoMessageTypeProvider build() { + ImmutableSet fds = fileDescriptors.build(); + if (celDescriptors != null && !fds.isEmpty()) { + throw new IllegalArgumentException( + "Both CelDescriptors and FileDescriptors cannot be set at the same time."); + } + + if (celDescriptors == null) { + celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + fileDescriptors.build(), resolveTypeDependencies); + } + + return new ProtoMessageTypeProvider(celDescriptors, allowJsonFieldNames); + } + + private Builder() {} + } +} diff --git a/common/src/main/java/dev/cel/common/types/SimpleType.java b/common/src/main/java/dev/cel/common/types/SimpleType.java new file mode 100644 index 000000000..93bd5326d --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/SimpleType.java @@ -0,0 +1,81 @@ +// Copyright 2022 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.types; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.Optional; + +/** Simple types represent scalar, dynamic, and error values. */ +@AutoValue +@CheckReturnValue +@Immutable +public abstract class SimpleType extends CelType { + + // Internal error type. + public static final CelType ERROR = create(CelKind.ERROR, "*error*"); + + // Dynamic 'top' types. + public static final CelType DYN = create(CelKind.DYN, "dyn"); + public static final CelType ANY = create(CelKind.ANY, "google.protobuf.Any"); + + // Scalar types. + public static final CelType BOOL = create(CelKind.BOOL, "bool"); + public static final CelType BYTES = create(CelKind.BYTES, "bytes"); + public static final CelType DOUBLE = create(CelKind.DOUBLE, "double"); + public static final CelType DURATION = create(CelKind.DURATION, "google.protobuf.Duration"); + public static final CelType INT = create(CelKind.INT, "int"); + public static final CelType NULL_TYPE = create(CelKind.NULL_TYPE, "null_type"); + public static final CelType STRING = create(CelKind.STRING, "string"); + public static final CelType TIMESTAMP = create(CelKind.TIMESTAMP, "google.protobuf.Timestamp"); + public static final CelType UINT = create(CelKind.UINT, "uint"); + + public static final ImmutableMap TYPE_MAP = + ImmutableMap.of( + BOOL.name(), BOOL, + BYTES.name(), BYTES, + DOUBLE.name(), DOUBLE, + DURATION.name(), DURATION, + INT.name(), INT, + NULL_TYPE.name(), NULL_TYPE, + STRING.name(), STRING, + TIMESTAMP.name(), TIMESTAMP, + UINT.name(), UINT); + + @Override + public abstract CelKind kind(); + + @Override + public abstract String name(); + + @Override + public boolean isAssignableFrom(CelType other) { + return kind().isDyn() + || super.isAssignableFrom(other) + || (kind().equals(CelKind.INT) && other instanceof EnumType) + || (other instanceof NullableType && other.isAssignableFrom(this)); + } + + /** Returns a matching SimpleType by its name if one exists. */ + public static Optional findByName(String typeName) { + return Optional.ofNullable(TYPE_MAP.get(typeName)); + } + + private static CelType create(CelKind kind, String name) { + return new AutoValue_SimpleType(kind, name); + } +} diff --git a/common/src/main/java/dev/cel/common/types/StructType.java b/common/src/main/java/dev/cel/common/types/StructType.java new file mode 100644 index 000000000..b91b6fef0 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/StructType.java @@ -0,0 +1,119 @@ +// Copyright 2022 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.types; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.NoSuchElementException; +import java.util.Optional; + +/** + * Struct type indicates that the type {@code name} is a structured object with typed properties. + * + *

The definition of the struct properties occurs outside the CEL type specification. + */ +@CheckReturnValue +@Immutable +public class StructType extends CelType { + + protected final String name; + protected final ImmutableSet fieldNames; + protected final FieldResolver fieldResolver; + + StructType(String name, ImmutableSet fieldNames, FieldResolver fieldResolver) { + this.name = name; + this.fieldNames = fieldNames; + this.fieldResolver = fieldResolver; + } + + @Override + public CelKind kind() { + return CelKind.STRUCT; + } + + @Override + public String name() { + return name; + } + + @Override + public boolean isAssignableFrom(CelType other) { + return super.isAssignableFrom(other) + || ((other instanceof StructType || other instanceof StructTypeReference) + && other.name().equals(name())); + } + + /** Returns the {@code CelType} associated with the struct field name. */ + public Optional findField(String fieldName) { + if (!fieldNames.contains(fieldName)) { + return Optional.empty(); + } + return fieldResolver.findField(fieldName).map(type -> Field.of(fieldName, type)); + } + + /** Returns the set of declare field names and their types. */ + public ImmutableSet fieldNames() { + return fieldNames; + } + + /** + * Returns the full set of {@code Field} definitions visible within this struct. + * + *

Note, the struct may support a broader set of fields than is returned; however, the input + * {@code fieldNames} to constructor limits which fields are visible. + */ + public ImmutableSet fields() { + return fieldNames().stream() + .map( + f -> + findField(f) + .orElseThrow( + () -> new NoSuchElementException(String.format("no such field: %s", f)))) + .collect(toImmutableSet()); + } + + public static StructType create( + String name, ImmutableSet fieldNames, FieldResolver fieldResolver) { + return new StructType(name, fieldNames, fieldResolver); + } + + /** + * The {@code FieldResolver} is used to lookup the type of a {@code StructType}'s {@code + * fieldName}. + */ + @Immutable + @FunctionalInterface + public interface FieldResolver { + /** Find the {@code CelType} for the given {@code fieldName} if the field is defined. */ + Optional findField(String fieldName); + } + + /** Value object which holds a reference to the field name and type. */ + @Immutable + @AutoValue + public abstract static class Field { + public abstract String name(); + + public abstract CelType type(); + + public static Field of(String name, CelType type) { + return new AutoValue_StructType_Field(name, type); + } + } +} diff --git a/common/src/main/java/dev/cel/common/types/StructTypeReference.java b/common/src/main/java/dev/cel/common/types/StructTypeReference.java new file mode 100644 index 000000000..59fa24dd9 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/StructTypeReference.java @@ -0,0 +1,52 @@ +// Copyright 2022 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.types; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; + +/** + * A simple type reference to a struct. + * + *

This can be used if you simply need to refer to a struct (including Proto Messages) in an + * expression without providing its full definition. + * + *

If you need the ability to enumerate its fields, use a full-fledged {@link StructType} or + * {@link ProtoMessageType} instead. An example is to mask fields that should not be exposed by + * leveraging {@code ProtoTypeMaskTypeProvider} + */ +@AutoValue +@CheckReturnValue +@Immutable +public abstract class StructTypeReference extends CelType { + + @Override + public abstract CelKind kind(); + + @Override + public abstract String name(); + + @Override + public boolean isAssignableFrom(CelType other) { + return super.isAssignableFrom(other) + || ((other instanceof StructType || other instanceof StructTypeReference) + && other.name().equals(name())); + } + + public static StructTypeReference create(String name) { + return new AutoValue_StructTypeReference(CelKind.STRUCT, name); + } +} diff --git a/common/src/main/java/dev/cel/common/types/TypeParamType.java b/common/src/main/java/dev/cel/common/types/TypeParamType.java new file mode 100644 index 000000000..db6a1bbdc --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/TypeParamType.java @@ -0,0 +1,42 @@ +// Copyright 2022 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.types; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import java.util.function.Function; + +/** Type parameters are 'free' types which take on a concrete type contextually. */ +@AutoValue +@CheckReturnValue +@Immutable +public abstract class TypeParamType extends CelType { + + @Override + public abstract CelKind kind(); + + @Override + public abstract String name(); + + @Override + public CelType withFreshTypeParamVariables(Function varNameGenerator) { + return create(varNameGenerator.apply(name())); + } + + public static TypeParamType create(String name) { + return new AutoValue_TypeParamType(CelKind.TYPE_PARAM, name); + } +} diff --git a/common/src/main/java/dev/cel/common/types/TypeType.java b/common/src/main/java/dev/cel/common/types/TypeType.java new file mode 100644 index 000000000..44905bbc7 --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/TypeType.java @@ -0,0 +1,65 @@ +// Copyright 2022 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.types; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; + +/** The {@code TypeType} is a type which holds a reference to a type-kind. */ +@AutoValue +@CheckReturnValue +@Immutable +public abstract class TypeType extends CelType { + + @Override + public CelKind kind() { + return CelKind.TYPE; + } + + @Override + public String name() { + return "type"; + } + + /** Retrieves the underlying type name of the type-kind held. */ + public String containingTypeName() { + CelType containingType = type(); + if (containingType.kind() == CelKind.DYN) { + return "type"; + } + + return containingType.name(); + } + + @Override + public abstract ImmutableList parameters(); + + public CelType type() { + return parameters().get(0); + } + + @Override + public CelType withParameters(ImmutableList parameters) { + Preconditions.checkArgument(parameters.size() == 1); + return create(parameters.get(0)); + } + + public static TypeType create(CelType type) { + return new AutoValue_TypeType(ImmutableList.of(type)); + } +} diff --git a/common/src/main/java/dev/cel/common/types/UnspecifiedType.java b/common/src/main/java/dev/cel/common/types/UnspecifiedType.java new file mode 100644 index 000000000..2c1df422e --- /dev/null +++ b/common/src/main/java/dev/cel/common/types/UnspecifiedType.java @@ -0,0 +1,52 @@ +// Copyright 2023 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.types; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; + +/** + * Represents an unspecified CEL-Type. + * + *

This exists purely to maintain compatibility with since the proto-based Type from + * checked.proto allows instantiation without an underlying kind set. Users should not be using this + * class directly. + * + *

CEL Library Internals. Do Not Use. + */ +@AutoValue +@CheckReturnValue +@Immutable +@Internal +public abstract class UnspecifiedType extends CelType { + + @Override + public CelKind kind() { + return CelKind.UNSPECIFIED; + } + + @Override + public String name() { + return "notset"; + } + + /** Do not use. This exists for compatibility reason with ListType from checked.proto. */ + @Internal + public static UnspecifiedType create() { + return new AutoValue_UnspecifiedType(); + } +} diff --git a/common/src/main/java/dev/cel/common/values/BUILD.bazel b/common/src/main/java/dev/cel/common/values/BUILD.bazel new file mode 100644 index 000000000..5ccc498fd --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/BUILD.bazel @@ -0,0 +1,428 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//common/values:__pkg__", + "//publish:__pkg__", + ], +) + +# keep sorted +CEL_VALUES_SOURCES = [ + "CelValueConverter.java", + "ErrorValue.java", + "NullValue.java", + "OpaqueValue.java", + "OptionalValue.java", + "SelectableValue.java", + "StructValue.java", +] + +# keep sorted +PROTO_MESSAGE_VALUE_SOURCES = [ + "ProtoCelValueConverter.java", + "ProtoMessageValue.java", +] + +java_library( + name = "cel_value", + srcs = ["CelValue.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/types:type_providers", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "cel_value_android", + srcs = ["CelValue.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/types:type_providers_android", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "cel_value_provider", + srcs = ["CelValueProvider.java"], + tags = [ + ], + deps = [ + "//common/values", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "cel_value_provider_android", + srcs = ["CelValueProvider.java"], + tags = [ + ], + deps = [ + "//common/values:values_android", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "combined_cel_value_provider", + srcs = [ + "CombinedCelValueProvider.java", + ], + tags = [ + ], + deps = [ + ":combined_cel_value_converter", + ":values", + "//common/values:cel_value_provider", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "combined_cel_value_provider_android", + srcs = [ + "CombinedCelValueProvider.java", + ], + tags = [ + ], + deps = [ + ":combined_cel_value_converter_android", + ":values_android", + "//common/values:cel_value_provider_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "combined_cel_value_converter", + srcs = [ + "CombinedCelValueConverter.java", + ], + tags = [ + ], + deps = [ + ":values", + "//common/annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +cel_android_library( + name = "combined_cel_value_converter_android", + srcs = [ + "CombinedCelValueConverter.java", + ], + tags = [ + ], + deps = [ + ":values_android", + "//common/annotations", + "@maven//:org_jspecify_jspecify", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "preadapted_list", + srcs = [ + "CelPreAdaptedList.java", + ], + tags = [ + ], + deps = ["//common/annotations"], +) + +cel_android_library( + name = "preadapted_list_android", + srcs = [ + "CelPreAdaptedList.java", + ], + tags = [ + ], + deps = ["//common/annotations"], +) + +java_library( + name = "values", + srcs = CEL_VALUES_SOURCES, + tags = [ + ], + deps = [ + ":cel_byte_string", + ":cel_value", + ":preadapted_list", + "//:auto_value", + "//common/annotations", + "//common/types", + "//common/types:type_providers", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "mutable_map_value", + srcs = ["MutableMapValue.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/exceptions:attribute_not_found", + "//common/types", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_value", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "mutable_map_value_android", + srcs = ["MutableMapValue.java"], + tags = [ + ], + deps = [ + ":cel_value_android", + "//common/annotations", + "//common/exceptions:attribute_not_found", + "//common/types:type_providers_android", + "//common/types:types_android", + "//common/values:values_android", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "values_android", + srcs = CEL_VALUES_SOURCES, + tags = [ + ], + deps = [ + ":cel_byte_string", + ":cel_value_android", + ":preadapted_list_android", + "//:auto_value", + "//common/annotations", + "//common/types:type_providers_android", + "//common/types:types_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "cel_byte_string", + srcs = ["CelByteString.java"], + # used_by_android + tags = [ + ], + deps = [ + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "base_proto_cel_value_converter", + srcs = ["BaseProtoCelValueConverter.java"], + tags = [ + ], + deps = [ + ":cel_byte_string", + "//common/annotations", + "//common/internal:proto_time_utils", + "//common/internal:well_known_proto", + "//common/values", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "base_proto_cel_value_converter_android", + srcs = ["BaseProtoCelValueConverter.java"], + tags = [ + ], + deps = [ + ":cel_byte_string", + ":values_android", + "//common/annotations", + "//common/internal:proto_time_utils_android", + "//common/internal:well_known_proto_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "proto_message_value", + srcs = PROTO_MESSAGE_VALUE_SOURCES, + tags = [ + ], + deps = [ + ":base_proto_cel_value_converter", + ":preadapted_list", + ":values", + "//:auto_value", + "//common:options", + "//common/annotations", + "//common/internal:cel_descriptor_pools", + "//common/internal:dynamic_proto", + "//common/internal:well_known_proto", + "//common/types", + "//common/types:type_providers", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "proto_message_value_provider", + srcs = ["ProtoMessageValueProvider.java"], + tags = [ + ], + deps = [ + ":proto_message_value", + "//common:options", + "//common/annotations", + "//common/internal:dynamic_proto", + "//common/internal:proto_message_factory", + "//common/values", + "//common/values:cel_value_provider", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "proto_message_lite_value", + srcs = [ + "ProtoLiteCelValueConverter.java", + "ProtoMessageLiteValue.java", + ], + tags = [ + ], + deps = [ + ":base_proto_cel_value_converter", + ":values", + "//:auto_value", + "//common/annotations", + "//common/internal:cel_lite_descriptor_pool", + "//common/internal:well_known_proto", + "//common/types", + "//common/types:type_providers", + "//common/values:cel_byte_string", + "//protobuf:cel_lite_descriptor", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +cel_android_library( + name = "proto_message_lite_value_android", + srcs = [ + "ProtoLiteCelValueConverter.java", + "ProtoMessageLiteValue.java", + ], + tags = [ + ], + deps = [ + ":base_proto_cel_value_converter_android", + ":values_android", + "//:auto_value", + "//common/annotations", + "//common/internal:cel_lite_descriptor_pool_android", + "//common/internal:well_known_proto_android", + "//common/types:type_providers_android", + "//common/types:types_android", + "//common/values:cel_byte_string", + "//protobuf:cel_lite_descriptor", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "proto_message_lite_value_provider", + srcs = ["ProtoMessageLiteValueProvider.java"], + tags = [ + ], + deps = [ + ":base_proto_message_value_provider", + ":proto_message_lite_value", + "//common/annotations", + "//common/internal:cel_lite_descriptor_pool", + "//common/internal:default_lite_descriptor_pool", + "//common/values:base_proto_cel_value_converter", + "//protobuf:cel_lite_descriptor", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +cel_android_library( + name = "proto_message_lite_value_provider_android", + srcs = ["ProtoMessageLiteValueProvider.java"], + tags = [ + ], + deps = [ + ":base_proto_message_value_provider_android", + ":proto_message_lite_value_android", + "//common/annotations", + "//common/internal:cel_lite_descriptor_pool_android", + "//common/internal:default_lite_descriptor_pool_android", + "//common/values:base_proto_cel_value_converter_android", + "//protobuf:cel_lite_descriptor", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "base_proto_message_value_provider", + srcs = ["BaseProtoMessageValueProvider.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/values:base_proto_cel_value_converter", + "//common/values:cel_value_provider", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "base_proto_message_value_provider_android", + srcs = ["BaseProtoMessageValueProvider.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/values:base_proto_cel_value_converter_android", + "//common/values:cel_value_provider_android", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) diff --git a/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java b/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java new file mode 100644 index 000000000..9fc218abe --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java @@ -0,0 +1,149 @@ +// Copyright 2025 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.values; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableMap.toImmutableMap; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.MessageLiteOrBuilder; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.internal.WellKnownProto; + +/** + * {@code BaseProtoCelValueConverter} contains the common logic for converting between native Java + * and protobuf objects to {@link CelValue}. This base class is inherited by {@code + * ProtoCelValueConverter} and {@code ProtoLiteCelValueConverter} to perform the conversion using + * full and lite variants of protobuf messages respectively. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public abstract class BaseProtoCelValueConverter extends CelValueConverter { + + /** {@inheritDoc} Protobuf semantics take precedence for conversion. */ + @Override + public Object toRuntimeValue(Object value) { + Preconditions.checkNotNull(value); + + if (value instanceof ByteString) { + return CelByteString.of(((ByteString) value).toByteArray()); + } else if (value instanceof com.google.protobuf.NullValue) { + return NullValue.NULL_VALUE; + } + + return super.toRuntimeValue(value); + } + + protected Object fromWellKnownProto(MessageLiteOrBuilder message, WellKnownProto wellKnownProto) { + switch (wellKnownProto) { + case JSON_VALUE: + return adaptJsonValue((Value) message); + case JSON_STRUCT_VALUE: + return adaptJsonStruct((Struct) message); + case JSON_LIST_VALUE: + return adaptJsonList((ListValue) message); + case DURATION: + return ProtoTimeUtils.toJavaDuration((Duration) message); + case TIMESTAMP: + return ProtoTimeUtils.toJavaInstant((Timestamp) message); + case BOOL_VALUE: + return normalizePrimitive(((BoolValue) message).getValue()); + case BYTES_VALUE: + return normalizePrimitive(((BytesValue) message).getValue().toByteArray()); + case DOUBLE_VALUE: + return normalizePrimitive(((DoubleValue) message).getValue()); + case FLOAT_VALUE: + return normalizePrimitive(((FloatValue) message).getValue()); + case INT32_VALUE: + return normalizePrimitive(((Int32Value) message).getValue()); + case INT64_VALUE: + return normalizePrimitive(((Int64Value) message).getValue()); + case STRING_VALUE: + return normalizePrimitive(((StringValue) message).getValue()); + case UINT32_VALUE: + return UnsignedLong.valueOf(((UInt32Value) message).getValue()); + case UINT64_VALUE: + return UnsignedLong.fromLongBits(((UInt64Value) message).getValue()); + case EMPTY: + return ImmutableMap.of(); + default: + throw new UnsupportedOperationException( + "Unsupported well known proto conversion - " + wellKnownProto); + } + } + + private Object adaptJsonValue(Value value) { + switch (value.getKindCase()) { + case BOOL_VALUE: + return normalizePrimitive(value.getBoolValue()); + case NUMBER_VALUE: + return normalizePrimitive(value.getNumberValue()); + case STRING_VALUE: + return normalizePrimitive(value.getStringValue()); + case LIST_VALUE: + return adaptJsonList(value.getListValue()); + case STRUCT_VALUE: + return adaptJsonStruct(value.getStructValue()); + case NULL_VALUE: + case KIND_NOT_SET: // Fall-through is intended + return NullValue.NULL_VALUE; + } + throw new UnsupportedOperationException( + "Unsupported Json to CelValue conversion: " + value.getKindCase()); + } + + private ImmutableList adaptJsonList(ListValue listValue) { + return listValue.getValuesList().stream().map(this::adaptJsonValue).collect(toImmutableList()); + } + + private ImmutableMap adaptJsonStruct(Struct struct) { + return struct.getFieldsMap().entrySet().stream() + .collect( + toImmutableMap( + e -> { + Object key = toRuntimeValue(e.getKey()); + if (!(key instanceof String)) { + throw new IllegalStateException( + "Expected a string type for the key, but instead got: " + key); + } + return (String) key; + }, + e -> adaptJsonValue(e.getValue()))); + } + + protected BaseProtoCelValueConverter() {} +} diff --git a/common/src/main/java/dev/cel/common/values/BaseProtoMessageValueProvider.java b/common/src/main/java/dev/cel/common/values/BaseProtoMessageValueProvider.java new file mode 100644 index 000000000..f42a16179 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/BaseProtoMessageValueProvider.java @@ -0,0 +1,31 @@ +// Copyright 2025 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.values; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; + +/** + * {@code BaseProtoMessageValueProvider} is a common parent to {@code ProtoMessageValueProvider} and + * {@code ProtoMessageLiteValueProvider}. + * + *

CEL-Java internals. Do not use. Use one of the inherited variants mentioned above. + */ +@Internal +@Immutable +public abstract class BaseProtoMessageValueProvider implements CelValueProvider { + + public abstract BaseProtoCelValueConverter protoCelValueConverter(); +} diff --git a/common/src/main/java/dev/cel/common/values/CelByteString.java b/common/src/main/java/dev/cel/common/values/CelByteString.java new file mode 100644 index 000000000..b37fc778d --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/CelByteString.java @@ -0,0 +1,159 @@ +// Copyright 2023 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.values; + +import com.google.errorprone.annotations.Immutable; +import java.nio.ByteBuffer; +import java.nio.charset.CharacterCodingException; +import java.nio.charset.CharsetDecoder; +import java.nio.charset.CodingErrorAction; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Comparator; + +/** CelByteString is an immutable sequence of a byte array. */ +@Immutable +@SuppressWarnings("Immutable") // We make defensive copies on the byte array. +public final class CelByteString { + private static final byte[] EMPTY_BYTE_ARRAY = new byte[0]; + public static final CelByteString EMPTY = new CelByteString(EMPTY_BYTE_ARRAY); + + private final byte[] data; + + private volatile int hash = 0; + + public static CelByteString of(byte[] buffer) { + if (buffer == null) { + throw new NullPointerException("buffer cannot be null"); + } + if (buffer.length == 0) { + return EMPTY; + } + return new CelByteString(buffer); + } + + public static CelByteString copyFromUtf8(String utf8String) { + return new CelByteString(utf8String.getBytes(StandardCharsets.UTF_8)); + } + + public static Comparator unsignedLexicographicalComparator() { + return UNSIGNED_LEXICOGRAPHICAL_COMPARATOR; + } + + public String toStringUtf8() { + return new String(data, StandardCharsets.UTF_8); + } + + /** Checks if the byte array is a valid utf-8 encoded text. */ + public boolean isValidUtf8() { + CharsetDecoder charsetDecoder = StandardCharsets.UTF_8.newDecoder(); + charsetDecoder.onMalformedInput(CodingErrorAction.REPORT); + charsetDecoder.onUnmappableCharacter(CodingErrorAction.REPORT); + + try { + charsetDecoder.decode(ByteBuffer.wrap(data)); + } catch (CharacterCodingException unused) { + return false; + } + return true; + } + + public int size() { + return data.length; + } + + public boolean isEmpty() { + return data.length == 0; + } + + public byte[] toByteArray() { + int size = size(); + if (size == 0) { + return EMPTY_BYTE_ARRAY; + } + + return Arrays.copyOf(data, size); + } + + public CelByteString concat(CelByteString other) { + byte[] result = new byte[data.length + other.data.length]; + System.arraycopy(data, 0, result, 0, data.length); + System.arraycopy(other.data, 0, result, data.length, other.data.length); + + return CelByteString.of(result); + } + + private CelByteString(byte[] buffer) { + data = Arrays.copyOf(buffer, buffer.length); + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + + if (!(o instanceof CelByteString)) { + return false; + } + + return Arrays.equals(data, ((CelByteString) o).data); + } + + /** + * Note that we do not use Arrays.hashCode directly due to its implementation using 31 as an odd + * prime, which is outdated and is more prone to hash collisions. This code is very similar to + * what AutoValue generates. + */ + @Override + public int hashCode() { + if (hash == 0) { + int h = 1; + h *= 1000003; + h ^= Arrays.hashCode(data); + if (h == 0) { + h = 1; + } + hash = h; + } + + return hash; + } + + @Override + public String toString() { + return toStringUtf8(); + } + + private static final Comparator UNSIGNED_LEXICOGRAPHICAL_COMPARATOR = + (former, latter) -> { + // Once we're on Java 9+, we can replace this whole thing with Arrays.compareUnsigned + byte[] formerBytes = former.toByteArray(); + byte[] latterBytes = latter.toByteArray(); + int minLength = Math.min(formerBytes.length, latterBytes.length); + + for (int i = 0; i < minLength; i++) { + int formerUnsigned = Byte.toUnsignedInt(formerBytes[i]); + int latterUnsigned = Byte.toUnsignedInt(latterBytes[i]); + int result = Integer.compare(formerUnsigned, latterUnsigned); + + if (result != 0) { + return result; + } + } + + return Integer.compare(formerBytes.length, latterBytes.length); + }; +} diff --git a/common/src/main/java/dev/cel/common/values/CelPreAdaptedList.java b/common/src/main/java/dev/cel/common/values/CelPreAdaptedList.java new file mode 100644 index 000000000..c0ff25e45 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/CelPreAdaptedList.java @@ -0,0 +1,49 @@ +// 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.values; + +import dev.cel.common.annotations.Internal; +import java.util.AbstractList; +import java.util.List; +import java.util.RandomAccess; + +/** + * A zero-allocation view over a list we know is already adapted. + * + *

This class purely exists as an optimization scheme to avoid redundant collection traversals in + * {@link CelValueConverter}, and is not intended for general use. + */ +@Internal +final class CelPreAdaptedList extends AbstractList implements RandomAccess { + private final List delegate; + + private CelPreAdaptedList(List delegate) { + this.delegate = delegate; + } + + static CelPreAdaptedList wrap(List safeList) { + return new CelPreAdaptedList<>(safeList); + } + + @Override + public E get(int index) { + return delegate.get(index); + } + + @Override + public int size() { + return delegate.size(); + } +} diff --git a/common/src/main/java/dev/cel/common/values/CelValue.java b/common/src/main/java/dev/cel/common/values/CelValue.java new file mode 100644 index 000000000..3a3ea6f2b --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/CelValue.java @@ -0,0 +1,45 @@ +// Copyright 2023 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.values; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import dev.cel.common.types.CelType; + +/** + * A representation of a CEL value for the runtime. Clients should never directly extend from + * CelValue. Clients may extend some subclasses of CelValue, such as StructValue if it has been + * explicitly designed and documented for extension. + */ +@Immutable +@Internal +public abstract class CelValue { + + /** + * The underlying value. This is typically the Java native value or a derived instance of CelValue + * (ex: an element in lists or key/value pair in maps). + */ + public abstract Object value(); + + /** Returns true if the {@link #value()} is a zero value for its type. */ + public abstract boolean isZeroValue(); + + /** The CelType that represents this value. */ + public abstract CelType celType(); + + // TOOD(b/309695452): Add CelEquals method + + public CelValue() {} +} diff --git a/common/src/main/java/dev/cel/common/values/CelValueConverter.java b/common/src/main/java/dev/cel/common/values/CelValueConverter.java new file mode 100644 index 000000000..20deef1d3 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/CelValueConverter.java @@ -0,0 +1,203 @@ +// Copyright 2023 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.values; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.RandomAccess; +import java.util.function.Function; + +/** + * {@code CelValueConverter} handles bidirectional conversion between native Java objects to {@link + * CelValue}. + * + *

CEL Library Internals. Do Not Use. + */ +@SuppressWarnings("unchecked") // Unchecked cast of generics due to type-erasure (ex: MapValue). +@Internal +@Immutable +public class CelValueConverter { + + private static final CelValueConverter DEFAULT_INSTANCE = new CelValueConverter(); + + @SuppressWarnings("Immutable") // Method reference is immutable + private final Function maybeUnwrapFunction; + + @SuppressWarnings("Immutable") // Method reference is immutable + private final Function toRuntimeValueFunction; + + public static CelValueConverter getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + /** + * Unwraps the {@code value} into its plain old Java Object representation. + * + *

The value may be a {@link CelValue}, a {@link Collection} or a {@link Map}. + */ + public Object maybeUnwrap(Object value) { + if (value instanceof CelValue || value instanceof CelPreAdaptedList) { + return value instanceof CelValue ? unwrap((CelValue) value) : value; + } + + return mapContainer(value, maybeUnwrapFunction); + } + + /** + * Maps a container (Collection or Map) by applying the provided mapper function to its elements. + * Returns the original value if it's not a supported container. + */ + protected Object mapContainer(Object value, Function mapper) { + + // Zero allocation path for standard lists that support O(1) indexing + // Generally, protobuf lists (backed by arrays) fall into this category + if (value instanceof List && value instanceof RandomAccess) { + List list = (List) value; + for (int i = 0; i < list.size(); i++) { + Object element = list.get(i); + Object mapped = mapper.apply(element); + + if (mapped != element) { + ImmutableList.Builder builder = + ImmutableList.builderWithExpectedSize(list.size()); + for (int j = 0; j < i; j++) { + builder.add(list.get(j)); + } + builder.add(mapped); + for (int j = i + 1; j < list.size(); j++) { + builder.add(mapper.apply(list.get(j))); + } + return builder.build(); + } + } + + // Zero allocations if unmodified + return value; + } + + // Fallback for lists that are unordered + if (value instanceof Collection) { + Collection collection = (Collection) value; + ImmutableList.Builder builder = + ImmutableList.builderWithExpectedSize(collection.size()); + for (Object element : collection) { + builder.add(mapper.apply(element)); + } + return builder.build(); + } + + if (value instanceof Map) { + Map map = (Map) value; + Iterator> iterator = map.entrySet().iterator(); + + while (iterator.hasNext()) { + Map.Entry entry = iterator.next(); + Object mappedKey = mapper.apply(entry.getKey()); + Object mappedValue = mapper.apply(entry.getValue()); + + if (mappedKey != entry.getKey() || mappedValue != entry.getValue()) { + ImmutableMap.Builder builder = + ImmutableMap.builderWithExpectedSize(map.size()); + + for (Map.Entry prevEntry : map.entrySet()) { + if (prevEntry.getKey() == entry.getKey()) { + break; + } + builder.put(mapper.apply(prevEntry.getKey()), mapper.apply(prevEntry.getValue())); + } + builder.put(mappedKey, mappedValue); + while (iterator.hasNext()) { + Map.Entry nextEntry = iterator.next(); + builder.put(mapper.apply(nextEntry.getKey()), mapper.apply(nextEntry.getValue())); + } + return builder.buildOrThrow(); + } + } + return value; + } + + return value; + } + + public Object toRuntimeValue(Object value) { + Preconditions.checkNotNull(value); + + if (value instanceof CelValue || value instanceof CelPreAdaptedList) { + return value; + } + + Object mapped = mapContainer(value, toRuntimeValueFunction); + if (mapped != value) { + return mapped; + } + + if (value instanceof Optional) { + Optional optionalValue = (Optional) value; + return optionalValue + .map(toRuntimeValueFunction) + .map(OptionalValue::create) + .orElse(OptionalValue.EMPTY); + } + + return normalizePrimitive(value); + } + + protected Object normalizePrimitive(Object value) { + Preconditions.checkNotNull(value); + + if (value instanceof Integer) { + return ((Integer) value).longValue(); + } else if (value instanceof byte[]) { + return CelByteString.of((byte[]) value); + } else if (value instanceof Float) { + return ((Float) value).doubleValue(); + } + + return value; + } + + /** Adapts a {@link CelValue} to a plain old Java Object. */ + private Object unwrap(CelValue celValue) { + Preconditions.checkNotNull(celValue); + + if (celValue instanceof OptionalValue) { + OptionalValue optionalValue = (OptionalValue) celValue; + if (optionalValue.isZeroValue()) { + return Optional.empty(); + } + + return Optional.of(maybeUnwrap(optionalValue.value())); + } + + if (celValue instanceof ErrorValue) { + return celValue; + } + + return celValue.value(); + } + + protected CelValueConverter() { + this.maybeUnwrapFunction = this::maybeUnwrap; + this.toRuntimeValueFunction = this::toRuntimeValue; + } +} diff --git a/common/src/main/java/dev/cel/common/values/CelValueProvider.java b/common/src/main/java/dev/cel/common/values/CelValueProvider.java new file mode 100644 index 000000000..20ae865e7 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/CelValueProvider.java @@ -0,0 +1,34 @@ +// Copyright 2023 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.values; + +import com.google.errorprone.annotations.Immutable; +import java.util.Map; +import java.util.Optional; + +/** CelValueProvider is an interface for constructing new struct values. */ +@Immutable +public interface CelValueProvider { + + /** + * Constructs a new struct value, or a primitive value in case the fully qualified struct name is + * a wrapper. + */ + Optional newValue(String structType, Map fields); + + default CelValueConverter celValueConverter() { + return CelValueConverter.getDefaultInstance(); + } +} diff --git a/common/src/main/java/dev/cel/common/values/CombinedCelValueConverter.java b/common/src/main/java/dev/cel/common/values/CombinedCelValueConverter.java new file mode 100644 index 000000000..46e5fc3f1 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/CombinedCelValueConverter.java @@ -0,0 +1,84 @@ +// 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.values; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.collect.ImmutableList; +import dev.cel.common.annotations.Internal; +import org.jspecify.annotations.Nullable; + +/** + * {@code CombinedCelValueConverter} delegates value conversion to a list of underlying {@link + * CelValueConverter}s. + */ +@Internal +public final class CombinedCelValueConverter extends CelValueConverter { + private final ImmutableList converters; + + public static CombinedCelValueConverter combine(ImmutableList converters) { + return new CombinedCelValueConverter(converters); + } + + private CombinedCelValueConverter(ImmutableList converters) { + this.converters = checkNotNull(converters); + } + + @Override + public @Nullable Object toRuntimeValue(Object value) { + if (value == null) { + return null; + } + + // Let the base class handle CelValues, Optionals, Collections, Maps, and primitives. + Object baseResult = super.toRuntimeValue(value); + if (baseResult != value) { + return baseResult; + } + + // If the base class left the object unchanged (e.g. a raw POJO), try the delegates. + for (CelValueConverter converter : converters) { + Object result = converter.toRuntimeValue(value); + if (result != value) { + return result; + } + } + + return value; + } + + @Override + public @Nullable Object maybeUnwrap(Object value) { + if (value == null) { + return null; + } + + // Let the base class handle standard unwrapping and container unrolling. + Object baseResult = super.maybeUnwrap(value); + if (baseResult != value) { + return baseResult; + } + + // Try delegates for specialized unwrapping. + for (CelValueConverter converter : converters) { + Object result = converter.maybeUnwrap(value); + if (result != value) { + return result; + } + } + + return value; + } +} diff --git a/common/src/main/java/dev/cel/common/values/CombinedCelValueProvider.java b/common/src/main/java/dev/cel/common/values/CombinedCelValueProvider.java new file mode 100644 index 000000000..d51c3afce --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/CombinedCelValueProvider.java @@ -0,0 +1,69 @@ +// Copyright 2025 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.values; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import java.util.Map; +import java.util.Optional; + +/** + * The {@link CombinedCelValueProvider} takes one or more {@link CelValueProvider} instances and + * attempts to create a {@link CelValue} instance for a given struct type name by calling each value + * provider in the order that they are provided to the constructor. + */ +@Immutable +public final class CombinedCelValueProvider implements CelValueProvider { + private final ImmutableList celValueProviders; + + /** Combines the provided first and second {@link CelValueProvider}. */ + public static CombinedCelValueProvider combine(CelValueProvider... providers) { + checkArgument(providers.length >= 2, "You must provide two or more providers"); + return new CombinedCelValueProvider(ImmutableList.copyOf(providers)); + } + + @Override + public Optional newValue(String structType, Map fields) { + for (CelValueProvider provider : celValueProviders) { + Optional newValue = provider.newValue(structType, fields); + if (newValue.isPresent()) { + return newValue; + } + } + + return Optional.empty(); + } + + @Override + public CelValueConverter celValueConverter() { + return CombinedCelValueConverter.combine( + celValueProviders.stream() + .map(CelValueProvider::celValueConverter) + .collect(toImmutableList())); + } + + /** Returns the underlying {@link CelValueProvider}s in order. */ + public ImmutableList valueProviders() { + return celValueProviders; + } + + private CombinedCelValueProvider(ImmutableList providers) { + celValueProviders = checkNotNull(providers); + } +} diff --git a/common/src/main/java/dev/cel/common/values/ErrorValue.java b/common/src/main/java/dev/cel/common/values/ErrorValue.java new file mode 100644 index 000000000..6bc04cda4 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/ErrorValue.java @@ -0,0 +1,54 @@ +// Copyright 2023 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.values; + +import com.google.auto.value.AutoValue; +import dev.cel.common.annotations.Internal; +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; + +/** + * CelErrorValue represent the intermediate error that occurs during evaluation in the form of Java + * exception. This is used to capture the error that occurs during a non-strict evaluation, which + * may or may not be propagated to the caller. + * + *

CEL Library Internals. Do Not Use. + */ +@AutoValue +@AutoValue.CopyAnnotations +@Internal +@SuppressWarnings( + "Immutable") // Exception is technically not immutable as the stacktrace is malleable. +public abstract class ErrorValue extends CelValue { + + public abstract long exprId(); + + @Override + public abstract Exception value(); + + @Override + public boolean isZeroValue() { + return false; + } + + @Override + public CelType celType() { + return SimpleType.ERROR; + } + + public static ErrorValue create(long exprId, Exception value) { + return new AutoValue_ErrorValue(exprId, value); + } +} diff --git a/common/src/main/java/dev/cel/common/values/MutableMapValue.java b/common/src/main/java/dev/cel/common/values/MutableMapValue.java new file mode 100644 index 000000000..706436b2e --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/MutableMapValue.java @@ -0,0 +1,146 @@ +// 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.values; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelAttributeNotFoundException; +import dev.cel.common.types.CelType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.SimpleType; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Optional; +import java.util.Set; + +/** + * A custom CelValue implementation that allows O(1) insertions for maps during comprehension. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +@Immutable +@SuppressWarnings("Immutable") // Intentionally mutable for performance reasons +public final class MutableMapValue extends CelValue + implements SelectableValue, Map { + private final Map internalMap; + private final CelType celType; + + public static MutableMapValue create(Map map) { + return new MutableMapValue(map); + } + + @Override + public int size() { + return internalMap.size(); + } + + @Override + public boolean isEmpty() { + return internalMap.isEmpty(); + } + + @Override + public boolean containsKey(Object key) { + return internalMap.containsKey(key); + } + + @Override + public boolean containsValue(Object value) { + return internalMap.containsValue(value); + } + + @Override + public Object get(Object key) { + return internalMap.get(key); + } + + @Override + public Object put(Object key, Object value) { + return internalMap.put(key, value); + } + + @Override + public Object remove(Object key) { + return internalMap.remove(key); + } + + @Override + public void putAll(Map m) { + internalMap.putAll(m); + } + + @Override + public void clear() { + internalMap.clear(); + } + + @Override + public Set keySet() { + return internalMap.keySet(); + } + + @Override + public Collection values() { + return internalMap.values(); + } + + @Override + public Set> entrySet() { + return internalMap.entrySet(); + } + + @Override + public Object select(Object field) { + Object val = internalMap.get(field); + if (val != null) { + return val; + } + if (!internalMap.containsKey(field)) { + throw CelAttributeNotFoundException.forMissingMapKey(field.toString()); + } + throw CelAttributeNotFoundException.of( + String.format("Map value cannot be null for key: %s", field)); + } + + @Override + public Optional find(Object field) { + if (internalMap.containsKey(field)) { + return Optional.ofNullable(internalMap.get(field)); + } + return Optional.empty(); + } + + @Override + public Object value() { + return this; + } + + @Override + public boolean isZeroValue() { + return internalMap.isEmpty(); + } + + @Override + public CelType celType() { + return celType; + } + + private MutableMapValue(Map map) { + this.internalMap = new LinkedHashMap<>(map); + this.celType = MapType.create(SimpleType.DYN, SimpleType.DYN); + } +} diff --git a/common/src/main/java/dev/cel/common/values/NullValue.java b/common/src/main/java/dev/cel/common/values/NullValue.java new file mode 100644 index 000000000..ca35c1550 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/NullValue.java @@ -0,0 +1,52 @@ +// Copyright 2023 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.values; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; + +/** + * NullValue represents the value 'null' of 'null_type' according to the CEL specification. One of + * its primary uses is to represent nulls in JSON data. + */ +@Immutable +public final class NullValue extends CelValue { + + /** Sentinel value for representing NULL. */ + public static final NullValue NULL_VALUE = new NullValue(); + + @Override + public NullValue value() { + return NULL_VALUE; + } + + @Override + public CelType celType() { + return SimpleType.NULL_TYPE; + } + + @Override + public boolean isZeroValue() { + return true; + } + + @Override + public String toString() { + return "NULL_VALUE"; + } + + private NullValue() {} +} diff --git a/common/src/main/java/dev/cel/common/values/OpaqueValue.java b/common/src/main/java/dev/cel/common/values/OpaqueValue.java new file mode 100644 index 000000000..8b3ac4574 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/OpaqueValue.java @@ -0,0 +1,79 @@ +// Copyright 2023 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.values; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.types.OpaqueType; + +/** + * OpaqueValue is the value representation of an {@link OpaqueType}. + * + *

Users may provide a custom opaque type that CEL can understand. Note that this is only + * supported for the Planner runtime. There are two primary modes of extending this class: + * + *

    + *
  • Direct Extension (Recommended): A domain object directly extends {@code OpaqueValue} + * and returns {@code this} for its {@link #value()} method. This approach allows the CEL + * engine to evaluate the object natively without stripping its type information, eliminating + * the need to register a custom {@link CelValueConverter}. + *
  • Wrapping: A domain object is wrapped into an {@code OpaqueValue} via the {@link + * #create(String, Object)} factory method. This is required when users cannot modify their + * existing POJOs to extend {@code OpaqueValue}. However, because the CEL runtime aggressively + * unwraps objects during evaluation, this mode necessitates implementing and registering a + * custom {@code CelValueConverter} that maps the unwrapped native Java object back into its + * corresponding {@code OpaqueValue}. + *
+ */ +@Immutable +public abstract class OpaqueValue extends CelValue { + + @Override + public boolean isZeroValue() { + return false; + } + + @Override + public abstract OpaqueType celType(); + + /** + * Creates an {@code OpaqueValue} by wrapping a domain object. + * + *

This method should only be used for the "Wrapping" extension mode (see class Javadoc) when + * users cannot modify their POJOs to directly extend {@code OpaqueValue}. Using this method + * necessitates implementing and registering a custom {@link CelValueConverter}. + * + * @param name The name of the opaque type. + * @param value The raw Java object to wrap. + */ + public static OpaqueValue create(String name, Object value) { + return new AutoValue_OpaqueValue_OpaqueValueWrapper( + checkNotNull(value), OpaqueType.create(name)); + } + + @AutoValue + @AutoValue.CopyAnnotations + @Immutable + @SuppressWarnings("Immutable") + abstract static class OpaqueValueWrapper extends OpaqueValue { + @Override + public abstract Object value(); + + @Override + public abstract OpaqueType celType(); + } +} diff --git a/common/src/main/java/dev/cel/common/values/OptionalValue.java b/common/src/main/java/dev/cel/common/values/OptionalValue.java new file mode 100644 index 000000000..9a2204fca --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/OptionalValue.java @@ -0,0 +1,107 @@ +// Copyright 2023 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.values; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** + * First-class support for CEL optionals. Supports similar semantics to java.util.Optional. Also + * supports optional field selection and presence tests against maps and structs using the optional + * syntax. + */ +@AutoValue +@Immutable(containerOf = "E") +public abstract class OptionalValue extends CelValue implements SelectableValue { + private static final OptionalType OPTIONAL_TYPE = OptionalType.create(SimpleType.DYN); + + /** Sentinel value representing an empty optional ('optional.none()' in CEL) */ + public static final OptionalValue EMPTY = empty(); + + // There is only one scenario where the value is null and it's `optional.none`. + abstract @Nullable E innerValue(); + + @Override + public E value() { + if (innerValue() == null) { + throw new NoSuchElementException("No value present"); + } + + return innerValue(); + } + + @Override + public boolean isZeroValue() { + return innerValue() == null; + } + + @Override + public OptionalType celType() { + return OPTIONAL_TYPE; + } + + /** + * Optional field selection on maps or structs. + * + *

    + *
  1. msg.?field -> has(msg.field) ? optional{msg.field} : optional.none() + *
  2. map[?key] -> key in map ? optional{map[key]} : optional.none() + *
+ */ + @Override + public OptionalValue select(T field) { + return find(field).orElse(EMPTY); + } + + @Override + @SuppressWarnings("unchecked") + public Optional> find(T field) { + if (isZeroValue()) { + return Optional.empty(); + } + + E value = value(); + if (value instanceof Map) { + Map map = (Map) value; + Object selectedVal = map.get(field); + if (selectedVal == null) { + return Optional.empty(); + } + + return Optional.of(OptionalValue.create((E) selectedVal)); + } else if (value instanceof SelectableValue) { + SelectableValue selectableValue = (SelectableValue) value; + return selectableValue.find(field).map(OptionalValue::create); + } + + return Optional.empty(); + } + + public static OptionalValue create(E value) { + Preconditions.checkNotNull(value); + return new AutoValue_OptionalValue<>(value); + } + + private static OptionalValue empty() { + return new AutoValue_OptionalValue<>(null); + } +} diff --git a/common/src/main/java/dev/cel/common/values/ProtoCelValueConverter.java b/common/src/main/java/dev/cel/common/values/ProtoCelValueConverter.java new file mode 100644 index 000000000..a4280e1ea --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/ProtoCelValueConverter.java @@ -0,0 +1,199 @@ +// Copyright 2023 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.values; + +import com.google.common.base.Preconditions; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Any; +import com.google.protobuf.Descriptors.EnumValueDescriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.MapEntry; +import com.google.protobuf.Message; +import com.google.protobuf.MessageLiteOrBuilder; +import com.google.protobuf.MessageOrBuilder; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.CelDescriptorPool; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.internal.WellKnownProto; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * {@code ProtoCelValueConverter} handles bidirectional conversion between native Java and protobuf + * objects to {@link CelValue}. This converter leverages descriptors, thus requires the full version + * of protobuf implementation. + * + *

Protobuf semantics take precedence for conversion. For example, CEL's TimestampValue will be + * converted into Protobuf's Timestamp instead of java.time.Instant. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public final class ProtoCelValueConverter extends BaseProtoCelValueConverter { + private final CelDescriptorPool celDescriptorPool; + private final DynamicProto dynamicProto; + private final CelOptions celOptions; + + /** Constructs a new instance of ProtoCelValueConverter. */ + public static ProtoCelValueConverter newInstance( + CelDescriptorPool celDescriptorPool, DynamicProto dynamicProto, CelOptions celOptions) { + return new ProtoCelValueConverter(celDescriptorPool, dynamicProto, celOptions); + } + + @Override + protected Object fromWellKnownProto(MessageLiteOrBuilder msg, WellKnownProto wellKnownProto) { + MessageOrBuilder message = (MessageOrBuilder) msg; + switch (wellKnownProto) { + case ANY_VALUE: + Message unpackedMessage; + try { + unpackedMessage = dynamicProto.unpack((Any) message); + } catch (InvalidProtocolBufferException e) { + throw new IllegalArgumentException( + "Unpacking failed for message: " + message.getDescriptorForType().getFullName(), e); + } + return toRuntimeValue(unpackedMessage); + case FIELD_MASK: + return ProtoMessageValue.create( + (Message) message, celDescriptorPool, this, celOptions.enableJsonFieldNames()); + default: + return super.fromWellKnownProto(message, wellKnownProto); + } + } + + @Override + public Object toRuntimeValue(Object value) { + if (value instanceof EnumValueDescriptor) { + // (b/178627883) Strongly typed enum is not supported yet + return Long.valueOf(((EnumValueDescriptor) value).getNumber()); + } + + if (value instanceof MessageOrBuilder) { + Message message; + if (value instanceof Message.Builder) { + message = ((Message.Builder) value).build(); + } else { + message = (Message) value; + } + + // Attempt to convert the proto from a dynamic message into a concrete message if possible. + if (message instanceof DynamicMessage) { + message = dynamicProto.maybeAdaptDynamicMessage((DynamicMessage) message); + } + + WellKnownProto wellKnownProto = + WellKnownProto.getByTypeName(message.getDescriptorForType().getFullName()).orElse(null); + if (wellKnownProto == null) { + return ProtoMessageValue.create( + message, celDescriptorPool, this, celOptions.enableJsonFieldNames()); + } + + return fromWellKnownProto(message, wellKnownProto); + } + + return super.toRuntimeValue(value); + } + + /** Adapts the protobuf message field. */ + @SuppressWarnings({"unchecked", "rawtypes"}) + public Object fromProtoMessageFieldToCelValue(Message message, FieldDescriptor fieldDescriptor) { + Preconditions.checkNotNull(message); + Preconditions.checkNotNull(fieldDescriptor); + + Object result = message.getField(fieldDescriptor); + switch (fieldDescriptor.getType()) { + case MESSAGE: + if (WellKnownProto.isWrapperType(fieldDescriptor.getMessageType().getFullName()) + && !fieldDescriptor.isRepeated() + && !message.hasField(fieldDescriptor)) { + // Special semantics for wrapper types per CEL specification. These all convert into null + // instead of the default value. + return NullValue.NULL_VALUE; + } + + if (fieldDescriptor.isMapField()) { + Map map = new HashMap<>(); + Object mapKey; + Object mapValue; + for (Object entry : ((List) result)) { + if (entry instanceof MapEntry) { + MapEntry mapEntry = (MapEntry) entry; + mapKey = mapEntry.getKey(); + mapValue = mapEntry.getValue(); + } else if (entry instanceof DynamicMessage) { + DynamicMessage dynamicMessage = (DynamicMessage) entry; + FieldDescriptor keyFieldDescriptor = + fieldDescriptor.getMessageType().findFieldByNumber(1); + FieldDescriptor valueFieldDescriptor = + fieldDescriptor.getMessageType().findFieldByNumber(2); + mapKey = dynamicMessage.getField(keyFieldDescriptor); + mapValue = dynamicMessage.getField(valueFieldDescriptor); + } else { + throw new IllegalStateException("Unexpected map field type: " + entry); + } + + map.put(mapKey, mapValue); + } + return toRuntimeValue(map); + } + + return toRuntimeValue(result); + case UINT32: + case FIXED32: + if (!fieldDescriptor.isRepeated()) { + return UnsignedLong.valueOf((int) result); + } + break; + case UINT64: + case FIXED64: + if (!fieldDescriptor.isRepeated()) { + return UnsignedLong.fromLongBits((long) result); + } + break; + default: + break; + } + + if (fieldDescriptor.isRepeated()) { + switch (fieldDescriptor.getType()) { + case INT64: + case BOOL: + case STRING: + case DOUBLE: + return CelPreAdaptedList.wrap((List) result); + default: + break; + } + } + + return toRuntimeValue(result); + } + + private ProtoCelValueConverter( + CelDescriptorPool celDescriptorPool, DynamicProto dynamicProto, CelOptions celOptions) { + Preconditions.checkNotNull(celDescriptorPool); + Preconditions.checkNotNull(dynamicProto); + Preconditions.checkNotNull(celOptions); + this.celDescriptorPool = celDescriptorPool; + this.dynamicProto = dynamicProto; + this.celOptions = celOptions; + } +} diff --git a/common/src/main/java/dev/cel/common/values/ProtoLiteCelValueConverter.java b/common/src/main/java/dev/cel/common/values/ProtoLiteCelValueConverter.java new file mode 100644 index 000000000..64d6ec1d4 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/ProtoLiteCelValueConverter.java @@ -0,0 +1,412 @@ +// Copyright 2025 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.values; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.auto.value.AutoValue; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Defaults; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Multimap; +import com.google.common.collect.Multimaps; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.CodedInputStream; +import com.google.protobuf.ExtensionRegistryLite; +import com.google.protobuf.MessageLite; +import com.google.protobuf.MessageLiteOrBuilder; +import com.google.protobuf.WireFormat; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.CelLiteDescriptorPool; +import dev.cel.common.internal.WellKnownProto; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.EncodingType; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.JavaType; +import dev.cel.protobuf.CelLiteDescriptor.MessageLiteDescriptor; +import java.io.IOException; +import java.util.AbstractMap; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.TreeMap; + +/** + * {@code ProtoLiteCelValueConverter} handles bidirectional conversion between native Java and + * protobuf objects to {@link CelValue}. This converter is specifically designed for use with + * lite-variants of protobuf messages. + * + *

Protobuf semantics take precedence for conversion. For example, CEL's TimestampValue will be + * converted into Protobuf's Timestamp instead of java.time.Instant. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public final class ProtoLiteCelValueConverter extends BaseProtoCelValueConverter { + private final CelLiteDescriptorPool descriptorPool; + + public static ProtoLiteCelValueConverter newInstance( + CelLiteDescriptorPool celLiteDescriptorPool) { + return new ProtoLiteCelValueConverter(celLiteDescriptorPool); + } + + private static Object readPrimitiveField( + CodedInputStream inputStream, FieldLiteDescriptor fieldDescriptor) throws IOException { + switch (fieldDescriptor.getProtoFieldType()) { + case SINT32: + return inputStream.readSInt32(); + case SINT64: + return inputStream.readSInt64(); + case INT32: + case ENUM: + return inputStream.readInt32(); + case INT64: + return inputStream.readInt64(); + case UINT32: + return UnsignedLong.fromLongBits(inputStream.readUInt32()); + case UINT64: + return UnsignedLong.fromLongBits(inputStream.readUInt64()); + case BOOL: + return inputStream.readBool(); + case FLOAT: + case FIXED32: + case SFIXED32: + return readFixed32BitField(inputStream, fieldDescriptor); + case DOUBLE: + case FIXED64: + case SFIXED64: + return readFixed64BitField(inputStream, fieldDescriptor); + default: + throw new IllegalStateException( + "Unexpected field type: " + fieldDescriptor.getProtoFieldType()); + } + } + + private static Object readFixed32BitField( + CodedInputStream inputStream, FieldLiteDescriptor fieldDescriptor) throws IOException { + switch (fieldDescriptor.getProtoFieldType()) { + case FLOAT: + return inputStream.readFloat(); + case FIXED32: + case SFIXED32: + return inputStream.readRawLittleEndian32(); + default: + throw new IllegalStateException( + "Unexpected field type: " + fieldDescriptor.getProtoFieldType()); + } + } + + private static Object readFixed64BitField( + CodedInputStream inputStream, FieldLiteDescriptor fieldDescriptor) throws IOException { + switch (fieldDescriptor.getProtoFieldType()) { + case DOUBLE: + return inputStream.readDouble(); + case FIXED64: + case SFIXED64: + return inputStream.readRawLittleEndian64(); + default: + throw new IllegalStateException( + "Unexpected field type: " + fieldDescriptor.getProtoFieldType()); + } + } + + private Object readLengthDelimitedField( + CodedInputStream inputStream, FieldLiteDescriptor fieldDescriptor) throws IOException { + FieldLiteDescriptor.Type fieldType = fieldDescriptor.getProtoFieldType(); + + switch (fieldType) { + case BYTES: + return inputStream.readBytes(); + case MESSAGE: + MessageLite.Builder builder = + getDefaultMessageBuilder(fieldDescriptor.getFieldProtoTypeName()); + + inputStream.readMessage(builder, ExtensionRegistryLite.getEmptyRegistry()); + return builder.build(); + case STRING: + return inputStream.readStringRequireUtf8(); + default: + throw new IllegalStateException("Unexpected field type: " + fieldType); + } + } + + private MessageLite.Builder getDefaultMessageBuilder(String protoTypeName) { + return descriptorPool.getDescriptorOrThrow(protoTypeName).newMessageBuilder(); + } + + Object getDefaultCelValue(String protoTypeName, String fieldName) { + MessageLiteDescriptor messageDescriptor = descriptorPool.getDescriptorOrThrow(protoTypeName); + FieldLiteDescriptor fieldDescriptor = messageDescriptor.getByFieldNameOrThrow(fieldName); + + Object defaultValue = getDefaultValue(fieldDescriptor); + + return toRuntimeValue(defaultValue); + } + + @Override + @SuppressWarnings("LiteProtoToString") // No alternative identifier to use. Debug only info is OK. + public Object toRuntimeValue(Object value) { + checkNotNull(value); + if (value instanceof MessageLite) { + MessageLite msg = (MessageLite) value; + + MessageLiteDescriptor descriptor = + descriptorPool + .findDescriptor(msg) + .orElseThrow( + () -> new NoSuchElementException("Could not find a descriptor for: " + msg)); + WellKnownProto wellKnownProto = + WellKnownProto.getByTypeName(descriptor.getProtoTypeName()).orElse(null); + + if (wellKnownProto == null) { + return ProtoMessageLiteValue.create(msg, descriptor.getProtoTypeName(), this); + } + + return fromWellKnownProto(msg, wellKnownProto); + } + + return super.toRuntimeValue(value); + } + + @Override + protected Object fromWellKnownProto(MessageLiteOrBuilder msg, WellKnownProto wellKnownProto) { + if (wellKnownProto == WellKnownProto.FIELD_MASK) { + MessageLite message = (MessageLite) msg; + MessageLiteDescriptor descriptor = + descriptorPool + .findDescriptor(message) + .orElseThrow( + () -> new NoSuchElementException("Could not find a descriptor for: " + message)); + return ProtoMessageLiteValue.create(message, descriptor.getProtoTypeName(), this); + } + + return super.fromWellKnownProto(msg, wellKnownProto); + } + + private Object getDefaultValue(FieldLiteDescriptor fieldDescriptor) { + EncodingType encodingType = fieldDescriptor.getEncodingType(); + switch (encodingType) { + case LIST: + return ImmutableList.of(); + case MAP: + return ImmutableMap.of(); + case SINGULAR: + return getScalarDefaultValue(fieldDescriptor); + } + throw new IllegalStateException("Unexpected encoding type: " + encodingType); + } + + private Object getScalarDefaultValue(FieldLiteDescriptor fieldDescriptor) { + JavaType type = fieldDescriptor.getJavaType(); + switch (type) { + case INT: + return fieldDescriptor.getProtoFieldType().equals(FieldLiteDescriptor.Type.UINT32) + ? UnsignedLong.ZERO + : Defaults.defaultValue(long.class); + case LONG: + return fieldDescriptor.getProtoFieldType().equals(FieldLiteDescriptor.Type.UINT64) + ? UnsignedLong.ZERO + : Defaults.defaultValue(long.class); + case ENUM: + return Defaults.defaultValue(long.class); + case FLOAT: + return Defaults.defaultValue(float.class); + case DOUBLE: + return Defaults.defaultValue(double.class); + case BOOLEAN: + return Defaults.defaultValue(boolean.class); + case STRING: + return ""; + case BYTE_STRING: + return CelByteString.EMPTY; + case MESSAGE: + if (WellKnownProto.isWrapperType(fieldDescriptor.getFieldProtoTypeName())) { + return NullValue.NULL_VALUE; + } + + return getDefaultMessageBuilder(fieldDescriptor.getFieldProtoTypeName()).build(); + } + throw new IllegalStateException("Unexpected java type: " + type); + } + + private ImmutableList readPackedRepeatedFields( + CodedInputStream inputStream, FieldLiteDescriptor fieldDescriptor) throws IOException { + int length = inputStream.readInt32(); + int oldLimit = inputStream.pushLimit(length); + ImmutableList.Builder builder = ImmutableList.builder(); + while (inputStream.getBytesUntilLimit() > 0) { + builder.add(readPrimitiveField(inputStream, fieldDescriptor)); + } + inputStream.popLimit(oldLimit); + return builder.build(); + } + + private Map.Entry readSingleMapEntry( + CodedInputStream inputStream, FieldLiteDescriptor fieldDescriptor) throws IOException { + ImmutableMap singleMapEntry = + readAllFields(inputStream.readByteArray(), fieldDescriptor.getFieldProtoTypeName()) + .values(); + Object key = checkNotNull(singleMapEntry.get("key")); + Object value = checkNotNull(singleMapEntry.get("value")); + + return new AbstractMap.SimpleEntry<>(key, value); + } + + @VisibleForTesting + MessageFields readAllFields(byte[] bytes, String protoTypeName) throws IOException { + MessageLiteDescriptor messageDescriptor = descriptorPool.getDescriptorOrThrow(protoTypeName); + CodedInputStream inputStream = CodedInputStream.newInstance(bytes); + + Multimap unknownFields = + Multimaps.newMultimap(new TreeMap<>(), ArrayList::new); + ImmutableMap.Builder fieldValues = ImmutableMap.builder(); + Map> repeatedFieldValues = new LinkedHashMap<>(); + Map> mapFieldValues = new LinkedHashMap<>(); + for (int tag = inputStream.readTag(); tag != 0; tag = inputStream.readTag()) { + int tagWireType = WireFormat.getTagWireType(tag); + int fieldNumber = WireFormat.getTagFieldNumber(tag); + FieldLiteDescriptor fieldDescriptor = + messageDescriptor.findByFieldNumber(fieldNumber).orElse(null); + if (fieldDescriptor == null) { + unknownFields.put(fieldNumber, readUnknownField(tagWireType, inputStream)); + continue; + } + + Object payload; + switch (tagWireType) { + case WireFormat.WIRETYPE_VARINT: + payload = readPrimitiveField(inputStream, fieldDescriptor); + break; + case WireFormat.WIRETYPE_FIXED32: + payload = readFixed32BitField(inputStream, fieldDescriptor); + break; + case WireFormat.WIRETYPE_FIXED64: + payload = readFixed64BitField(inputStream, fieldDescriptor); + break; + case WireFormat.WIRETYPE_LENGTH_DELIMITED: + EncodingType encodingType = fieldDescriptor.getEncodingType(); + switch (encodingType) { + case LIST: + if (fieldDescriptor.getIsPacked()) { + payload = readPackedRepeatedFields(inputStream, fieldDescriptor); + } else { + FieldLiteDescriptor.Type protoFieldType = fieldDescriptor.getProtoFieldType(); + boolean isLenDelimited = + protoFieldType.equals(FieldLiteDescriptor.Type.MESSAGE) + || protoFieldType.equals(FieldLiteDescriptor.Type.STRING) + || protoFieldType.equals(FieldLiteDescriptor.Type.BYTES); + if (!isLenDelimited) { + throw new IllegalStateException( + "Unexpected field type encountered for LEN-Delimited record: " + + protoFieldType); + } + + payload = readLengthDelimitedField(inputStream, fieldDescriptor); + } + break; + case MAP: + Map fieldMap = + mapFieldValues.computeIfAbsent(fieldNumber, (unused) -> new LinkedHashMap<>()); + Map.Entry mapEntry = readSingleMapEntry(inputStream, fieldDescriptor); + fieldMap.put(mapEntry.getKey(), mapEntry.getValue()); + payload = fieldMap; + break; + default: + payload = readLengthDelimitedField(inputStream, fieldDescriptor); + break; + } + break; + case WireFormat.WIRETYPE_START_GROUP: + case WireFormat.WIRETYPE_END_GROUP: + // TODO: Support groups + throw new UnsupportedOperationException("Groups are not supported"); + default: + throw new IllegalArgumentException("Unexpected wire type: " + tagWireType); + } + + if (fieldDescriptor.getEncodingType().equals(EncodingType.LIST)) { + String fieldName = fieldDescriptor.getFieldName(); + List repeatedValues = + repeatedFieldValues.computeIfAbsent( + fieldNumber, + (unused) -> { + List newList = new ArrayList<>(); + fieldValues.put(fieldName, newList); + return newList; + }); + + if (payload instanceof Collection) { + repeatedValues.addAll((Collection) payload); + } else { + repeatedValues.add(payload); + } + } else { + fieldValues.put(fieldDescriptor.getFieldName(), payload); + } + } + + // Protobuf encoding follows a "last one wins" semantics. This means for duplicated fields, + // we accept the last value encountered. + return MessageFields.create(fieldValues.buildKeepingLast(), unknownFields); + } + + ImmutableMap readAllFields(MessageLite msg, String protoTypeName) + throws IOException { + return readAllFields(msg.toByteArray(), protoTypeName).values(); + } + + private static Object readUnknownField(int tagWireType, CodedInputStream inputStream) + throws IOException { + switch (tagWireType) { + case WireFormat.WIRETYPE_VARINT: + return inputStream.readInt64(); + case WireFormat.WIRETYPE_FIXED64: + return inputStream.readFixed64(); + case WireFormat.WIRETYPE_LENGTH_DELIMITED: + return inputStream.readBytes(); + case WireFormat.WIRETYPE_FIXED32: + return inputStream.readFixed32(); + case WireFormat.WIRETYPE_START_GROUP: + case WireFormat.WIRETYPE_END_GROUP: + // TODO: Support groups + throw new UnsupportedOperationException("Groups are not supported"); + default: + throw new IllegalArgumentException("Unknown wire type: " + tagWireType); + } + } + + @AutoValue + @SuppressWarnings("AutoValueImmutableFields") // Unknowns are inaccessible to users. + abstract static class MessageFields { + + abstract ImmutableMap values(); + + abstract Multimap unknowns(); + + static MessageFields create( + ImmutableMap fieldValues, Multimap unknownFields) { + return new AutoValue_ProtoLiteCelValueConverter_MessageFields(fieldValues, unknownFields); + } + } + + private ProtoLiteCelValueConverter(CelLiteDescriptorPool celLiteDescriptorPool) { + this.descriptorPool = celLiteDescriptorPool; + } +} diff --git a/common/src/main/java/dev/cel/common/values/ProtoMessageLiteValue.java b/common/src/main/java/dev/cel/common/values/ProtoMessageLiteValue.java new file mode 100644 index 000000000..2e4d980c7 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/ProtoMessageLiteValue.java @@ -0,0 +1,82 @@ +// Copyright 2025 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.values; + +import com.google.auto.value.AutoValue; +import com.google.auto.value.extension.memoized.Memoized; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.MessageLite; +import dev.cel.common.types.CelType; +import dev.cel.common.types.StructTypeReference; +import java.io.IOException; +import java.util.Optional; + +/** + * ProtoMessageLiteValue is a struct value with protobuf support for {@link MessageLite}. + * Specifically, it does not rely on full message descriptors, thus field selections can be + * performed without the reliance of proto-reflection. + * + *

If the codebase has access to full protobuf messages with descriptors, use {@code + * ProtoMessageValue} instead. + */ +@AutoValue +@Immutable +public abstract class ProtoMessageLiteValue extends StructValue { + + @Override + public abstract MessageLite value(); + + @Override + public abstract CelType celType(); + + abstract ProtoLiteCelValueConverter protoLiteCelValueConverter(); + + @Memoized + ImmutableMap fieldValues() { + try { + return protoLiteCelValueConverter().readAllFields(value(), celType().name()); + } catch (IOException e) { + throw new IllegalStateException("Unable to read message fields for " + celType().name(), e); + } + } + + @Override + public boolean isZeroValue() { + return value().getDefaultInstanceForType().equals(value()); + } + + @Override + public Object select(String field) { + return find(field) + .orElseGet(() -> protoLiteCelValueConverter().getDefaultCelValue(celType().name(), field)); + } + + @Override + public Optional find(String field) { + Object fieldValue = fieldValues().get(field); + return Optional.ofNullable(fieldValue) + .map(value -> protoLiteCelValueConverter().toRuntimeValue(fieldValue)); + } + + public static ProtoMessageLiteValue create( + MessageLite value, String typeName, ProtoLiteCelValueConverter protoLiteCelValueConverter) { + Preconditions.checkNotNull(value); + Preconditions.checkNotNull(typeName); + return new AutoValue_ProtoMessageLiteValue( + value, StructTypeReference.create(typeName), protoLiteCelValueConverter); + } +} diff --git a/common/src/main/java/dev/cel/common/values/ProtoMessageLiteValueProvider.java b/common/src/main/java/dev/cel/common/values/ProtoMessageLiteValueProvider.java new file mode 100644 index 000000000..041d850a6 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/ProtoMessageLiteValueProvider.java @@ -0,0 +1,78 @@ +// Copyright 2025 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.values; + +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.MessageLite; +import dev.cel.common.annotations.Beta; +import dev.cel.common.internal.CelLiteDescriptorPool; +import dev.cel.common.internal.DefaultLiteDescriptorPool; +import dev.cel.protobuf.CelLiteDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.MessageLiteDescriptor; +import java.util.Map; +import java.util.Optional; +import java.util.Set; + +/** + * {@code ProtoMessageValueProvider} constructs new instances of protobuf lite-message given its + * fully qualified name and its fields to populate. + */ +@Immutable +@Beta +public class ProtoMessageLiteValueProvider extends BaseProtoMessageValueProvider { + private final CelLiteDescriptorPool descriptorPool; + private final ProtoLiteCelValueConverter protoLiteCelValueConverter; + + @Override + public BaseProtoCelValueConverter protoCelValueConverter() { + return protoLiteCelValueConverter; + } + + @Override + public Optional newValue(String structType, Map fields) { + MessageLiteDescriptor descriptor = descriptorPool.findDescriptor(structType).orElse(null); + if (descriptor == null) { + return Optional.empty(); + } + + if (!fields.isEmpty()) { + // TODO: Add support for this + throw new UnsupportedOperationException( + "Message creation with prepopulated fields is not supported yet."); + } + + MessageLite message = descriptor.newMessageBuilder().build(); + return Optional.of(protoLiteCelValueConverter.toRuntimeValue(message)); + } + + public static ProtoMessageLiteValueProvider newInstance(CelLiteDescriptor... descriptors) { + return newInstance(ImmutableSet.copyOf(descriptors)); + } + + public static ProtoMessageLiteValueProvider newInstance(Set descriptors) { + DefaultLiteDescriptorPool descriptorPool = + DefaultLiteDescriptorPool.newInstance(ImmutableSet.copyOf(descriptors)); + ProtoLiteCelValueConverter protoLiteCelValueConverter = + ProtoLiteCelValueConverter.newInstance(descriptorPool); + return new ProtoMessageLiteValueProvider(protoLiteCelValueConverter, descriptorPool); + } + + private ProtoMessageLiteValueProvider( + ProtoLiteCelValueConverter protoLiteCelValueConverter, CelLiteDescriptorPool descriptorPool) { + this.protoLiteCelValueConverter = protoLiteCelValueConverter; + this.descriptorPool = descriptorPool; + } +} diff --git a/common/src/main/java/dev/cel/common/values/ProtoMessageValue.java b/common/src/main/java/dev/cel/common/values/ProtoMessageValue.java new file mode 100644 index 000000000..627bd2c1d --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/ProtoMessageValue.java @@ -0,0 +1,117 @@ +// Copyright 2023 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.values; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Message; +import dev.cel.common.internal.CelDescriptorPool; +import dev.cel.common.types.CelType; +import dev.cel.common.types.StructTypeReference; +import java.util.Optional; + +/** ProtoMessageValue is a struct value with protobuf support. */ +@AutoValue +@Immutable +public abstract class ProtoMessageValue extends StructValue { + + @Override + public abstract Message value(); + + @Override + public abstract CelType celType(); + + abstract CelDescriptorPool celDescriptorPool(); + + abstract ProtoCelValueConverter protoCelValueConverter(); + + abstract boolean enableJsonFieldNames(); + + @Override + public boolean isZeroValue() { + return value().getDefaultInstanceForType().equals(value()); + } + + @Override + public Object select(String field) { + FieldDescriptor fieldDescriptor = + findField(celDescriptorPool(), value().getDescriptorForType(), field); + + return protoCelValueConverter().fromProtoMessageFieldToCelValue(value(), fieldDescriptor); + } + + @Override + public Optional find(String field) { + FieldDescriptor fieldDescriptor = + findField(celDescriptorPool(), value().getDescriptorForType(), field); + + // Selecting a field on a protobuf message yields a default value even if the field is not + // declared. Therefore, we must exhaustively test whether they are actually declared. + if (fieldDescriptor.isRepeated()) { + if (value().getRepeatedFieldCount(fieldDescriptor) == 0) { + return Optional.empty(); + } + } else if (!value().hasField(fieldDescriptor)) { + return Optional.empty(); + } + + return Optional.of( + protoCelValueConverter().fromProtoMessageFieldToCelValue(value(), fieldDescriptor)); + } + + public static ProtoMessageValue create( + Message value, + CelDescriptorPool celDescriptorPool, + ProtoCelValueConverter protoCelValueConverter, + boolean enableJsonFieldNames) { + Preconditions.checkNotNull(value); + Preconditions.checkNotNull(celDescriptorPool); + Preconditions.checkNotNull(protoCelValueConverter); + return new AutoValue_ProtoMessageValue( + value, + StructTypeReference.create(value.getDescriptorForType().getFullName()), + celDescriptorPool, + protoCelValueConverter, + enableJsonFieldNames); + } + + private FieldDescriptor findField( + CelDescriptorPool celDescriptorPool, Descriptor descriptor, String fieldName) { + if (enableJsonFieldNames()) { + for (FieldDescriptor fd : descriptor.getFields()) { + if (fd.getJsonName().equals(fieldName)) { + return fd; + } + } + } + + FieldDescriptor fieldDescriptor = descriptor.findFieldByName(fieldName); + if (fieldDescriptor != null) { + return fieldDescriptor; + } + + return celDescriptorPool + .findExtensionDescriptor(descriptor, fieldName) + .orElseThrow( + () -> + new IllegalArgumentException( + String.format( + "field '%s' is not declared in message '%s'", + fieldName, descriptor.getFullName()))); + } +} diff --git a/common/src/main/java/dev/cel/common/values/ProtoMessageValueProvider.java b/common/src/main/java/dev/cel/common/values/ProtoMessageValueProvider.java new file mode 100644 index 000000000..7beb40c61 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/ProtoMessageValueProvider.java @@ -0,0 +1,108 @@ +// Copyright 2023 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.values; + +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Message; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.internal.ProtoAdapter; +import dev.cel.common.internal.ProtoMessageFactory; +import java.util.Map; +import java.util.Optional; + +/** + * {@link ProtoMessageValueProvider} constructs new instances of a protobuf message given its fully + * qualified name and its fields to populate. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public class ProtoMessageValueProvider implements CelValueProvider { + private final ProtoAdapter protoAdapter; + private final ProtoMessageFactory protoMessageFactory; + private final ProtoCelValueConverter protoCelValueConverter; + private final CelOptions celOptions; + + @Override + public CelValueConverter celValueConverter() { + return protoCelValueConverter; + } + + @Override + public Optional newValue(String structType, Map fields) { + Message.Builder builder = protoMessageFactory.newBuilder(structType).orElse(null); + if (builder == null) { + return Optional.empty(); + } + try { + Descriptor descriptor = builder.getDescriptorForType(); + for (Map.Entry entry : fields.entrySet()) { + FieldDescriptor fieldDescriptor = findField(descriptor, entry.getKey()); + Optional fieldValue = + protoAdapter.adaptValueToFieldType( + fieldDescriptor, entry.getValue()); // TODO: Decouple ProtoAdapter + fieldValue.ifPresent(o -> builder.setField(fieldDescriptor, o)); + } + + return Optional.of(protoCelValueConverter.toRuntimeValue(builder.build())); + } catch (ArrayIndexOutOfBoundsException e) { + throw new IllegalArgumentException(e.getMessage()); + } + } + + private FieldDescriptor findField(Descriptor descriptor, String fieldName) { + if (celOptions.enableJsonFieldNames()) { + for (FieldDescriptor fd : descriptor.getFields()) { + if (fd.getJsonName().equals(fieldName)) { + return fd; + } + } + } + + FieldDescriptor fieldDescriptor = descriptor.findFieldByName(fieldName); + if (fieldDescriptor != null) { + return fieldDescriptor; + } + + return protoMessageFactory + .getDescriptorPool() + .findExtensionDescriptor(descriptor, fieldName) + .orElseThrow( + () -> + new IllegalArgumentException( + String.format( + "field '%s' is not declared in message '%s'", + fieldName, descriptor.getFullName()))); + } + + public static ProtoMessageValueProvider newInstance( + CelOptions celOptions, DynamicProto dynamicProto) { + return new ProtoMessageValueProvider(celOptions, dynamicProto); + } + + private ProtoMessageValueProvider(CelOptions celOptions, DynamicProto dynamicProto) { + this.protoMessageFactory = dynamicProto.getProtoMessageFactory(); + this.protoCelValueConverter = + ProtoCelValueConverter.newInstance( + protoMessageFactory.getDescriptorPool(), dynamicProto, celOptions); + this.protoAdapter = new ProtoAdapter(dynamicProto, celOptions); + this.celOptions = celOptions; + } +} diff --git a/common/src/main/java/dev/cel/common/values/SelectableValue.java b/common/src/main/java/dev/cel/common/values/SelectableValue.java new file mode 100644 index 000000000..4db43d144 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/SelectableValue.java @@ -0,0 +1,37 @@ +// Copyright 2023 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.values; + +import java.util.Optional; + +/** + * SelectableValue is an interface for representing a value that supports field selection and + * presence tests. Few examples are structs, protobuf messages, maps and optional values. + */ +public interface SelectableValue { + + /** + * Performs field selection. The behavior depends on the concrete implementation of the value + * being selected. For structs and maps, this must throw an exception if the field does not exist. + * For optional values, this will return an {@code optional.none()}. + */ + Object select(T field); + + /** + * Finds the field. This will return an {@link Optional#empty()} if the field does not exist. This + * can be used for presence testing. + */ + Optional find(T field); +} diff --git a/common/src/main/java/dev/cel/common/values/StructValue.java b/common/src/main/java/dev/cel/common/values/StructValue.java new file mode 100644 index 000000000..aa44ec420 --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/StructValue.java @@ -0,0 +1,39 @@ +// Copyright 2023 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.values; + +import com.google.errorprone.annotations.Immutable; + +/** + * StructValue is a representation of a structured object with typed properties. + * + *

Users may extend from this class to provide a custom struct that CEL can understand by + * wrapping a native Java object (e.g., a POJO or a Map). Custom struct implementations must provide + * all functionalities denoted in the CEL specification, such as field selection, presence testing + * and new object creation. + * + *

For an expression `e` selecting a field `f`, `e.f` must throw an exception if `f` does not + * exist in the struct (i.e: hasField returns false). If the field exists but is not set, the + * implementation should return an appropriate default value based on the struct's semantics. + * + * @param The type of the field identifier. Only {@code String} is supported for now, but we may + * extend support to other types in the future. + * @param The type of the wrapped native object. + */ +@Immutable +public abstract class StructValue extends CelValue implements SelectableValue { + @Override + public abstract V value(); +} diff --git a/common/src/main/resources/testdata/proto3/BUILD.bazel b/common/src/main/resources/testdata/proto3/BUILD.bazel new file mode 100644 index 000000000..a7db554d5 --- /dev/null +++ b/common/src/main/resources/testdata/proto3/BUILD.bazel @@ -0,0 +1,29 @@ +load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library") +load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//common/resources/testdata/proto3:__pkg__", + ], +) + +filegroup( + name = "test_all_types_file_descriptor_set", + srcs = ["test_all_types.fds"], +) + +proto_library( + name = "standalone_global_enum_proto", + srcs = ["standalone_global_enum.proto"], +) + +java_proto_library( + name = "standalone_global_enum_java_proto", + tags = [ + ], + deps = [":standalone_global_enum_proto"], +) diff --git a/common/src/main/resources/testdata/proto3/standalone_global_enum.proto b/common/src/main/resources/testdata/proto3/standalone_global_enum.proto new file mode 100644 index 000000000..3a6028f77 --- /dev/null +++ b/common/src/main/resources/testdata/proto3/standalone_global_enum.proto @@ -0,0 +1,28 @@ +// Copyright 2022 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. + +syntax = "proto3"; + +package dev.cel.testing.testdata.proto3; + +option java_package = "dev.cel.testing.testdata.proto3"; +option java_outer_classname = "GlobalEnum"; + +option java_multiple_files = true; + +enum StandaloneGlobalEnum { + SGOO = 0; + SGAR = 1; + SGAZ = 2; +} diff --git a/common/src/main/resources/testdata/proto3/test_all_types.fds b/common/src/main/resources/testdata/proto3/test_all_types.fds new file mode 100644 index 000000000..5a2b9778c --- /dev/null +++ b/common/src/main/resources/testdata/proto3/test_all_types.fds @@ -0,0 +1,871 @@ +file { + name: "common/src/main/resources/testdata/proto3/test_all_types_serialized.proto" + package: "dev.cel.testing.testdata.serialized.proto3" + dependency: "google/protobuf/any.proto" + dependency: "google/protobuf/duration.proto" + dependency: "google/protobuf/struct.proto" + dependency: "google/protobuf/timestamp.proto" + dependency: "google/protobuf/wrappers.proto" + message_type { + name: "TestAllTypes" + field { + name: "single_int32" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_INT32 + } + field { + name: "single_int64" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_INT64 + } + field { + name: "single_uint32" + number: 3 + label: LABEL_OPTIONAL + type: TYPE_UINT32 + } + field { + name: "single_uint64" + number: 4 + label: LABEL_OPTIONAL + type: TYPE_UINT64 + } + field { + name: "single_sint32" + number: 5 + label: LABEL_OPTIONAL + type: TYPE_SINT32 + } + field { + name: "single_sint64" + number: 6 + label: LABEL_OPTIONAL + type: TYPE_SINT64 + } + field { + name: "single_fixed32" + number: 7 + label: LABEL_OPTIONAL + type: TYPE_FIXED32 + } + field { + name: "single_fixed64" + number: 8 + label: LABEL_OPTIONAL + type: TYPE_FIXED64 + } + field { + name: "single_sfixed32" + number: 9 + label: LABEL_OPTIONAL + type: TYPE_SFIXED32 + } + field { + name: "single_sfixed64" + number: 10 + label: LABEL_OPTIONAL + type: TYPE_SFIXED64 + } + field { + name: "single_float" + number: 11 + label: LABEL_OPTIONAL + type: TYPE_FLOAT + } + field { + name: "single_double" + number: 12 + label: LABEL_OPTIONAL + type: TYPE_DOUBLE + } + field { + name: "single_bool" + number: 13 + label: LABEL_OPTIONAL + type: TYPE_BOOL + } + field { + name: "single_string" + number: 14 + label: LABEL_OPTIONAL + type: TYPE_STRING + } + field { + name: "single_bytes" + number: 15 + label: LABEL_OPTIONAL + type: TYPE_BYTES + } + field { + name: "optional_bool" + number: 16 + label: LABEL_OPTIONAL + type: TYPE_BOOL + oneof_index: 2 + proto3_optional: true + } + field { + name: "optional_string" + number: 17 + label: LABEL_OPTIONAL + type: TYPE_BOOL + oneof_index: 3 + proto3_optional: true + } + field { + name: "single_any" + number: 100 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Any" + } + field { + name: "single_duration" + number: 101 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Duration" + } + field { + name: "single_timestamp" + number: 102 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Timestamp" + } + field { + name: "single_struct" + number: 103 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Struct" + } + field { + name: "single_value" + number: 104 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Value" + } + field { + name: "single_int64_wrapper" + number: 105 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Int64Value" + } + field { + name: "single_int32_wrapper" + number: 106 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Int32Value" + } + field { + name: "single_double_wrapper" + number: 107 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.DoubleValue" + } + field { + name: "single_float_wrapper" + number: 108 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.FloatValue" + } + field { + name: "single_uint64_wrapper" + number: 109 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.UInt64Value" + } + field { + name: "single_uint32_wrapper" + number: 110 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.UInt32Value" + } + field { + name: "single_string_wrapper" + number: 111 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.StringValue" + } + field { + name: "single_bool_wrapper" + number: 112 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.BoolValue" + } + field { + name: "single_bytes_wrapper" + number: 113 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.BytesValue" + } + field { + name: "single_list_value" + number: 114 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.ListValue" + } + field { + name: "single_nested_message" + number: 21 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.NestedMessage" + oneof_index: 0 + } + field { + name: "single_nested_enum" + number: 22 + label: LABEL_OPTIONAL + type: TYPE_ENUM + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.NestedEnum" + oneof_index: 0 + } + field { + name: "standalone_message" + number: 23 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.NestedMessage" + } + field { + name: "standalone_enum" + number: 24 + label: LABEL_OPTIONAL + type: TYPE_ENUM + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.NestedEnum" + } + field { + name: "repeated_int32" + number: 31 + label: LABEL_REPEATED + type: TYPE_INT32 + } + field { + name: "repeated_int64" + number: 32 + label: LABEL_REPEATED + type: TYPE_INT64 + } + field { + name: "repeated_uint32" + number: 33 + label: LABEL_REPEATED + type: TYPE_UINT32 + } + field { + name: "repeated_uint64" + number: 34 + label: LABEL_REPEATED + type: TYPE_UINT64 + } + field { + name: "repeated_sint32" + number: 35 + label: LABEL_REPEATED + type: TYPE_SINT32 + } + field { + name: "repeated_sint64" + number: 36 + label: LABEL_REPEATED + type: TYPE_SINT64 + } + field { + name: "repeated_fixed32" + number: 37 + label: LABEL_REPEATED + type: TYPE_FIXED32 + } + field { + name: "repeated_fixed64" + number: 38 + label: LABEL_REPEATED + type: TYPE_FIXED64 + } + field { + name: "repeated_sfixed32" + number: 39 + label: LABEL_REPEATED + type: TYPE_SFIXED32 + } + field { + name: "repeated_sfixed64" + number: 40 + label: LABEL_REPEATED + type: TYPE_SFIXED64 + } + field { + name: "repeated_float" + number: 41 + label: LABEL_REPEATED + type: TYPE_FLOAT + } + field { + name: "repeated_double" + number: 42 + label: LABEL_REPEATED + type: TYPE_DOUBLE + } + field { + name: "repeated_bool" + number: 43 + label: LABEL_REPEATED + type: TYPE_BOOL + } + field { + name: "repeated_string" + number: 44 + label: LABEL_REPEATED + type: TYPE_STRING + } + field { + name: "repeated_bytes" + number: 45 + label: LABEL_REPEATED + type: TYPE_BYTES + } + field { + name: "repeated_nested_message" + number: 51 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.NestedMessage" + } + field { + name: "repeated_nested_enum" + number: 52 + label: LABEL_REPEATED + type: TYPE_ENUM + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.NestedEnum" + } + field { + name: "repeated_string_piece" + number: 53 + label: LABEL_REPEATED + type: TYPE_STRING + options { + ctype: STRING_PIECE + } + } + field { + name: "repeated_cord" + number: 54 + label: LABEL_REPEATED + type: TYPE_STRING + options { + ctype: CORD + } + } + field { + name: "repeated_lazy_message" + number: 55 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.NestedMessage" + } + field { + name: "map_int32_int64" + number: 56 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.MapInt32Int64Entry" + } + field { + name: "map_string_string" + number: 61 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.MapStringStringEntry" + } + field { + name: "map_int64_nested_type" + number: 62 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.MapInt64NestedTypeEntry" + } + field { + name: "oneof_type" + number: 63 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.NestedTestAllTypes" + oneof_index: 1 + } + field { + name: "oneof_msg" + number: 64 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes.NestedMessage" + oneof_index: 1 + } + field { + name: "oneof_bool" + number: 65 + label: LABEL_OPTIONAL + type: TYPE_BOOL + oneof_index: 1 + } + nested_type { + name: "NestedMessage" + field { + name: "bb" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_INT32 + } + } + nested_type { + name: "MapInt32Int64Entry" + field { + name: "key" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_INT32 + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_INT64 + } + options { + map_entry: true + } + } + nested_type { + name: "MapStringStringEntry" + field { + name: "key" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_STRING + } + options { + map_entry: true + } + } + nested_type { + name: "MapInt64NestedTypeEntry" + field { + name: "key" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_INT64 + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.NestedTestAllTypes" + } + options { + map_entry: true + } + } + enum_type { + name: "NestedEnum" + value { + name: "FOO" + number: 0 + } + value { + name: "BAR" + number: 1 + } + value { + name: "BAZ" + number: 2 + } + } + oneof_decl { + name: "nested_type" + } + oneof_decl { + name: "kind" + } + oneof_decl { + name: "_optional_bool" + } + oneof_decl { + name: "_optional_string" + } + } + message_type { + name: "NestedTestAllTypes" + field { + name: "child" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.NestedTestAllTypes" + } + field { + name: "payload" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".dev.cel.testing.testdata.serialized.proto3.TestAllTypes" + } + } + enum_type { + name: "GlobalEnum" + value { + name: "GOO" + number: 0 + } + value { + name: "GAR" + number: 1 + } + value { + name: "GAZ" + number: 2 + } + } + options { + java_package: "dev.cel.testing.testdata.serialized.proto3" + java_outer_classname: "TestAllTypesProto" + } + syntax: "proto3" +} +file { + name: "google/protobuf/any.proto" + package: "google.protobuf" + message_type { + name: "Any" + field { + name: "type_url" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "typeUrl" + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_BYTES + json_name: "value" + } + } + options { + java_package: "com.google.protobuf" + java_outer_classname: "AnyProto" + java_multiple_files: true + go_package: "google.golang.org/protobuf/types/known/anypb" + objc_class_prefix: "GPB" + csharp_namespace: "Google.Protobuf.WellKnownTypes" + } + syntax: "proto3" +} +file { + name: "google/protobuf/duration.proto" + package: "google.protobuf" + message_type { + name: "Duration" + field { + name: "seconds" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_INT64 + json_name: "seconds" + } + field { + name: "nanos" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_INT32 + json_name: "nanos" + } + } + options { + java_package: "com.google.protobuf" + java_outer_classname: "DurationProto" + java_multiple_files: true + go_package: "google.golang.org/protobuf/types/known/durationpb" + cc_enable_arenas: true + objc_class_prefix: "GPB" + csharp_namespace: "Google.Protobuf.WellKnownTypes" + } + syntax: "proto3" +} +file { + name: "google/protobuf/struct.proto" + package: "google.protobuf" + message_type { + name: "Struct" + field { + name: "fields" + number: 1 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".google.protobuf.Struct.FieldsEntry" + json_name: "fields" + } + nested_type { + name: "FieldsEntry" + field { + name: "key" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "key" + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Value" + json_name: "value" + } + options { + map_entry: true + } + } + } + message_type { + name: "Value" + field { + name: "null_value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_ENUM + type_name: ".google.protobuf.NullValue" + oneof_index: 0 + json_name: "nullValue" + } + field { + name: "number_value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_DOUBLE + oneof_index: 0 + json_name: "numberValue" + } + field { + name: "string_value" + number: 3 + label: LABEL_OPTIONAL + type: TYPE_STRING + oneof_index: 0 + json_name: "stringValue" + } + field { + name: "bool_value" + number: 4 + label: LABEL_OPTIONAL + type: TYPE_BOOL + oneof_index: 0 + json_name: "boolValue" + } + field { + name: "struct_value" + number: 5 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Struct" + oneof_index: 0 + json_name: "structValue" + } + field { + name: "list_value" + number: 6 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.ListValue" + oneof_index: 0 + json_name: "listValue" + } + oneof_decl { + name: "kind" + } + } + message_type { + name: "ListValue" + field { + name: "values" + number: 1 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".google.protobuf.Value" + json_name: "values" + } + } + enum_type { + name: "NullValue" + value { + name: "NULL_VALUE" + number: 0 + } + } + options { + java_package: "com.google.protobuf" + java_outer_classname: "StructProto" + java_multiple_files: true + go_package: "google.golang.org/protobuf/types/known/structpb" + cc_enable_arenas: true + objc_class_prefix: "GPB" + csharp_namespace: "Google.Protobuf.WellKnownTypes" + } + syntax: "proto3" +} +file { + name: "google/protobuf/timestamp.proto" + package: "google.protobuf" + message_type { + name: "Timestamp" + field { + name: "seconds" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_INT64 + json_name: "seconds" + } + field { + name: "nanos" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_INT32 + json_name: "nanos" + } + } + options { + java_package: "com.google.protobuf" + java_outer_classname: "TimestampProto" + java_multiple_files: true + go_package: "google.golang.org/protobuf/types/known/timestamppb" + cc_enable_arenas: true + objc_class_prefix: "GPB" + csharp_namespace: "Google.Protobuf.WellKnownTypes" + } + syntax: "proto3" +} +file { + name: "google/protobuf/wrappers.proto" + package: "google.protobuf" + message_type { + name: "DoubleValue" + field { + name: "value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_DOUBLE + json_name: "value" + } + } + message_type { + name: "FloatValue" + field { + name: "value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_FLOAT + json_name: "value" + } + } + message_type { + name: "Int64Value" + field { + name: "value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_INT64 + json_name: "value" + } + } + message_type { + name: "UInt64Value" + field { + name: "value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_UINT64 + json_name: "value" + } + } + message_type { + name: "Int32Value" + field { + name: "value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_INT32 + json_name: "value" + } + } + message_type { + name: "UInt32Value" + field { + name: "value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_UINT32 + json_name: "value" + } + } + message_type { + name: "BoolValue" + field { + name: "value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_BOOL + json_name: "value" + } + } + message_type { + name: "StringValue" + field { + name: "value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + json_name: "value" + } + } + message_type { + name: "BytesValue" + field { + name: "value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_BYTES + json_name: "value" + } + } + options { + java_package: "com.google.protobuf" + java_outer_classname: "WrappersProto" + java_multiple_files: true + go_package: "google.golang.org/protobuf/types/known/wrapperspb" + cc_enable_arenas: true + objc_class_prefix: "GPB" + csharp_namespace: "Google.Protobuf.WellKnownTypes" + } + syntax: "proto3" +} diff --git a/common/src/test/java/dev/cel/common/BUILD.bazel b/common/src/test/java/dev/cel/common/BUILD.bazel new file mode 100644 index 000000000..98be87d17 --- /dev/null +++ b/common/src/test/java/dev/cel/common/BUILD.bazel @@ -0,0 +1,61 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = [ + "//:license", + ], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:operator", + "//common:options", + "//common:proto_ast", + "//common:proto_json_adapter", + "//common:proto_v1alpha1_ast", + "//common:source_location", + "//common/ast", + "//common/internal", + "//common/internal:code_point_stream", + "//common/types", + "//common/types:cel_proto_types", + "//common/types:cel_v1alpha1_types", + "//common/values:cel_byte_string", + "//compiler", + "//compiler:compiler_builder", + "//parser:macro", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@com_google_googleapis//google/api/expr/v1alpha1:expr_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_guava_guava_testlib", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:com_google_truth_extensions_truth_proto_extension", + "@maven//:junit_junit", + "@maven//:org_antlr_antlr4_runtime", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [ + ":tests", + ], +) diff --git a/common/src/test/java/dev/cel/common/CelAbstractSyntaxTreeTest.java b/common/src/test/java/dev/cel/common/CelAbstractSyntaxTreeTest.java new file mode 100644 index 000000000..b04f9f406 --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelAbstractSyntaxTreeTest.java @@ -0,0 +1,188 @@ +// Copyright 2022 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; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.expr.CheckedExpr; +import dev.cel.expr.Constant; +import dev.cel.expr.Expr; +import dev.cel.expr.Expr.Call; +import dev.cel.expr.Expr.Ident; +import dev.cel.expr.Reference; +import dev.cel.expr.SourceInfo; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.testing.EqualsTester; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelStandardMacro; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelAbstractSyntaxTreeTest { + + private static final CelExpr EXPR = + CelExpr.newBuilder().setId(1L).setConstant(CelConstant.ofValue(true)).build(); + private static final CelSource SOURCE_INFO = + CelSource.newBuilder() + .setDescription("test/location.cel") + .addPositions(1L, 0) + .addLineOffsets(4) + .build(); + private static final CelAbstractSyntaxTree PARSED_AST = + CelAbstractSyntaxTree.newParsedAst(EXPR, SOURCE_INFO); + private static final CelAbstractSyntaxTree CHECKED_AST = + CelAbstractSyntaxTree.newCheckedAst( + EXPR, SOURCE_INFO, ImmutableMap.of(), ImmutableMap.of(1L, SimpleType.BOOL)); + + private static final CelAbstractSyntaxTree CHECKED_ENUM_AST = + CelProtoAbstractSyntaxTree.fromCheckedExpr( + CheckedExpr.newBuilder() + .putTypeMap(1L, CelProtoTypes.INT64) + .putTypeMap(2L, CelProtoTypes.INT64) + .putTypeMap(3L, CelProtoTypes.BOOL) + .putReferenceMap( + 2L, + Reference.newBuilder() + .setValue(Constant.newBuilder().setInt64Value(2)) + .build()) + .putReferenceMap(3L, Reference.newBuilder().addOverloadId("not_equals").build()) + .setExpr( + Expr.newBuilder() + .setId(3L) + .setCallExpr( + Call.newBuilder() + .setFunction("_!=_") + .addArgs( + Expr.newBuilder() + .setId(1L) + .setConstExpr(Constant.newBuilder().setInt64Value(1))) + .addArgs( + Expr.newBuilder() + .setId(2L) + .setIdentExpr(Ident.newBuilder().setName("ENUM"))))) + .setSourceInfo( + SourceInfo.newBuilder() + .setLocation("test/location.cel") + .putPositions(1L, 0) + .putPositions(2L, 4) + .putPositions(3L, 2) + .addLineOffsets(8)) + .build()) + .getAst(); + + @Test + public void getResultType_isDynWhenParsedExpr() { + CelAbstractSyntaxTree ast = PARSED_AST; + + assertThat(ast.getResultType()).isEqualTo(SimpleType.DYN); + } + + @Test + public void getResultType_isStaticWhenCheckedExpr() { + CelAbstractSyntaxTree ast = CHECKED_AST; + + assertThat(ast.getResultType()).isEqualTo(SimpleType.BOOL); + } + + @Test + public void findEnumValue_findsConstantInCheckedExpr() { + CelAbstractSyntaxTree ast = CHECKED_ENUM_AST; + assertThat(ast.findEnumValue(1)).isEmpty(); + assertThat(ast.findEnumValue(2)).hasValue(CelConstant.ofValue(2)); + assertThat(ast.findEnumValue(3)).isEmpty(); + } + + @Test + public void findEnumValue_doesNotFindConstantInParsedExpr() { + CelAbstractSyntaxTree ast = + CelAbstractSyntaxTree.newParsedAst( + CHECKED_ENUM_AST.getExpr(), CHECKED_ENUM_AST.getSource()); + + assertThat(ast.findEnumValue(1)).isEmpty(); + assertThat(ast.findEnumValue(2)).isEmpty(); + assertThat(ast.findEnumValue(3)).isEmpty(); + } + + @Test + public void findOverloadIDs_findsOverloadsInCheckedExpr() { + CelAbstractSyntaxTree ast = CHECKED_ENUM_AST; + assertThat(ast.findOverloadIDs(1)).isEmpty(); + assertThat(ast.findOverloadIDs(2)).isEmpty(); + assertThat(ast.findOverloadIDs(3)).hasValue(ImmutableList.of("not_equals")); + } + + @Test + public void findOverloadIDs_doesNotFindsOverloadsInParsedExpr() { + CelAbstractSyntaxTree ast = + CelAbstractSyntaxTree.newParsedAst( + CHECKED_ENUM_AST.getExpr(), CHECKED_ENUM_AST.getSource()); + + assertThat(ast.findOverloadIDs(1)).isEmpty(); + assertThat(ast.findOverloadIDs(2)).isEmpty(); + assertThat(ast.findOverloadIDs(3)).isEmpty(); + } + + @Test + public void getSource_hasDescriptionEqualToSourceLocation() { + assertThat(PARSED_AST.getSource().getDescription()).isEqualTo("test/location.cel"); + } + + @Test + public void equalityTest() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setOptions(CelOptions.current().populateMacroCalls(true).build()) + .build(); + new EqualsTester() + .addEqualityGroup( + CelAbstractSyntaxTree.newParsedAst( + CelExpr.newBuilder().build(), CelSource.newBuilder().build())) + .addEqualityGroup( + celCompiler.compile("'foo'").getAst(), celCompiler.compile("'foo'").getAst()) // ASCII + .addEqualityGroup( + celCompiler.compile("'κ°€λ‚˜λ‹€'").getAst(), celCompiler.compile("'κ°€λ‚˜λ‹€'").getAst()) // BMP + .addEqualityGroup( + celCompiler.compile("'πŸ˜¦πŸ˜πŸ˜‘'").getAst(), + celCompiler.compile("'πŸ˜¦πŸ˜πŸ˜‘'").getAst()) // SMP + .addEqualityGroup( + celCompiler.compile("[1,2,3].exists(x, x > 0)").getAst(), + celCompiler.compile("[1,2,3].exists(x, x > 0)").getAst()) + .testEquals(); + } + + @Test + public void parsedExpression_createAst() { + CelExpr celExpr = CelExpr.newBuilder().setId(1).setConstant(CelConstant.ofValue(2)).build(); + CelSource celSource = + CelSource.newBuilder("expression").setDescription("desc").addPositions(1, 5).build(); + + CelAbstractSyntaxTree ast = CelAbstractSyntaxTree.newParsedAst(celExpr, celSource); + + assertThat(ast).isNotNull(); + assertThat(ast.getExpr()).isEqualTo(celExpr); + assertThat(ast.getSource()).isEqualTo(celSource); + assertThat(ast.getTypeMap()).isEmpty(); + assertThat(ast.getReferenceMap()).isEmpty(); + } +} diff --git a/common/src/test/java/dev/cel/common/CelContainerTest.java b/common/src/test/java/dev/cel/common/CelContainerTest.java new file mode 100644 index 000000000..cd7b73576 --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelContainerTest.java @@ -0,0 +1,208 @@ +// Copyright 2025 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; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableSet; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelContainerTest { + + @Test + public void resolveCandidateName_singleContainer_resolvesAllCandidates() { + CelContainer container = CelContainer.ofName("a.b.c.M.N"); + + ImmutableSet resolvedNames = container.resolveCandidateNames("R.s"); + + assertThat(resolvedNames) + .containsExactly("a.b.c.M.N.R.s", "a.b.c.M.R.s", "a.b.c.R.s", "a.b.R.s", "a.R.s", "R.s") + .inOrder(); + } + + @Test + public void resolveCandidateName_fullyQualifiedTypeName_resolveSingleCandidate() { + CelContainer container = CelContainer.ofName("a.b.c.M.N"); + + ImmutableSet resolvedNames = container.resolveCandidateNames(".R.s"); + + assertThat(resolvedNames).containsExactly("R.s"); + } + + @Test + @TestParameters("{typeName: bigex, resolved: my.example.pkg.verbose}") + @TestParameters("{typeName: .bigex, resolved: my.example.pkg.verbose}") + @TestParameters("{typeName: bigex.Execute, resolved: my.example.pkg.verbose.Execute}") + @TestParameters("{typeName: .bigex.Execute, resolved: my.example.pkg.verbose.Execute}") + public void resolveCandidateName_withAlias_resolvesSingleCandidate( + String typeName, String resolved) { + CelContainer container = + CelContainer.newBuilder() + .setName("a.b.c") // Note: alias takes precedence + .addAlias("bigex", "my.example.pkg.verbose") + .build(); + + ImmutableSet resolvedNames = container.resolveCandidateNames(typeName); + + assertThat(resolvedNames).containsExactly(resolved); + } + + @Test + @TestParameters("{typeName: R, resolved: my.alias.R}") + @TestParameters("{typeName: R.S.T, resolved: my.alias.R.S.T}") + public void resolveCandidateName_withMatchingAbbreviation_resolvesSingleCandidate( + String typeName, String resolved) { + CelContainer container = + CelContainer.newBuilder().setName("a.b.c").addAbbreviations("my.alias.R").build(); + + ImmutableSet resolvedNames = container.resolveCandidateNames(typeName); + + assertThat(resolvedNames).containsExactly(resolved); + } + + @Test + public void resolveCandidateName_withUnmatchedAbbreviation_resolvesMultipleCandidates() { + CelContainer container = + CelContainer.newBuilder().setName("a.b.c").addAbbreviations("my.alias.R").build(); + + ImmutableSet resolvedNames = container.resolveCandidateNames("S"); + + assertThat(resolvedNames).containsExactly("a.b.c.S", "a.b.S", "a.S", "S").inOrder(); + } + + @Test + public void containerBuilder_duplicateAliases_throws() { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> CelContainer.newBuilder().addAlias("foo", "a.b").addAlias("foo", "b.c")); + assertThat(e) + .hasMessageThat() + .contains("alias collides with existing reference: name=b.c, alias=foo, existing=a.b"); + } + + @Test + public void containerBuilder_aliasCollidesWithContainer_throws() { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> CelContainer.newBuilder().setName("foo").addAlias("foo", "a.b")); + assertThat(e) + .hasMessageThat() + .contains("alias collides with container name: name=a.b, alias=foo, container=foo"); + } + + @Test + public void containerBuilder_addAliasError_throws(@TestParameter AliasingErrorTestCase testCase) { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> CelContainer.newBuilder().addAlias(testCase.alias, testCase.qualifiedName)); + assertThat(e).hasMessageThat().contains(testCase.errorMessage); + } + + private enum AliasingErrorTestCase { + BAD_QUALIFIED_NAME( + "foo", ".bad.name", "qualified name must not begin with a leading '.': .bad.name"), + BAD_ALIAS_NAME_1( + "bad.alias", "b.c", "alias must be non-empty and simple (not qualified): alias=bad.alias"), + BAD_ALIAS_NAME_2("", "b.c", "alias must be non-empty and simple (not qualified): alias="); + + private final String alias; + private final String qualifiedName; + private final String errorMessage; + + AliasingErrorTestCase(String alias, String qualifiedName, String errorMessage) { + this.alias = alias; + this.qualifiedName = qualifiedName; + this.errorMessage = errorMessage; + } + } + + @Test + public void containerBuilder_addAbbreviationsError_throws( + @TestParameter AbbreviationErrorTestCase testCase) { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> CelContainer.newBuilder().addAbbreviations(testCase.qualifiedNames)); + assertThat(e).hasMessageThat().contains(testCase.errorMessage); + } + + private enum AbbreviationErrorTestCase { + ABBREVIATION_COLLISION( + ImmutableSet.of("my.alias.R", "yer.other.R"), + "abbreviation collides with existing reference: name=yer.other.R, abbreviation=R," + + " existing=my.alias.R"), + INVALID_DOT_PREFIX( + ".bad", "invalid qualified name: .bad, wanted name of the form 'qualified.name'"), + INVALID_DOT_SUFFIX( + "bad.alias.", + "invalid qualified name: bad.alias., wanted name of the form 'qualified.name'"), + NO_QUALIFIER( + " bad_alias1 ", + "invalid qualified name: bad_alias1, wanted name of the form 'qualified.name'"), + INVALID_IDENTIFIER( + " bad.alias!", + "invalid qualified name: bad.alias!, wanted name of the form 'qualified.name'"), + ; + + private final ImmutableSet qualifiedNames; + private final String errorMessage; + + AbbreviationErrorTestCase(String qualifiedNames, String errorMessage) { + this(ImmutableSet.of(qualifiedNames), errorMessage); + } + + AbbreviationErrorTestCase(ImmutableSet qualifiedNames, String errorMessage) { + this.qualifiedNames = qualifiedNames; + this.errorMessage = errorMessage; + } + } + + @Test + public void containerBuilder_addAbbreviationsCollidesWithContainer_throws() { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> + CelContainer.newBuilder() + .setName("a.b.c.M.N") + .addAbbreviations("my.alias.a", "yer.other.b")); + + assertThat(e) + .hasMessageThat() + .contains( + "abbreviation collides with container name: name=my.alias.a, abbreviation=a," + + " container=a.b.c.M.N"); + } + + @Test + public void container_toBuilderRoundTrip_retainsExistingProperties() { + CelContainer container = + CelContainer.newBuilder().setName("hello").addAlias("foo", "x.y").build(); + + container = container.toBuilder().addAlias("bar", "a.b").build(); + + assertThat(container.name()).isEqualTo("hello"); + assertThat(container.aliases()).containsExactly("foo", "x.y", "bar", "a.b").inOrder(); + } +} diff --git a/common/src/test/java/dev/cel/common/CelDescriptorUtilTest.java b/common/src/test/java/dev/cel/common/CelDescriptorUtilTest.java new file mode 100644 index 000000000..3184f5624 --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelDescriptorUtilTest.java @@ -0,0 +1,209 @@ +// Copyright 2022 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; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.Empty; +import com.google.protobuf.FieldMask; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.NullValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import com.google.protobuf.WrappersProto; +import dev.cel.expr.conformance.proto3.GlobalEnum; +import dev.cel.expr.conformance.proto3.NestedTestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedEnum; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelDescriptorUtilTest { + + @Test + public void getAllDescriptorsFromFileDescriptor() { + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + ImmutableList.of(TestAllTypes.getDescriptor().getFile())); + + assertThat(celDescriptors.messageTypeDescriptors()) + .containsExactly( + Any.getDescriptor(), + BoolValue.getDescriptor(), + BytesValue.getDescriptor(), + DoubleValue.getDescriptor(), + Duration.getDescriptor(), + Empty.getDescriptor(), + FieldMask.getDescriptor(), + FloatValue.getDescriptor(), + Int32Value.getDescriptor(), + Int64Value.getDescriptor(), + ListValue.getDescriptor(), + NestedTestAllTypes.getDescriptor(), + StringValue.getDescriptor(), + Struct.getDescriptor(), + TestAllTypes.NestedMessage.getDescriptor(), + TestAllTypes.getDescriptor(), + Timestamp.getDescriptor(), + UInt32Value.getDescriptor(), + UInt64Value.getDescriptor(), + Value.getDescriptor()); + assertThat(celDescriptors.enumDescriptors()) + .containsExactly( + NullValue.getDescriptor(), GlobalEnum.getDescriptor(), NestedEnum.getDescriptor()); + assertThat(celDescriptors.fileDescriptors()) + .containsExactly( + TestAllTypes.getDescriptor().getFile(), + // The following fileDescriptors are defined as imports of TestAllTypes proto + Any.getDescriptor().getFile(), + Duration.getDescriptor().getFile(), + Empty.getDescriptor().getFile(), + FieldMask.getDescriptor().getFile(), + Struct.getDescriptor().getFile(), + Timestamp.getDescriptor().getFile(), + WrappersProto.getDescriptor().getFile()); + } + + @Test + public void getFileDescriptorsForDescriptors() { + ImmutableSet fileDescriptors = + CelDescriptorUtil.getFileDescriptorsForDescriptors( + ImmutableList.of(TestAllTypes.getDescriptor())); + assertThat(fileDescriptors) + .containsExactly( + TestAllTypes.getDescriptor().getFile(), + Any.getDescriptor().getFile(), + Duration.getDescriptor().getFile(), + Empty.getDescriptor().getFile(), + FieldMask.getDescriptor().getFile(), + Struct.getDescriptor().getFile(), + Timestamp.getDescriptor().getFile(), + WrappersProto.getDescriptor().getFile()); + } + + @Test + public void getFileDescriptorsForDescriptors_duplicateDescriptors() { + ImmutableSet fileDescriptors = + CelDescriptorUtil.getFileDescriptorsForDescriptors( + ImmutableList.of(TestAllTypes.getDescriptor(), TestAllTypes.getDescriptor())); + assertThat(fileDescriptors) + .containsExactly( + TestAllTypes.getDescriptor().getFile(), + Any.getDescriptor().getFile(), + Duration.getDescriptor().getFile(), + Empty.getDescriptor().getFile(), + FieldMask.getDescriptor().getFile(), + Struct.getDescriptor().getFile(), + Timestamp.getDescriptor().getFile(), + WrappersProto.getDescriptor().getFile()); + } + + @Test + public void getFileDescriptorsForDescriptors_duplicateAncestorDescriptors() { + ImmutableSet fileDescriptors = + CelDescriptorUtil.getFileDescriptorsForDescriptors( + ImmutableList.of(TestAllTypes.getDescriptor(), Any.getDescriptor())); + assertThat(fileDescriptors) + .containsExactly( + TestAllTypes.getDescriptor().getFile(), + Any.getDescriptor().getFile(), + Duration.getDescriptor().getFile(), + Empty.getDescriptor().getFile(), + FieldMask.getDescriptor().getFile(), + Struct.getDescriptor().getFile(), + Timestamp.getDescriptor().getFile(), + WrappersProto.getDescriptor().getFile()); + } + + @Test + public void getFileDescriptorsFromFileDescriptorSet() { + FileDescriptorSet fds = + FileDescriptorSet.newBuilder() + .addFile(Any.getDescriptor().getFile().toProto()) + .addFile(Empty.getDescriptor().getFile().toProto()) + .addFile(FieldMask.getDescriptor().getFile().toProto()) + .addFile(WrappersProto.getDescriptor().getFile().toProto()) + .addFile(Duration.getDescriptor().getFile().toProto()) + .addFile(Struct.getDescriptor().getFile().toProto()) + .addFile(Timestamp.getDescriptor().getFile().toProto()) + .addFile(TestAllTypes.getDescriptor().getFile().toProto()) + .build(); + ImmutableSet fileDescriptors = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds); + assertThat(fileDescriptors.stream().map(FileDescriptor::getName).collect(toImmutableSet())) + .containsExactly( + TestAllTypes.getDescriptor().getFile().getName(), + Any.getDescriptor().getFile().getName(), + Duration.getDescriptor().getFile().getName(), + Empty.getDescriptor().getFile().getName(), + FieldMask.getDescriptor().getFile().getName(), + Struct.getDescriptor().getFile().getName(), + Timestamp.getDescriptor().getFile().getName(), + WrappersProto.getDescriptor().getFile().getName()); + } + + @Test + public void getFileDescriptorsFromFileDescriptorSet_incompleteFileSet() { + FileDescriptorSet fds = + FileDescriptorSet.newBuilder() + .addFile(Duration.getDescriptor().getFile().toProto()) + .addFile(Struct.getDescriptor().getFile().toProto()) + .addFile(Timestamp.getDescriptor().getFile().toProto()) + .addFile(TestAllTypes.getDescriptor().getFile().toProto()) + .build(); + + ImmutableSet fileDescriptors = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds); + + assertThat(fileDescriptors.stream().map(FileDescriptor::getName).collect(toImmutableSet())) + .containsExactly( + TestAllTypes.getDescriptor().getFile().getName(), + Duration.getDescriptor().getFile().getName(), + Struct.getDescriptor().getFile().getName(), + Timestamp.getDescriptor().getFile().getName()); + } + + @Test + public void getFileDescriptorsFromFileDescriptorSet_duplicateFiles() { + FileDescriptorSet fds = + FileDescriptorSet.newBuilder() + .addFile(Any.getDescriptor().getFile().toProto()) + .addFile(Any.getDescriptor().getFile().toProto()) + .build(); + ImmutableSet fileDescriptors = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds); + assertThat(fileDescriptors.stream().map(FileDescriptor::getName).collect(toImmutableSet())) + .containsExactly(Any.getDescriptor().getFile().getName()); + } +} diff --git a/common/src/test/java/dev/cel/common/CelOptionsTest.java b/common/src/test/java/dev/cel/common/CelOptionsTest.java new file mode 100644 index 000000000..751d85ed8 --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelOptionsTest.java @@ -0,0 +1,39 @@ +// Copyright 2022 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; + +import static com.google.common.truth.Truth.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelOptionsTest { + + @Test + public void current_success_celOptions() { + CelOptions options = CelOptions.current().build(); + assertThat(options).isNotNull(); + assertThat(options.enableRegexPartialMatch()).isTrue(); + } + + @Test + public void current_defaults() { + // Defaults that aren't represented in deprecated CelOptions + assertThat(CelOptions.current().build().enableUnknownTracking()).isFalse(); + assertThat(CelOptions.current().build().resolveTypeDependencies()).isTrue(); + } +} diff --git a/common/src/test/java/dev/cel/common/CelProtoAbstractSyntaxTreeTest.java b/common/src/test/java/dev/cel/common/CelProtoAbstractSyntaxTreeTest.java new file mode 100644 index 000000000..585828549 --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelProtoAbstractSyntaxTreeTest.java @@ -0,0 +1,142 @@ +// Copyright 2022 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; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.expr.CheckedExpr; +import dev.cel.expr.Constant; +import dev.cel.expr.Expr; +import dev.cel.expr.Expr.Call; +import dev.cel.expr.ParsedExpr; +import dev.cel.expr.Reference; +import dev.cel.expr.SourceInfo; +import dev.cel.expr.SourceInfo.Extension; +import dev.cel.expr.SourceInfo.Extension.Component; +import dev.cel.expr.SourceInfo.Extension.Version; +import dev.cel.common.types.CelProtoTypes; +import java.util.Arrays; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +// LINT.IfChange +@RunWith(JUnit4.class) +public class CelProtoAbstractSyntaxTreeTest { + private static final Expr EXPR = + Expr.newBuilder() + .setId(1L) + .setCallExpr( + Call.newBuilder() + .setFunction("_!=_") + .addAllArgs( + Arrays.asList( + Expr.newBuilder() + .setId(2) + .setConstExpr(Constant.newBuilder().setBoolValue(true).build()) + .build(), + Expr.newBuilder() + .setId(3) + .setConstExpr(Constant.newBuilder().setBoolValue(false).build()) + .build())) + .build()) + .build(); + private static final SourceInfo SOURCE_INFO = + SourceInfo.newBuilder() + .setLocation("test/location.cel") + .putPositions(1L, 0) + .addLineOffsets(4) + .addExtensions( + Extension.newBuilder() + .setId("extension_id") + .addAffectedComponents(Component.COMPONENT_PARSER) + .addAffectedComponents(Component.COMPONENT_TYPE_CHECKER) + .addAffectedComponents(Component.COMPONENT_RUNTIME) + .setVersion(Version.newBuilder().setMajor(5).setMinor(3))) + .putMacroCalls( + 2, + Expr.newBuilder() + .setId(4) + .setConstExpr(Constant.newBuilder().setStringValue("Hello")) + .build()) + .build(); + private static final ParsedExpr PARSED_EXPR = + ParsedExpr.newBuilder().setExpr(EXPR).setSourceInfo(SOURCE_INFO).build(); + + private static final CheckedExpr CHECKED_EXPR = + CheckedExpr.newBuilder() + .putTypeMap(1L, CelProtoTypes.BOOL) + .putReferenceMap(1L, Reference.newBuilder().addOverloadId("not_equals").build()) + .setSourceInfo(SOURCE_INFO) + .setExpr(EXPR) + .build(); + + @Test + public void toParsedExpr_yieldsEquivalentMessage() { + CelProtoAbstractSyntaxTree ast = CelProtoAbstractSyntaxTree.fromParsedExpr(PARSED_EXPR); + assertThat(ast.toParsedExpr()).isEqualTo(PARSED_EXPR); + } + + @Test + public void toCheckedExpr_throwsWhenParsedExpr() { + CelProtoAbstractSyntaxTree ast = CelProtoAbstractSyntaxTree.fromParsedExpr(PARSED_EXPR); + assertThat(ast.getAst().isChecked()).isFalse(); + assertThrows(IllegalStateException.class, ast::toCheckedExpr); + } + + @Test + public void toCheckedExpr_yieldsEquivalentMessage() { + CelProtoAbstractSyntaxTree ast = CelProtoAbstractSyntaxTree.fromCheckedExpr(CHECKED_EXPR); + assertThat(ast.getAst().isChecked()).isTrue(); + assertThat(ast.toCheckedExpr()).isEqualTo(CHECKED_EXPR); + } + + @Test + public void getSourceInfo_yieldsEquivalentMessage() { + CelProtoAbstractSyntaxTree ast = CelProtoAbstractSyntaxTree.fromParsedExpr(PARSED_EXPR); + assertThat(ast.getSourceInfo()).isEqualTo(SOURCE_INFO); + } + + @Test + public void getProtoResultType_isDynWhenParsedExpr() { + CelProtoAbstractSyntaxTree ast = CelProtoAbstractSyntaxTree.fromParsedExpr(PARSED_EXPR); + assertThat(ast.getProtoResultType()).isEqualTo(CelProtoTypes.DYN); + } + + @Test + public void getProtoResultType_isStaticWhenCheckedExpr() { + CelProtoAbstractSyntaxTree ast = CelProtoAbstractSyntaxTree.fromCheckedExpr(CHECKED_EXPR); + assertThat(ast.getProtoResultType()).isEqualTo(CelProtoTypes.BOOL); + } + + @Test + public void fromCelAst_toParsedExpr_roundTrip() { + CelAbstractSyntaxTree celAst = CelProtoAbstractSyntaxTree.fromParsedExpr(PARSED_EXPR).getAst(); + + assertThat(CelProtoAbstractSyntaxTree.fromCelAst(celAst).toParsedExpr()).isEqualTo(PARSED_EXPR); + } + + @Test + public void fromCelAst_toCheckedExpr_roundTrip() { + CelAbstractSyntaxTree celAst = + CelProtoAbstractSyntaxTree.fromCheckedExpr(CHECKED_EXPR).getAst(); + + assertThat(CelProtoAbstractSyntaxTree.fromCelAst(celAst).toCheckedExpr()) + .isEqualTo(CHECKED_EXPR); + } +} +// LINT.ThenChange(CelProtoV1Alpha1AbstractSyntaxTreeTest.java) diff --git a/common/src/test/java/dev/cel/common/CelProtoJsonAdapterTest.java b/common/src/test/java/dev/cel/common/CelProtoJsonAdapterTest.java new file mode 100644 index 000000000..bc845e5ab --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelProtoJsonAdapterTest.java @@ -0,0 +1,80 @@ +// Copyright 2024 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; + +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ListValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Value; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.values.CelByteString; +import java.util.Arrays; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelProtoJsonAdapterTest { + + @Test + public void adaptValueToJsonValue_asymmetricJsonConversion() { + assertThat(CelProtoJsonAdapter.adaptValueToJsonValue(UnsignedLong.valueOf(1L))) + .isEqualTo(Value.newBuilder().setNumberValue(1).build()); + assertThat(CelProtoJsonAdapter.adaptValueToJsonValue(UnsignedLong.fromLongBits(-1L))) + .isEqualTo(Value.newBuilder().setStringValue(Long.toUnsignedString(-1L)).build()); + assertThat(CelProtoJsonAdapter.adaptValueToJsonValue(1L)) + .isEqualTo(Value.newBuilder().setNumberValue(1).build()); + assertThat(CelProtoJsonAdapter.adaptValueToJsonValue(Long.MAX_VALUE)) + .isEqualTo(Value.newBuilder().setStringValue(Long.toString(Long.MAX_VALUE)).build()); + assertThat(CelProtoJsonAdapter.adaptValueToJsonValue(CelByteString.copyFromUtf8("foo"))) + .isEqualTo(Value.newBuilder().setStringValue("Zm9v").build()); + } + + @Test + public void adaptValueToJsonList() { + ListValue listValue = CelProtoJsonAdapter.adaptToJsonListValue(Arrays.asList("hello", "world")); + + assertThat(listValue) + .isEqualTo( + ListValue.newBuilder() + .addValues(Value.newBuilder().setStringValue("hello")) + .addValues(Value.newBuilder().setStringValue("world")) + .build()); + } + + @Test + public void adaptToJsonStructValue() { + Struct struct = CelProtoJsonAdapter.adaptToJsonStructValue(ImmutableMap.of("key", "value")); + + assertThat(struct) + .isEqualTo( + Struct.newBuilder() + .putFields("key", Value.newBuilder().setStringValue("value").build()) + .build()); + } + + @Test + public void adaptValueToJsonValue_unsupportedJsonConversion() { + assertThrows( + ClassCastException.class, + () -> CelProtoJsonAdapter.adaptValueToJsonValue(ImmutableMap.of(1, 1))); + assertThrows( + IllegalArgumentException.class, + () -> CelProtoJsonAdapter.adaptValueToJsonValue(CelSource.newBuilder().build())); + } +} diff --git a/common/src/test/java/dev/cel/common/CelProtoV1Alpha1AbstractSyntaxTreeTest.java b/common/src/test/java/dev/cel/common/CelProtoV1Alpha1AbstractSyntaxTreeTest.java new file mode 100644 index 000000000..b679c7246 --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelProtoV1Alpha1AbstractSyntaxTreeTest.java @@ -0,0 +1,140 @@ +// Copyright 2022 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; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.api.expr.v1alpha1.CheckedExpr; +import com.google.api.expr.v1alpha1.Constant; +import com.google.api.expr.v1alpha1.Expr; +import com.google.api.expr.v1alpha1.Expr.Call; +import com.google.api.expr.v1alpha1.ParsedExpr; +import com.google.api.expr.v1alpha1.Reference; +import com.google.api.expr.v1alpha1.SourceInfo; +import dev.cel.common.types.CelV1AlphaTypes; +import java.util.Arrays; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +// LINT.IfChange +@RunWith(JUnit4.class) +public class CelProtoV1Alpha1AbstractSyntaxTreeTest { + private static final Expr EXPR = + Expr.newBuilder() + .setId(1L) + .setCallExpr( + Call.newBuilder() + .setFunction("_!=_") + .addAllArgs( + Arrays.asList( + Expr.newBuilder() + .setId(2) + .setConstExpr(Constant.newBuilder().setBoolValue(true).build()) + .build(), + Expr.newBuilder() + .setId(3) + .setConstExpr(Constant.newBuilder().setBoolValue(false).build()) + .build())) + .build()) + .build(); + private static final SourceInfo SOURCE_INFO = + SourceInfo.newBuilder() + .setLocation("test/location.cel") + .putPositions(1L, 0) + .addLineOffsets(4) + .putMacroCalls( + 2, + Expr.newBuilder() + .setId(4) + .setConstExpr(Constant.newBuilder().setStringValue("Hello")) + .build()) + .build(); + private static final ParsedExpr PARSED_EXPR = + ParsedExpr.newBuilder().setExpr(EXPR).setSourceInfo(SOURCE_INFO).build(); + + private static final CheckedExpr CHECKED_EXPR = + CheckedExpr.newBuilder() + .putTypeMap(1L, CelV1AlphaTypes.BOOL) + .setSourceInfo(SOURCE_INFO) + .putReferenceMap(1L, Reference.newBuilder().addOverloadId("not_equals").build()) + .setExpr(EXPR) + .build(); + + @Test + public void toParsedExpr_yieldsEquivalentMessage() { + CelProtoV1Alpha1AbstractSyntaxTree ast = + CelProtoV1Alpha1AbstractSyntaxTree.fromParsedExpr(PARSED_EXPR); + assertThat(ast.toParsedExpr()).isEqualTo(PARSED_EXPR); + } + + @Test + public void toCheckedExpr_throwsWhenParsedExpr() { + CelProtoV1Alpha1AbstractSyntaxTree ast = + CelProtoV1Alpha1AbstractSyntaxTree.fromParsedExpr(PARSED_EXPR); + assertThat(ast.getAst().isChecked()).isFalse(); + assertThrows(IllegalStateException.class, ast::toCheckedExpr); + } + + @Test + public void toCheckedExpr_yieldsEquivalentMessage() { + CelProtoV1Alpha1AbstractSyntaxTree ast = + CelProtoV1Alpha1AbstractSyntaxTree.fromCheckedExpr(CHECKED_EXPR); + assertThat(ast.getAst().isChecked()).isTrue(); + assertThat(ast.toCheckedExpr()).isEqualTo(CHECKED_EXPR); + } + + @Test + public void getSourceInfo_yieldsEquivalentMessage() { + CelProtoV1Alpha1AbstractSyntaxTree ast = + CelProtoV1Alpha1AbstractSyntaxTree.fromParsedExpr(PARSED_EXPR); + assertThat(ast.getSourceInfo()).isEqualTo(SOURCE_INFO); + } + + @Test + public void getProtoResultType_isDynWhenParsedExpr() { + CelProtoV1Alpha1AbstractSyntaxTree ast = + CelProtoV1Alpha1AbstractSyntaxTree.fromParsedExpr(PARSED_EXPR); + assertThat(ast.getProtoResultType()).isEqualTo(CelV1AlphaTypes.DYN); + } + + @Test + public void getProtoResultType_isStaticWhenCheckedExpr() { + CelProtoV1Alpha1AbstractSyntaxTree ast = + CelProtoV1Alpha1AbstractSyntaxTree.fromCheckedExpr(CHECKED_EXPR); + assertThat(ast.getProtoResultType()).isEqualTo(CelV1AlphaTypes.BOOL); + } + + @Test + public void fromCelAst_toParsedExpr_roundTrip() { + CelAbstractSyntaxTree celAst = + CelProtoV1Alpha1AbstractSyntaxTree.fromParsedExpr(PARSED_EXPR).getAst(); + + assertThat(CelProtoV1Alpha1AbstractSyntaxTree.fromCelAst(celAst).toParsedExpr()) + .isEqualTo(PARSED_EXPR); + } + + @Test + public void fromCelAst_toCheckedExpr_roundTrip() { + CelAbstractSyntaxTree celAst = + CelProtoV1Alpha1AbstractSyntaxTree.fromCheckedExpr(CHECKED_EXPR).getAst(); + + assertThat(CelProtoV1Alpha1AbstractSyntaxTree.fromCelAst(celAst).toCheckedExpr()) + .isEqualTo(CHECKED_EXPR); + } +} +// LINT.ThenChange(CelProtoAbstractSyntaxTreeTest.java) diff --git a/common/src/test/java/dev/cel/common/CelSourceLocationTest.java b/common/src/test/java/dev/cel/common/CelSourceLocationTest.java new file mode 100644 index 000000000..9bffac08b --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelSourceLocationTest.java @@ -0,0 +1,56 @@ +// Copyright 2022 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; + +import static com.google.common.truth.Truth.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelSourceLocationTest { + + @Test + public void equals_equivalent() throws Exception { + CelSourceLocation lhs = CelSourceLocation.of(1, 1); + CelSourceLocation rhs = CelSourceLocation.of(1, 1); + assertThat(lhs).isEqualTo(rhs); + assertThat(lhs.hashCode()).isEqualTo(rhs.hashCode()); + assertThat(lhs.compareTo(rhs)).isEqualTo(0); + } + + @Test + public void equals_notEquivalent() throws Exception { + CelSourceLocation lhs = CelSourceLocation.of(1, 1); + CelSourceLocation rhs = CelSourceLocation.of(2, 2); + assertThat(lhs).isNotEqualTo(rhs); + assertThat(lhs.compareTo(rhs)).isEqualTo(-1); + } + + @Test + public void compareTo_lessThan() throws Exception { + CelSourceLocation lhs = CelSourceLocation.of(1, 1); + CelSourceLocation rhs = CelSourceLocation.of(2, 2); + assertThat(lhs.compareTo(rhs)).isEqualTo(-1); + } + + @Test + public void compareTo_greaterThanOrEqualTo() throws Exception { + CelSourceLocation lhs = CelSourceLocation.of(1, 2); + CelSourceLocation rhs = CelSourceLocation.of(1, 1); + assertThat(lhs.compareTo(rhs)).isEqualTo(1); + } +} diff --git a/common/src/test/java/dev/cel/common/CelSourceTest.java b/common/src/test/java/dev/cel/common/CelSourceTest.java new file mode 100644 index 000000000..d8b3701e3 --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelSourceTest.java @@ -0,0 +1,195 @@ +// Copyright 2022 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; + +import static com.google.common.truth.Truth.assertThat; +import static org.antlr.v4.runtime.IntStream.UNKNOWN_SOURCE_NAME; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.Iterables; +import dev.cel.common.CelSource.Extension; +import dev.cel.common.CelSource.Extension.Component; +import dev.cel.common.CelSource.Extension.Version; +import dev.cel.common.internal.BasicCodePointArray; +import dev.cel.common.internal.CodePointStream; +import dev.cel.common.internal.Latin1CodePointArray; +import dev.cel.common.internal.SupplementalCodePointArray; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.IntStream; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelSourceTest { + + private static final String LATIN_1_EXPR = "a + b == c"; + private static final String LATIN_1_NL_EXPR = "a + b\n== c"; + private static final String BASIC_EXPR = "a + \uff20 == c"; + private static final String BASIC_NL_EXPR = "a + \uff20\n == c"; + private static final String SUPPLEMENTAL_EXPR = + "a + \uff20 == " + new String(Character.toChars(0x1f4a2)) + " "; + private static final String SUPPLEMENTAL_NL_EXPR = + "a + \uff20\n == " + new String(Character.toChars(0x1f4a2)) + " "; + + @Test + public void getLocationOffset_correctStartingLocation() throws Exception { + CelSource source = CelSource.newBuilder(LATIN_1_EXPR).build(); + assertThat(source.getLocationOffset(CelSourceLocation.of(1, 0))).hasValue(0); + } + + @Test + public void getOffsetLocation_correctStartingLocation() throws Exception { + CelSource source = CelSource.newBuilder(LATIN_1_EXPR).build(); + assertThat(source.getOffsetLocation(0)).hasValue(CelSourceLocation.of(1, 0)); + } + + @Test + public void fromString_handlesSingleLineLatin1() throws Exception { + CelSource source = + CelSource.newBuilder(LATIN_1_EXPR).setDescription(UNKNOWN_SOURCE_NAME).build(); + assertThat(source.getContent().toString()).isEqualTo(LATIN_1_EXPR); + assertThat(source.getContent()).isInstanceOf(Latin1CodePointArray.class); + CharStream charStream = new CodePointStream(source.getDescription(), source.getContent()); + assertThat(charStream.getSourceName()).isEqualTo(UNKNOWN_SOURCE_NAME); + assertThat(charStream.size()).isEqualTo(LATIN_1_EXPR.codePoints().count()); + charStream.seek(charStream.size()); + assertThrows(IllegalStateException.class, charStream::consume); + charStream.seek(0); + assertThat(charStream.LA(0)).isEqualTo(0); + assertThat(charStream.LA(-1)).isEqualTo(IntStream.EOF); + assertThat(source.getLineOffsets()).hasSize(1); + assertThat(source.getLineOffsets().get(0)).isEqualTo(LATIN_1_EXPR.codePoints().count() + 1); + } + + @Test + public void fromString_handlesMultiLineLatin1() throws Exception { + CelSource source = + CelSource.newBuilder(LATIN_1_NL_EXPR).setDescription(UNKNOWN_SOURCE_NAME).build(); + assertThat(source.getContent().toString()).isEqualTo(LATIN_1_NL_EXPR); + assertThat(source.getContent()).isInstanceOf(Latin1CodePointArray.class); + CharStream charStream = new CodePointStream(source.getDescription(), source.getContent()); + assertThat(charStream.getSourceName()).isEqualTo(UNKNOWN_SOURCE_NAME); + assertThat(charStream.size()).isEqualTo(LATIN_1_NL_EXPR.codePoints().count()); + charStream.seek(charStream.size()); + assertThrows(IllegalStateException.class, charStream::consume); + charStream.seek(0); + assertThat(charStream.LA(0)).isEqualTo(0); + assertThat(charStream.LA(-1)).isEqualTo(IntStream.EOF); + assertThat(source.getLineOffsets()).containsExactly(6, 11).inOrder(); + } + + @Test + public void fromString_handlesSingleLineBasic() throws Exception { + CelSource source = CelSource.newBuilder(BASIC_EXPR).setDescription(UNKNOWN_SOURCE_NAME).build(); + assertThat(source.getContent().toString()).isEqualTo(BASIC_EXPR); + assertThat(source.getContent()).isInstanceOf(BasicCodePointArray.class); + CharStream charStream = new CodePointStream(source.getDescription(), source.getContent()); + assertThat(charStream.getSourceName()).isEqualTo(UNKNOWN_SOURCE_NAME); + assertThat(charStream.size()).isEqualTo(BASIC_EXPR.codePoints().count()); + charStream.seek(charStream.size()); + assertThrows(IllegalStateException.class, charStream::consume); + charStream.seek(0); + assertThat(charStream.LA(0)).isEqualTo(0); + assertThat(charStream.LA(-1)).isEqualTo(IntStream.EOF); + assertThat(source.getLineOffsets()).hasSize(1); + assertThat(source.getLineOffsets().get(0)).isEqualTo(BASIC_EXPR.codePoints().count() + 1); + } + + @Test + public void fromString_handlesMultiLineBasic() throws Exception { + CelSource source = + CelSource.newBuilder(BASIC_NL_EXPR).setDescription(UNKNOWN_SOURCE_NAME).build(); + assertThat(source.getContent().toString()).isEqualTo(BASIC_NL_EXPR); + assertThat(source.getContent()).isInstanceOf(BasicCodePointArray.class); + CharStream charStream = new CodePointStream(source.getDescription(), source.getContent()); + assertThat(charStream.getSourceName()).isEqualTo(UNKNOWN_SOURCE_NAME); + assertThat(charStream.size()).isEqualTo(BASIC_NL_EXPR.codePoints().count()); + charStream.seek(charStream.size()); + assertThrows(IllegalStateException.class, charStream::consume); + charStream.seek(0); + assertThat(charStream.LA(0)).isEqualTo(0); + assertThat(charStream.LA(-1)).isEqualTo(IntStream.EOF); + assertThat(source.getLineOffsets()).containsExactly(6, 12).inOrder(); + } + + @Test + public void fromString_handlesSingleLineSupplemental() throws Exception { + CelSource source = + CelSource.newBuilder(SUPPLEMENTAL_EXPR).setDescription(UNKNOWN_SOURCE_NAME).build(); + assertThat(source.getContent().toString()).isEqualTo(SUPPLEMENTAL_EXPR); + assertThat(source.getContent()).isInstanceOf(SupplementalCodePointArray.class); + CharStream charStream = new CodePointStream(source.getDescription(), source.getContent()); + assertThat(charStream.getSourceName()).isEqualTo(UNKNOWN_SOURCE_NAME); + assertThat(charStream.size()).isEqualTo(SUPPLEMENTAL_EXPR.codePoints().count()); + charStream.seek(charStream.size()); + assertThrows(IllegalStateException.class, charStream::consume); + charStream.seek(0); + assertThat(charStream.LA(0)).isEqualTo(0); + assertThat(charStream.LA(-1)).isEqualTo(IntStream.EOF); + assertThat(source.getLineOffsets()).hasSize(1); + assertThat(source.getLineOffsets().get(0)) + .isEqualTo(SUPPLEMENTAL_EXPR.codePoints().count() + 1); + } + + @Test + public void fromString_handlesMultiLineSupplemental() throws Exception { + CelSource source = + CelSource.newBuilder(SUPPLEMENTAL_NL_EXPR).setDescription(UNKNOWN_SOURCE_NAME).build(); + assertThat(source.getContent().toString()).isEqualTo(SUPPLEMENTAL_NL_EXPR); + assertThat(source.getContent()).isInstanceOf(SupplementalCodePointArray.class); + CharStream charStream = new CodePointStream(source.getDescription(), source.getContent()); + assertThat(charStream.getSourceName()).isEqualTo(UNKNOWN_SOURCE_NAME); + assertThat(charStream.size()).isEqualTo(SUPPLEMENTAL_NL_EXPR.codePoints().count()); + charStream.seek(charStream.size()); + assertThrows(IllegalStateException.class, charStream::consume); + charStream.seek(0); + assertThat(charStream.LA(0)).isEqualTo(0); + assertThat(charStream.LA(-1)).isEqualTo(IntStream.EOF); + assertThat(source.getLineOffsets()).containsExactly(6, 13).inOrder(); + } + + @Test + public void source_withExtension() { + CelSource celSource = + CelSource.newBuilder("") + .addAllExtensions( + Extension.create( + "extension_id", + Version.of(5, 3), + Component.COMPONENT_PARSER, + Component.COMPONENT_TYPE_CHECKER)) + .build(); + + Extension extension = Iterables.getOnlyElement(celSource.getExtensions()); + assertThat(extension.id()).isEqualTo("extension_id"); + assertThat(extension.version().major()).isEqualTo(5L); + assertThat(extension.version().minor()).isEqualTo(3L); + assertThat(extension.affectedComponents()) + .containsExactly(Component.COMPONENT_PARSER, Component.COMPONENT_TYPE_CHECKER); + assertThat(celSource.getExtensions()).hasSize(1); + } + + @Test + public void source_lineOffsetsAlreadyComputed_throws() { + CelSource.Builder sourceBuilder = CelSource.newBuilder("text"); + + IllegalStateException e = + assertThrows(IllegalStateException.class, () -> sourceBuilder.addLineOffsets(1)); + assertThat(e) + .hasMessageThat() + .contains("Line offsets were already been computed through the provided code points."); + } +} diff --git a/common/src/test/java/dev/cel/common/CelValidationExceptionTest.java b/common/src/test/java/dev/cel/common/CelValidationExceptionTest.java new file mode 100644 index 000000000..703531d81 --- /dev/null +++ b/common/src/test/java/dev/cel/common/CelValidationExceptionTest.java @@ -0,0 +1,42 @@ +// Copyright 2024 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; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelValidationExceptionTest { + + @Test + public void construct_withLargeErrorCount() { + ImmutableList.Builder issueBuilder = ImmutableList.builder(); + for (int i = 0; i < 1500; i++) { + issueBuilder.add(CelIssue.formatError(i + 1, i + 1, "generic error")); + } + + CelValidationException celValidationException = + new CelValidationException(CelSource.newBuilder().build(), issueBuilder.build()); + + assertThat(celValidationException.getErrors()).hasSize(1500); + assertThat(celValidationException) + .hasMessageThat() + .endsWith("...and 1400 more errors (truncated)"); + } +} diff --git a/common/src/test/java/dev/cel/common/OperatorTest.java b/common/src/test/java/dev/cel/common/OperatorTest.java new file mode 100644 index 000000000..28d941c6e --- /dev/null +++ b/common/src/test/java/dev/cel/common/OperatorTest.java @@ -0,0 +1,149 @@ +// Copyright 2022 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; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertEquals; + +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class OperatorTest { + + @Test + public void find_returnsEmptyWhenNotFound() { + assertThat(Operator.find("has")).isEmpty(); + } + + @Test + public void find_returnsCorrectOperator() { + assertThat(Operator.find("+")).hasValue(Operator.ADD); + } + + @Test + public void findReverse_returnsEmptyWhenNotFound() { + assertThat(Operator.findReverse("+")).isEmpty(); + } + + @Test + public void findReverse_returnsCorrectOperator() { + assertThat(Operator.findReverse("_+_")).hasValue(Operator.ADD); + } + + @Test + public void findReverse_allOperators(@TestParameter Operator operator) { + assertThat(Operator.findReverse(operator.getFunction())).hasValue(operator); + } + + @Test + public void findReverseBinaryOperator_returnsEmptyWhenNotFound() { + assertThat(Operator.findReverseBinaryOperator("+")).isEmpty(); + } + + @Test + public void findReverseBinaryOperator_returnsEmptyForUnaryOperator() { + assertThat(Operator.findReverse("-_")).hasValue(Operator.NEGATE); + assertThat(Operator.findReverseBinaryOperator("-_")).isEmpty(); + assertThat(Operator.findReverse("!_")).hasValue(Operator.LOGICAL_NOT); + assertThat(Operator.findReverseBinaryOperator("!_")).isEmpty(); + } + + @Test + public void findReverseBinaryOperator_returnsCorrectOperator() { + assertThat(Operator.findReverseBinaryOperator("_+_")).hasValue(Operator.ADD); + } + + @Test + @TestParameters({ + "{operator: '_?_:_', value: 8}", + "{operator: '_||_', value: 7}", + "{operator: '_&&_', value: 6}", + "{operator: '_==_', value: 5}", + "{operator: '_>_', value: 5}", + "{operator: '_>=_', value: 5}", + "{operator: '@in', value: 5}", + "{operator: '_<_', value: 5}", + "{operator: '_<=_', value: 5}", + "{operator: '_!=_', value: 5}", + "{operator: '_+_', value: 4}", + "{operator: '_-_', value: 4}", + "{operator: '_/_', value: 3}", + "{operator: '_%_', value: 3}", + "{operator: '_*_', value: 3}", + "{operator: '!_', value: 2}", + "{operator: '-_', value: 2}", + "{operator: '_[_]', value: 1}", + "{operator: 'has', value: 0}", + }) + public void lookupPrecedence(String operator, int value) { + assertEquals(Operator.lookupPrecedence(operator), value); + } + + @Test + @TestParameters({ + "{operator: '-_', value: '-'}", + "{operator: '!_', value: '!'}", + }) + public void lookupUnaryOperator_nonEmpty(String operator, String value) { + assertEquals(Operator.lookupUnaryOperator(operator), Optional.of(value)); + } + + @Test + @TestParameters({ + "{operator: '_*_'}", + "{operator: '_[_]'}", + "{operator: '_&&_'}", + }) + public void lookupUnaryOperator_empty(String operator) { + assertEquals(Operator.lookupUnaryOperator(operator), Optional.empty()); + } + + @Test + @TestParameters({ + "{operator: '_||_', value: '||'}", + "{operator: '_&&_', value: '&&'}", + "{operator: '_==_', value: '=='}", + "{operator: '_>_', value: '>'}", + "{operator: '_>=_', value: '>='}", + "{operator: '@in', value: 'in'}", + "{operator: '_<_', value: '<'}", + "{operator: '_<=_', value: '<='}", + "{operator: '_!=_', value: '!='}", + "{operator: '_+_', value: '+'}", + "{operator: '_-_', value: '-'}", + "{operator: '_/_', value: '/'}", + "{operator: '_%_', value: '%'}", + "{operator: '_*_', value: '*'}", + }) + public void lookupBinaryOperator_nonEmpty(String operator, String value) { + assertEquals(Operator.lookupBinaryOperator(operator), Optional.of(value)); + } + + @Test + @TestParameters({ + "{operator: '!_'}", + "{operator: '-_'}", + "{operator: '_[_]'}", + "{operator: 'has'}", + }) + public void lookupBinaryOperator_empty(String operator) { + assertEquals(Operator.lookupBinaryOperator(operator), Optional.empty()); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/BUILD.bazel b/common/src/test/java/dev/cel/common/ast/BUILD.bazel new file mode 100644 index 000000000..e4aac277b --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/BUILD.bazel @@ -0,0 +1,57 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = [ + "//:license", + ], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*.java"]), + deps = [ + "//:auto_value", + "//:java_truth", + "//common:cel_ast", + "//common:compiler_common", + "//common:container", + "//common:mutable_ast", + "//common:mutable_source", + "//common:operator", + "//common:options", + "//common/ast", + "//common/ast:cel_expr_visitor", + "//common/ast:expr_converter", + "//common/ast:expr_factory", + "//common/ast:expr_v1alpha1_converter", + "//common/ast:mutable_expr", + "//common/types", + "//common/values", + "//common/values:cel_byte_string", + "//compiler", + "//compiler:compiler_builder", + "//extensions:optional_library", + "//parser:macro", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@com_google_googleapis//google/api/expr/v1alpha1:expr_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_guava_guava_testlib", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/common/src/test/java/dev/cel/common/ast/CelConstantTest.java b/common/src/test/java/dev/cel/common/ast/CelConstantTest.java new file mode 100644 index 000000000..947073220 --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelConstantTest.java @@ -0,0 +1,222 @@ +// Copyright 2023 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.ast; + +import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.junit.Assert.assertThrows; + +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.ast.CelConstant.Kind; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelConstantTest { + + @Test + public void equality_objectsAreValueEqual_success() { + assertThat(CelConstant.ofValue(NullValue.NULL_VALUE)) + .isEqualTo(CelConstant.ofValue(NullValue.NULL_VALUE)); + assertThat(CelConstant.ofValue(true)).isEqualTo(CelConstant.ofValue(true)); + assertThat(CelConstant.ofValue(false)).isEqualTo(CelConstant.ofValue(false)); + assertThat(CelConstant.ofValue(2)).isEqualTo(CelConstant.ofValue(2)); + assertThat(CelConstant.ofValue(UnsignedLong.valueOf(2))) + .isEqualTo(CelConstant.ofValue(UnsignedLong.valueOf(2))); + assertThat(CelConstant.ofValue(2.1)).isEqualTo(CelConstant.ofValue(2.1)); + assertThat(CelConstant.ofValue("Hello world!")).isEqualTo(CelConstant.ofValue("Hello world!")); + assertThat(CelConstant.ofValue(CelByteString.of("Test".getBytes(UTF_8)))) + .isEqualTo(CelConstant.ofValue(CelByteString.of("Test".getBytes(UTF_8)))); + assertThat(CelConstant.ofValue(Duration.newBuilder().setSeconds(100L).build())) + .isEqualTo(CelConstant.ofValue(Duration.newBuilder().setSeconds(100L).build())); + assertThat(CelConstant.ofValue(Timestamp.newBuilder().setSeconds(100L).build())) + .isEqualTo(CelConstant.ofValue(Timestamp.newBuilder().setSeconds(100L).build())); + } + + @Test + public void equality_valueEqualityUnsatisfied_fails() { + assertThat(CelConstant.ofValue(true)).isNotEqualTo(CelConstant.ofValue(false)); + assertThat(CelConstant.ofValue(false)).isNotEqualTo(CelConstant.ofValue(true)); + assertThat(CelConstant.ofValue(3)).isNotEqualTo(CelConstant.ofValue(2)); + assertThat(CelConstant.ofValue(UnsignedLong.valueOf(3))) + .isNotEqualTo(CelConstant.ofValue(UnsignedLong.valueOf(2))); + assertThat(CelConstant.ofValue(3)).isNotEqualTo(CelConstant.ofValue(UnsignedLong.valueOf(3))); + assertThat(CelConstant.ofValue(3)).isNotEqualTo(CelConstant.ofValue(3.0)); + assertThat(CelConstant.ofValue(3.1)).isNotEqualTo(CelConstant.ofValue(2.1)); + assertThat(CelConstant.ofValue("world!")).isNotEqualTo(CelConstant.ofValue("Hello world!")); + assertThat(CelConstant.ofValue(CelByteString.of("T".getBytes(UTF_8)))) + .isNotEqualTo(CelConstant.ofValue(CelByteString.of("Test".getBytes(UTF_8)))); + assertThat(CelConstant.ofValue(Duration.newBuilder().setSeconds(100L).build())) + .isNotEqualTo(CelConstant.ofValue(Duration.newBuilder().setSeconds(50).build())); + assertThat(CelConstant.ofValue(Timestamp.newBuilder().setSeconds(100L).build())) + .isNotEqualTo(CelConstant.ofValue(Timestamp.newBuilder().setSeconds(50).build())); + } + + @Test + public void constructNullValue() { + CelConstant constant = CelConstant.ofValue(NullValue.NULL_VALUE); + + assertThat(constant.nullValue()).isEqualTo(NullValue.NULL_VALUE); + } + + @Test + public void constructBooleanValue() { + CelConstant trueConstant = CelConstant.ofValue(true); + CelConstant falseConstant = CelConstant.ofValue(false); + + assertThat(trueConstant.booleanValue()).isTrue(); + assertThat(falseConstant.booleanValue()).isFalse(); + } + + @Test + public void constructInt64Value() { + CelConstant constant = CelConstant.ofValue(2); + + assertThat(constant.int64Value()).isEqualTo(2); + } + + @Test + public void constructUInt64Value() { + CelConstant constant = CelConstant.ofValue(UnsignedLong.valueOf(2)); + + assertThat(constant.uint64Value()).isEqualTo(UnsignedLong.valueOf(2)); + } + + @Test + public void constructDoubleValue() { + CelConstant constant = CelConstant.ofValue(2.1); + + assertThat(constant.doubleValue()).isEqualTo(2.1); + } + + @Test + public void constructStringValue() { + CelConstant constant = CelConstant.ofValue("Hello world!"); + + assertThat(constant.stringValue()).isEqualTo("Hello world!"); + } + + @Test + public void constructBytesValue() { + CelConstant constant = CelConstant.ofValue(CelByteString.of("Test".getBytes(UTF_8))); + + assertThat(constant.bytesValue()).isEqualTo(CelByteString.of("Test".getBytes(UTF_8))); + } + + @Test + public void constructDurationValue() { + CelConstant constant = CelConstant.ofValue(Duration.newBuilder().setSeconds(100L).build()); + + assertThat(constant.durationValue()).isEqualTo(Duration.newBuilder().setSeconds(100L).build()); + } + + @Test + public void constructTimestampValue() { + CelConstant constant = CelConstant.ofValue(Timestamp.newBuilder().setSeconds(100L).build()); + + assertThat(constant.timestampValue()) + .isEqualTo(Timestamp.newBuilder().setSeconds(100L).build()); + } + + @Test + public void constructNotSetConstant() { + CelConstant constant = CelConstant.ofNotSet(); + + assertThat(constant).isNotNull(); + assertThat(constant.getKind()).isEqualTo(Kind.NOT_SET); + } + + private enum CelConstantTestCase { + NULL(CelConstant.ofValue(NullValue.NULL_VALUE)), + BOOLEAN(CelConstant.ofValue(true)), + INT64(CelConstant.ofValue(2)), + UINT64(CelConstant.ofValue(UnsignedLong.valueOf(2))), + DOUBLE(CelConstant.ofValue(2.1)), + STRING(CelConstant.ofValue("Hello world!")), + BYTES(CelConstant.ofValue(CelByteString.of("Test".getBytes(UTF_8)))), + DURATION(CelConstant.ofValue(Duration.newBuilder().setSeconds(100L).build())), + TIMESTAMP(CelConstant.ofValue(Timestamp.newBuilder().setSeconds(100L).build())); + + final CelConstant constant; + + CelConstantTestCase(CelConstant constant) { + this.constant = constant; + } + } + + @Test + public void getValueOnInvalidKindCase_throwsException( + @TestParameter CelConstantTestCase testCase) { + CelConstant constant = testCase.constant; + CelConstant.Kind constantKindCase = testCase.constant.getKind(); + if (constantKindCase != Kind.NULL_VALUE) { + assertThrows(UnsupportedOperationException.class, constant::nullValue); + } + if (constantKindCase != Kind.BOOLEAN_VALUE) { + assertThrows(UnsupportedOperationException.class, constant::booleanValue); + } + if (constantKindCase != Kind.INT64_VALUE) { + assertThrows(UnsupportedOperationException.class, constant::int64Value); + } + if (constantKindCase != Kind.UINT64_VALUE) { + assertThrows(UnsupportedOperationException.class, constant::uint64Value); + } + if (constantKindCase != Kind.DOUBLE_VALUE) { + assertThrows(UnsupportedOperationException.class, constant::doubleValue); + } + if (constantKindCase != Kind.STRING_VALUE) { + assertThrows(UnsupportedOperationException.class, constant::stringValue); + } + if (constantKindCase != Kind.BYTES_VALUE) { + assertThrows(UnsupportedOperationException.class, constant::bytesValue); + } + if (constantKindCase != Kind.DURATION_VALUE) { + assertThrows(UnsupportedOperationException.class, constant::durationValue); + } + if (constantKindCase != Kind.TIMESTAMP_VALUE) { + assertThrows(UnsupportedOperationException.class, constant::timestampValue); + } + } + + @Test + public void getObjectValue_success() { + assertThat(CelConstant.ofObjectValue(NullValue.NULL_VALUE)) + .isEqualTo(CelConstant.ofValue(NullValue.NULL_VALUE)); + assertThat(CelConstant.ofObjectValue(true)).isEqualTo(CelConstant.ofValue(true)); + assertThat(CelConstant.ofObjectValue(2L)).isEqualTo(CelConstant.ofValue(2L)); + assertThat(CelConstant.ofObjectValue(UnsignedLong.valueOf(3L))) + .isEqualTo(CelConstant.ofValue(UnsignedLong.valueOf(3L))); + assertThat(CelConstant.ofObjectValue(3.0d)).isEqualTo(CelConstant.ofValue(3.0d)); + assertThat(CelConstant.ofObjectValue("test")).isEqualTo(CelConstant.ofValue("test")); + assertThat(CelConstant.ofObjectValue(CelByteString.of("hello".getBytes(UTF_8)))) + .isEqualTo(CelConstant.ofValue(CelByteString.of("hello".getBytes(UTF_8)))); + } + + @Test + public void getObjectValue_invalidParameter_throws() { + assertThrows( + IllegalArgumentException.class, + () -> CelConstant.ofObjectValue(Duration.getDefaultInstance())); + assertThrows( + IllegalArgumentException.class, + () -> CelConstant.ofObjectValue(Timestamp.getDefaultInstance())); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/CelExprConverterTest.java b/common/src/test/java/dev/cel/common/ast/CelExprConverterTest.java new file mode 100644 index 000000000..ec064b4bb --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelExprConverterTest.java @@ -0,0 +1,617 @@ +// Copyright 2023 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.ast; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.expr.Constant; +import dev.cel.expr.Expr; +import dev.cel.expr.Expr.Call; +import dev.cel.expr.Expr.Comprehension; +import dev.cel.expr.Expr.CreateList; +import dev.cel.expr.Expr.CreateStruct; +import dev.cel.expr.Expr.Ident; +import dev.cel.expr.Expr.Select; +import dev.cel.expr.Reference; +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import com.google.protobuf.NullValue; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.values.CelByteString; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +// LINT.IfChange +@RunWith(TestParameterInjector.class) +public class CelExprConverterTest { + private enum ConstantTestCase { + NOT_SET( + Expr.newBuilder().setId(1).setConstExpr(Constant.getDefaultInstance()).build(), + CelExpr.ofConstant(1, CelConstant.ofNotSet())), + NULL( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setNullValue(NullValue.NULL_VALUE).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(dev.cel.common.values.NullValue.NULL_VALUE))), + BOOLEAN( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setBoolValue(true).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(true))), + INT64( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setInt64Value(10).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(10))), + UINT64( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setUint64Value(15).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(UnsignedLong.valueOf(15)))), + DOUBLE( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setDoubleValue(1.5).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(1.5))), + STRING( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setStringValue("Test").build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue("Test"))), + BYTES( + Expr.newBuilder() + .setId(1) + .setConstExpr( + Constant.newBuilder().setBytesValue(ByteString.copyFromUtf8("TEST")).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(CelByteString.copyFromUtf8("TEST")))); + + final Expr protoExpr; + final CelExpr celExpr; + + ConstantTestCase(Expr expr, CelExpr celExpr) { + this.protoExpr = expr; + this.celExpr = celExpr; + } + } + + @Test + public void convertConstant_bidirectional(@TestParameter ConstantTestCase constantTestCase) { + CelExpr celExpr = CelExprConverter.fromExpr(constantTestCase.protoExpr); + Expr expr = CelExprConverter.fromCelExpr(constantTestCase.celExpr); + + assertThat(celExpr).isEqualTo(constantTestCase.celExpr); + assertThat(expr).isEqualTo(constantTestCase.protoExpr); + } + + @Test + public void convertExprNotSet_toCelNotSet() { + Expr expr = Expr.newBuilder().setId(1).build(); + + CelExpr celExpr = CelExprConverter.fromExpr(expr); + + assertThat(celExpr).isEqualTo(CelExpr.ofNotSet(1)); + } + + @Test + public void convertExprIdent_toCelIdent() { + Expr expr = + Expr.newBuilder().setId(2).setIdentExpr(Ident.newBuilder().setName("Test").build()).build(); + + CelExpr celExpr = CelExprConverter.fromExpr(expr); + + assertThat(celExpr).isEqualTo(CelExpr.ofIdent(2, "Test")); + } + + @Test + @TestParameters("{isTestOnly: true}") + @TestParameters("{isTestOnly: false}") + public void convertExprSelect_toCelSelect(boolean isTestOnly) { + Expr expr = + Expr.newBuilder() + .setId(3) + .setSelectExpr( + Select.newBuilder() + .setField("field") + .setOperand( + Expr.newBuilder() + .setId(4) + .setConstExpr(Constant.newBuilder().setBoolValue(true).build())) + .setTestOnly(isTestOnly)) + .build(); + + CelExpr celExpr = CelExprConverter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofSelect( + 3, CelExpr.ofConstant(4, CelConstant.ofValue(true)), "field", isTestOnly)); + } + + @Test + public void convertExprCall_toCelCall() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setCallExpr( + Call.newBuilder() + .setTarget(newInt64ConstantExpr(2, 10)) + .setFunction("func") + .addArgs(newInt64ConstantExpr(3, 20)) + .build()) + .build(); + + CelExpr celExpr = CelExprConverter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofCall( + 1, + Optional.of(CelExpr.ofConstant(2, CelConstant.ofValue(10))), + "func", + ImmutableList.of(CelExpr.ofConstant(3, CelConstant.ofValue(20))))); + } + + @Test + public void convertExprList_toCelList() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setListExpr( + CreateList.newBuilder() + .addElements(newInt64ConstantExpr(2, 10)) + .addElements(newInt64ConstantExpr(3, 15)) + .addOptionalIndices(1) + .build()) + .build(); + + CelExpr celExpr = CelExprConverter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofList( + 1, + ImmutableList.of( + CelExpr.ofConstant(2, CelConstant.ofValue(10)), + CelExpr.ofConstant(3, CelConstant.ofValue(15))), + ImmutableList.of(1))); + } + + @Test + public void convertExprStructExpr_toCelStruct() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .setMessageName("messageName") + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setFieldKey("fieldKey") + .setValue(newInt64ConstantExpr(3, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build(); + + CelExpr celExpr = CelExprConverter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofStruct( + 1, + "messageName", + ImmutableList.of( + CelExpr.ofStructEntry( + 2, "fieldKey", CelExpr.ofConstant(3, CelConstant.ofValue(10)), true)))); + } + + @Test + public void convertExprStructExpr_invalidMapKey_throws() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .setMessageName("messageName") + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setMapKey( + Expr.getDefaultInstance()) // A message creation should not have a + // map key set. + .setValue(newInt64ConstantExpr(3, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build(); + + IllegalArgumentException e = + assertThrows(IllegalArgumentException.class, () -> CelExprConverter.fromExpr(expr)); + + assertThat(e).hasMessageThat().contains("Unexpected struct key kind case"); + } + + @Test + public void convertExprStructExpr_invalidFieldKey_throws() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setFieldKey("Bogus") // A map creation should not have a field key set + .setValue(newInt64ConstantExpr(3, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build(); + + IllegalArgumentException e = + assertThrows(IllegalArgumentException.class, () -> CelExprConverter.fromExpr(expr)); + + assertThat(e).hasMessageThat().contains("Unexpected map key kind case"); + } + + @Test + public void convertExprStructExpr_toCelMap() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setMapKey(newInt64ConstantExpr(3, 15)) + .setValue(newInt64ConstantExpr(4, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build(); + + CelExpr celExpr = CelExprConverter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofMap( + 1, + ImmutableList.of( + CelExpr.ofMapEntry( + 2, + CelExpr.ofConstant(3, CelConstant.ofValue(15)), + CelExpr.ofConstant(4, CelConstant.ofValue(10)), + true)))); + } + + @Test + public void convertExprComprehensionExpr_toCelComprehension() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setComprehensionExpr( + Comprehension.newBuilder() + .setIterVar("iterVar") + .setIterRange(newInt64ConstantExpr(2, 10)) + .setAccuVar("accuVar") + .setAccuInit(newInt64ConstantExpr(3, 20)) + .setLoopCondition( + Expr.newBuilder() + .setId(4) + .setCallExpr(Call.newBuilder().setFunction("testCondition").build()) + .build()) + .setLoopStep( + Expr.newBuilder() + .setId(5) + .setCallExpr(Call.newBuilder().setFunction("testStep").build()) + .build()) + .setResult(newInt64ConstantExpr(6, 30)) + .build()) + .build(); + + CelExpr celExpr = CelExprConverter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofComprehension( + 1, + "iterVar", + CelExpr.ofConstant(2, CelConstant.ofValue(10)), + "accuVar", + CelExpr.ofConstant(3, CelConstant.ofValue(20)), + CelExpr.ofCall(4, Optional.empty(), "testCondition", ImmutableList.of()), + CelExpr.ofCall(5, Optional.empty(), "testStep", ImmutableList.of()), + CelExpr.ofConstant(6, CelConstant.ofValue(30)))); + } + + @Test + public void convertExprReference_toCelReference_withOverloadIds() { + Reference reference = + Reference.newBuilder().setName("ref").addAllOverloadId(ImmutableList.of("a", "b")).build(); + + CelReference celReference = CelExprConverter.exprReferenceToCelReference(reference); + + assertThat(celReference) + .isEqualTo( + CelReference.newBuilder() + .setName("ref") + .addOverloadIds(ImmutableList.of("a", "b")) + .build()); + } + + @Test + public void convertExprReference_toCelReference_withValue() { + Reference reference = + Reference.newBuilder() + .setName("ref") + .setValue(Constant.newBuilder().setInt64Value(1).build()) + .build(); + + CelReference celReference = CelExprConverter.exprReferenceToCelReference(reference); + + assertThat(celReference) + .isEqualTo( + CelReference.newBuilder().setName("ref").setValue(CelConstant.ofValue(1)).build()); + } + + @Test + public void convertCelNotSet_toExprNotSet() { + CelExpr celExpr = CelExpr.ofNotSet(1); + + Expr expr = CelExprConverter.fromCelExpr(celExpr); + + assertThat(expr).isEqualTo(Expr.newBuilder().setId(1).build()); + } + + @Test + public void convertCelIdent_toExprIdent() { + CelExpr celExpr = CelExpr.ofIdent(2, "Test"); + + Expr expr = CelExprConverter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(2) + .setIdentExpr(Ident.newBuilder().setName("Test").build()) + .build()); + } + + @Test + @TestParameters("{isTestOnly: true}") + @TestParameters("{isTestOnly: false}") + public void convertCelSelect_toExprSelect(boolean isTestOnly) { + CelExpr celExpr = + CelExpr.ofSelect(3, CelExpr.ofConstant(4, CelConstant.ofValue(true)), "field", isTestOnly); + + Expr expr = CelExprConverter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(3) + .setSelectExpr( + Select.newBuilder() + .setField("field") + .setOperand( + Expr.newBuilder() + .setId(4) + .setConstExpr(Constant.newBuilder().setBoolValue(true).build())) + .setTestOnly(isTestOnly)) + .build()); + } + + @Test + public void convertCelCall_toExprCall() { + CelExpr celExpr = + CelExpr.ofCall( + 1, + Optional.of(CelExpr.ofConstant(2, CelConstant.ofValue(10))), + "func", + ImmutableList.of(CelExpr.ofConstant(3, CelConstant.ofValue(20)))); + + Expr expr = CelExprConverter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setCallExpr( + Call.newBuilder() + .setTarget(newInt64ConstantExpr(2, 10)) + .setFunction("func") + .addArgs(newInt64ConstantExpr(3, 20)) + .build()) + .build()); + } + + @Test + public void convertCelList_toExprList() { + CelExpr celExpr = + CelExpr.ofList( + 1, + ImmutableList.of( + CelExpr.ofConstant(2, CelConstant.ofValue(10)), + CelExpr.ofConstant(3, CelConstant.ofValue(15))), + ImmutableList.of(1)); + + Expr expr = CelExprConverter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setListExpr( + CreateList.newBuilder() + .addElements(newInt64ConstantExpr(2, 10)) + .addElements(newInt64ConstantExpr(3, 15)) + .addOptionalIndices(1) + .build()) + .build()); + } + + @Test + public void convertCelStructExpr_toExprStruct_withFieldKey() { + CelExpr celExpr = + CelExpr.ofStruct( + 1, + "messageName", + ImmutableList.of( + CelExpr.ofStructEntry( + 2, "fieldKey", CelExpr.ofConstant(3, CelConstant.ofValue(10)), true))); + + Expr expr = CelExprConverter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .setMessageName("messageName") + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setFieldKey("fieldKey") + .setValue(newInt64ConstantExpr(3, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build()); + } + + @Test + public void convertCelMapExpr_toExprStruct() { + CelExpr celExpr = + CelExpr.ofMap( + 1, + ImmutableList.of( + CelExpr.ofMapEntry( + 2, + CelExpr.ofConstant(3, CelConstant.ofValue(15)), + CelExpr.ofConstant(4, CelConstant.ofValue(10)), + true))); + + Expr expr = CelExprConverter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setMapKey(newInt64ConstantExpr(3, 15)) + .setValue(newInt64ConstantExpr(4, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build()); + } + + @Test + public void convertCelComprehensionExpr_toExprComprehension() { + CelExpr celExpr = + CelExpr.ofComprehension( + 1, + "iterVar", + CelExpr.ofConstant(2, CelConstant.ofValue(10)), + "accuVar", + CelExpr.ofConstant(3, CelConstant.ofValue(20)), + CelExpr.ofCall(4, Optional.empty(), "testCondition", ImmutableList.of()), + CelExpr.ofCall(5, Optional.empty(), "testStep", ImmutableList.of()), + CelExpr.ofConstant(6, CelConstant.ofValue(30))); + + Expr expr = CelExprConverter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setComprehensionExpr( + Comprehension.newBuilder() + .setIterVar("iterVar") + .setIterRange(newInt64ConstantExpr(2, 10)) + .setAccuVar("accuVar") + .setAccuInit(newInt64ConstantExpr(3, 20)) + .setLoopCondition( + Expr.newBuilder() + .setId(4) + .setCallExpr(Call.newBuilder().setFunction("testCondition").build()) + .build()) + .setLoopStep( + Expr.newBuilder() + .setId(5) + .setCallExpr(Call.newBuilder().setFunction("testStep").build()) + .build()) + .setResult(newInt64ConstantExpr(6, 30)) + .build()) + .build()); + } + + @Test + public void convertCelReference_toExprReference_withOverloadIds() { + CelReference celReference = + CelReference.newBuilder().setName("ref").addOverloadIds(ImmutableList.of("a", "b")).build(); + + Reference reference = CelExprConverter.celReferenceToExprReference(celReference); + + assertThat(reference) + .isEqualTo( + Reference.newBuilder() + .setName("ref") + .addAllOverloadId(ImmutableList.of("a", "b")) + .build()); + } + + @Test + public void convertCelReference_toExprReference_withValue() { + CelReference celReference = + CelReference.newBuilder().setName("ref").setValue(CelConstant.ofValue(1)).build(); + + Reference reference = CelExprConverter.celReferenceToExprReference(celReference); + + assertThat(reference) + .isEqualTo( + Reference.newBuilder() + .setName("ref") + .setValue(Constant.newBuilder().setInt64Value(1).build()) + .build()); + } + + private Expr newInt64ConstantExpr(long id, long value) { + return Expr.newBuilder() + .setId(id) + .setConstExpr(Constant.newBuilder().setInt64Value(value).build()) + .build(); + } +} +// LINT.ThenChange(CelExprV1Alpha1ConverterTest.java) diff --git a/common/src/test/java/dev/cel/common/ast/CelExprFactoryTest.java b/common/src/test/java/dev/cel/common/ast/CelExprFactoryTest.java new file mode 100644 index 000000000..f3d77ea9e --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelExprFactoryTest.java @@ -0,0 +1,40 @@ +// Copyright 2023 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.ast; + +import static com.google.common.truth.Truth.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelExprFactoryTest { + + @Test + public void construct_success() { + CelExprFactory exprFactory = CelExprFactory.newInstance(); + + assertThat(exprFactory).isNotNull(); + } + + @Test + public void nextExprId_startingDefaultIsOne() { + CelExprFactory exprFactory = CelExprFactory.newInstance(); + + assertThat(exprFactory.nextExprId()).isEqualTo(1L); + assertThat(exprFactory.nextExprId()).isEqualTo(2L); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/CelExprFormatterTest.java b/common/src/test/java/dev/cel/common/ast/CelExprFormatterTest.java new file mode 100644 index 000000000..116222d68 --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelExprFormatterTest.java @@ -0,0 +1,375 @@ +// Copyright 2023 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.ast; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.parser.CelStandardMacro; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelExprFormatterTest { + + private enum ConstantTestCase { + BOOL("true", "CONSTANT [1] { value: true }"), + INT("123", "CONSTANT [1] { value: 123 }"), + UINT("123u", "CONSTANT [1] { value: 123u }"), + DOUBLE("3.5", "CONSTANT [1] { value: 3.5 }"), + BYTES("b'abc'", "CONSTANT [1] { value: b\"abc\" }"), + STRING("'hello world'", "CONSTANT [1] { value: \"hello world\" }"); + + private final String expression; + private final String formatted; + + ConstantTestCase(String expression, String formatted) { + this.expression = expression; + this.formatted = formatted; + } + } + + @Test + public void constant(@TestParameter ConstantTestCase constantTestCase) throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile(constantTestCase.expression).getAst(); + + String formattedExpr = CelExprFormatter.format(ast.getExpr()); + + assertThat(formattedExpr).isEqualTo(constantTestCase.formatted); + } + + @Test + public void notSet() { + String formattedExpr = CelExprFormatter.format(CelExpr.ofNotSet(1)); + + assertThat(formattedExpr).isEqualTo("NOT_SET [1] {}"); + } + + @Test + public void select() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("msg.single_int32").getAst(); + + String formattedExpr = CelExprFormatter.format(ast.getExpr()); + + assertThat(formattedExpr) + .isEqualTo("SELECT [2] {\n IDENT [1] {\n name: msg\n }.single_int32\n}"); + } + + @Test + public void call_global() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "test", + CelOverloadDecl.newGlobalOverload( + "test_overload", SimpleType.INT, SimpleType.INT, SimpleType.INT))) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("test(1, 5)").getAst(); + + String formattedExpr = CelExprFormatter.format(ast.getExpr()); + + assertThat(formattedExpr) + .isEqualTo( + "CALL [1] {\n" + + " function: test\n" + + " args: {\n" + + " CONSTANT [2] { value: 1 }\n" + + " CONSTANT [3] { value: 5 }\n" + + " }\n" + + "}"); + } + + @Test + public void call_member() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "test", + CelOverloadDecl.newMemberOverload( + "test_overload", SimpleType.INT, SimpleType.INT, SimpleType.INT))) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("5.test(2)").getAst(); + + String formattedExpr = CelExprFormatter.format(ast.getExpr()); + + assertThat(formattedExpr) + .isEqualTo( + "CALL [2] {\n" + + " function: test\n" + + " target: {\n" + + " CONSTANT [1] { value: 5 }\n" + + " }\n" + + " args: {\n" + + " CONSTANT [3] { value: 2 }\n" + + " }\n" + + "}"); + } + + @Test + public void list() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries(CelOptionalLibrary.INSTANCE) + .build(); + CelAbstractSyntaxTree ast = + celCompiler.compile("[1, 2, ?optional.of(3), ?optional.of(4)]").getAst(); + + String formattedExpr = CelExprFormatter.format(ast.getExpr()); + + assertThat(formattedExpr) + .isEqualTo( + "LIST [1] {\n" + + " elements: {\n" + + " CONSTANT [2] { value: 1 }\n" + + " CONSTANT [3] { value: 2 }\n" + + " CALL [5] {\n" + + " function: optional.of\n" + + " args: {\n" + + " CONSTANT [6] { value: 3 }\n" + + " }\n" + + " }\n" + + " CALL [8] {\n" + + " function: optional.of\n" + + " args: {\n" + + " CONSTANT [9] { value: 4 }\n" + + " }\n" + + " }\n" + + " }\n" + + " optional_indices: [0, 1]\n" + + "}"); + } + + @Test + public void struct() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addLibraries(CelOptionalLibrary.INSTANCE) + .build(); + CelAbstractSyntaxTree ast = + celCompiler + .compile( + "TestAllTypes{single_int64: 1, single_string: 'test', ?single_double:" + + " optional.of(5.0)}") + .getAst(); + + String formattedExpr = CelExprFormatter.format(ast.getExpr()); + + assertThat(formattedExpr) + .isEqualTo( + "STRUCT [1] {\n" + + " name: cel.expr.conformance.proto3.TestAllTypes\n" + + " entries: {\n" + + " ENTRY [2] {\n" + + " field_key: single_int64\n" + + " value: {\n" + + " CONSTANT [3] { value: 1 }\n" + + " }\n" + + " }\n" + + " ENTRY [4] {\n" + + " field_key: single_string\n" + + " value: {\n" + + " CONSTANT [5] { value: \"test\" }\n" + + " }\n" + + " }\n" + + " ENTRY [6] {\n" + + " field_key: single_double\n" + + " optional_entry: true\n" + + " value: {\n" + + " CALL [8] {\n" + + " function: optional.of\n" + + " args: {\n" + + " CONSTANT [9] { value: 5.0 }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + "}"); + } + + @Test + public void map() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addLibraries(CelOptionalLibrary.INSTANCE) + .build(); + CelAbstractSyntaxTree ast = + celCompiler.compile("{1: 'a', 'test': true, ?false: optional.of(3.0)}").getAst(); + + String formattedExpr = CelExprFormatter.format(ast.getExpr()); + + assertThat(formattedExpr) + .isEqualTo( + "MAP [1] {\n" + + " MAP_ENTRY [2] {\n" + + " key: {\n" + + " CONSTANT [3] { value: 1 }\n" + + " }\n" + + " value: {\n" + + " CONSTANT [4] { value: \"a\" }\n" + + " }\n" + + " }\n" + + " MAP_ENTRY [5] {\n" + + " key: {\n" + + " CONSTANT [6] { value: \"test\" }\n" + + " }\n" + + " value: {\n" + + " CONSTANT [7] { value: true }\n" + + " }\n" + + " }\n" + + " MAP_ENTRY [8] {\n" + + " key: {\n" + + " CONSTANT [9] { value: false }\n" + + " }\n" + + " optional_entry: true\n" + + " value: {\n" + + " CALL [11] {\n" + + " function: optional.of\n" + + " args: {\n" + + " CONSTANT [12] { value: 3.0 }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + "}"); + } + + @Test + public void comprehension() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableHiddenAccumulatorVar(true).build()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("[1, 2, 3].exists(x, x > 0)").getAst(); + + String formattedExpr = CelExprFormatter.format(ast.getExpr()); + + assertThat(formattedExpr) + .isEqualTo( + "COMPREHENSION [17] {\n" + + " iter_var: x\n" + + " iter_range: {\n" + + " LIST [1] {\n" + + " elements: {\n" + + " CONSTANT [2] { value: 1 }\n" + + " CONSTANT [3] { value: 2 }\n" + + " CONSTANT [4] { value: 3 }\n" + + " }\n" + + " }\n" + + " }\n" + + " accu_var: @result\n" + + " accu_init: {\n" + + " CONSTANT [10] { value: false }\n" + + " }\n" + + " loop_condition: {\n" + + " CALL [13] {\n" + + " function: @not_strictly_false\n" + + " args: {\n" + + " CALL [12] {\n" + + " function: !_\n" + + " args: {\n" + + " IDENT [11] {\n" + + " name: @result\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " loop_step: {\n" + + " CALL [15] {\n" + + " function: _||_\n" + + " args: {\n" + + " IDENT [14] {\n" + + " name: @result\n" + + " }\n" + + " CALL [8] {\n" + + " function: _>_\n" + + " args: {\n" + + " IDENT [7] {\n" + + " name: x\n" + + " }\n" + + " CONSTANT [9] { value: 0 }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " result: {\n" + + " IDENT [16] {\n" + + " name: @result\n" + + " }\n" + + " }\n" + + "}"); + } + + @Test + public void ternaryWithPresenceTest() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + CelAbstractSyntaxTree ast = + celCompiler.compile("has(msg.single_any) ? msg.single_any : 10").getAst(); + + String formattedExpr = CelExprFormatter.format(ast.getExpr()); + + assertThat(formattedExpr) + .isEqualTo( + "CALL [5] {\n" + + " function: _?_:_\n" + + " args: {\n" + + " SELECT [4] {\n" + + " IDENT [2] {\n" + + " name: msg\n" + + " }.single_any~presence_test\n" + + " }\n" + + " SELECT [7] {\n" + + " IDENT [6] {\n" + + " name: msg\n" + + " }.single_any\n" + + " }\n" + + " CONSTANT [8] { value: 10 }\n" + + " }\n" + + "}"); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/CelExprIdGeneratorTest.java b/common/src/test/java/dev/cel/common/ast/CelExprIdGeneratorTest.java new file mode 100644 index 000000000..c40fa8fa9 --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelExprIdGeneratorTest.java @@ -0,0 +1,50 @@ +// Copyright 2023 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.ast; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.common.ast.CelExprIdGeneratorFactory.StableIdGenerator; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelExprIdGeneratorTest { + @Test + public void newMonotonicIdGenerator_throwsIfIdIsNegative() { + assertThrows( + IllegalArgumentException.class, + () -> CelExprIdGeneratorFactory.newMonotonicIdGenerator(-1)); + } + + @Test + public void newStableIdGenerator_throwsIfIdIsNegative() { + assertThrows( + IllegalArgumentException.class, () -> CelExprIdGeneratorFactory.newStableIdGenerator(-1)); + } + + @Test + public void stableIdGenerator_renumberId() { + StableIdGenerator idGenerator = CelExprIdGeneratorFactory.newStableIdGenerator(0); + + assertThat(idGenerator.renumberId(0)).isEqualTo(0); + assertThat(idGenerator.renumberId(2)).isEqualTo(1); + assertThat(idGenerator.renumberId(2)).isEqualTo(1); + assertThat(idGenerator.renumberId(1)).isEqualTo(2); + assertThat(idGenerator.renumberId(3)).isEqualTo(3); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/CelExprTest.java b/common/src/test/java/dev/cel/common/ast/CelExprTest.java new file mode 100644 index 000000000..e1bd48692 --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelExprTest.java @@ -0,0 +1,519 @@ +// Copyright 2023 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.ast; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelComprehension; +import dev.cel.common.ast.CelExpr.CelIdent; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.common.ast.CelExpr.ExprKind; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelExprTest { + + @Test + public void celExprBuilder_default() { + CelExpr expr = CelExpr.newBuilder().build(); + + assertThat(expr.id()).isEqualTo(0); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.NOT_SET); + } + + @Test + public void celExprBuilder_exprIdSet() { + CelExpr expr = CelExpr.newBuilder().setId(10).build(); + + assertThat(expr.id()).isEqualTo(10); + } + + private enum BuilderExprKindTestCase { + CONSTANT(CelExpr.newBuilder().setConstant(CelConstant.ofValue(1L)).build(), Kind.CONSTANT), + IDENT( + CelExpr.newBuilder().setIdent(CelIdent.newBuilder().setName("ident").build()).build(), + Kind.IDENT), + CALL( + CelExpr.newBuilder().setCall(CelCall.newBuilder().setFunction("function").build()).build(), + Kind.CALL), + SELECT( + CelExpr.newBuilder() + .setSelect( + CelSelect.newBuilder() + .setField("field") + .setOperand(CelExpr.newBuilder().build()) + .build()) + .build(), + Kind.SELECT), + MAP(CelExpr.newBuilder().setMap(CelMap.newBuilder().build()).build(), Kind.MAP), + LIST(CelExpr.newBuilder().setList(CelList.newBuilder().build()).build(), Kind.LIST), + STRUCT(CelExpr.newBuilder().setStruct(CelStruct.newBuilder().build()).build(), Kind.STRUCT), + COMPREHENSION( + CelExpr.newBuilder() + .setComprehension( + CelComprehension.newBuilder() + .setIterVar("iterVar") + .setIterRange(CelExpr.newBuilder().build()) + .setAccuVar("accuVar") + .setAccuInit(CelExpr.newBuilder().build()) + .setLoopCondition(CelExpr.newBuilder().build()) + .setLoopStep(CelExpr.newBuilder().build()) + .setResult(CelExpr.newBuilder().build()) + .build()) + .build(), + Kind.COMPREHENSION); + + private final CelExpr expr; + private final ExprKind.Kind expectedExprKind; + + BuilderExprKindTestCase(CelExpr expr, ExprKind.Kind expectedExprKind) { + this.expr = expr; + this.expectedExprKind = expectedExprKind; + } + } + + @Test + public void celExprBuilder_exprKindSet(@TestParameter BuilderExprKindTestCase builderTestCase) { + assertThat(builderTestCase.expr.exprKind().getKind()) + .isEqualTo(builderTestCase.expectedExprKind); + } + + @Test + public void celExprBuilder_setConstant() { + CelConstant celConstant = CelConstant.ofValue("hello"); + CelExpr celExpr = CelExpr.newBuilder().setConstant(celConstant).build(); + + assertThat(celExpr.constant()).isEqualTo(celConstant); + assertThat(celExpr.toBuilder().constant()).isEqualTo(celConstant); + } + + @Test + public void celExprBuilder_setIdent() { + CelIdent celIdent = CelIdent.newBuilder().setName("ident").build(); + CelExpr celExpr = CelExpr.newBuilder().setIdent(celIdent).build(); + + assertThat(celExpr.ident()).isEqualTo(celIdent); + assertThat(celExpr.toBuilder().ident()).isEqualTo(celIdent); + } + + @Test + public void celExprBuilder_setCall() { + CelCall celCall = + CelCall.newBuilder() + .setFunction("function") + .setTarget(CelExpr.newBuilder().build()) + .build(); + CelExpr celExpr = CelExpr.newBuilder().setCall(celCall).build(); + + assertThat(celExpr.call()).isEqualTo(celCall); + assertThat(celExpr.toBuilder().call()).isEqualTo(celCall); + } + + @Test + public void celExprBuilder_setCall_clearTarget() { + CelCall celCall = + CelCall.newBuilder() + .setFunction("function") + .setTarget(CelExpr.ofConstant(1, CelConstant.ofValue("test"))) + .build(); + CelExpr celExpr = + CelExpr.newBuilder().setCall(celCall.toBuilder().clearTarget().build()).build(); + + assertThat(celExpr.call()).isEqualTo(CelCall.newBuilder().setFunction("function").build()); + assertThat(celExpr.toBuilder().call()) + .isEqualTo(CelCall.newBuilder().setFunction("function").build()); + } + + @Test + public void callBuilder_getArgs() { + CelCall celCall = + CelCall.newBuilder() + .setFunction("function") + .addArgs(CelExpr.ofConstant(1, CelConstant.ofValue("test"))) + .build(); + + assertThat(celCall.toBuilder().getArgs()) + .containsExactly(CelExpr.ofConstant(1, CelConstant.ofValue("test"))); + } + + @Test + public void celExprBuilder_setCall_setArgByIndex() { + CelCall celCall = + CelCall.newBuilder() + .setFunction("function") + .addArgs( + CelExpr.ofConstant(5, CelConstant.ofValue("hello")), + CelExpr.ofConstant(6, CelConstant.ofValue(5))) + .build(); + + CelExpr celExpr = + CelExpr.newBuilder() + .setCall( + celCall.toBuilder() + .setArg(1, CelExpr.ofConstant(7, CelConstant.ofValue("world"))) + .build()) + .build(); + + assertThat(celExpr.call()) + .isEqualTo( + CelCall.newBuilder() + .setFunction("function") + .addArgs( + CelExpr.ofConstant(5, CelConstant.ofValue("hello")), + CelExpr.ofConstant(7, CelConstant.ofValue("world"))) + .build()); + } + + @Test + public void celExprBuilder_setSelect() { + CelSelect celSelect = + CelSelect.newBuilder().setField("field").setOperand(CelExpr.newBuilder().build()).build(); + CelExpr celExpr = CelExpr.newBuilder().setSelect(celSelect).build(); + + assertThat(celExpr.select().testOnly()).isFalse(); + assertThat(celExpr.select()).isEqualTo(celSelect); + assertThat(celExpr.toBuilder().select()).isEqualTo(celSelect); + } + + @Test + public void celExprBuilder_setList() { + CelList celList = + CelList.newBuilder().addElements(CelExpr.ofConstant(1, CelConstant.ofValue(2))).build(); + CelExpr celExpr = CelExpr.newBuilder().setList(celList).build(); + + assertThat(celExpr.list()).isEqualTo(celList); + assertThat(celExpr.toBuilder().list()).isEqualTo(celList); + } + + @Test + public void listBuilder_getArgs() { + CelList celList = + CelList.newBuilder().addElements(CelExpr.ofConstant(1, CelConstant.ofValue(2))).build(); + + assertThat(celList.toBuilder().getElements()) + .containsExactly(CelExpr.ofConstant(1, CelConstant.ofValue(2))); + } + + @Test + public void celExprBuilder_setList_setElementByIndex() { + CelList celList = + CelList.newBuilder() + .addElements( + CelExpr.ofConstant(5, CelConstant.ofValue("hello")), + CelExpr.ofConstant(6, CelConstant.ofValue(5))) + .build(); + + CelExpr celExpr = + CelExpr.newBuilder() + .setList( + celList.toBuilder() + .setElement(1, CelExpr.ofConstant(7, CelConstant.ofValue("world"))) + .build()) + .build(); + + assertThat(celExpr.list()) + .isEqualTo( + CelList.newBuilder() + .addElements( + CelExpr.ofConstant(5, CelConstant.ofValue("hello")), + CelExpr.ofConstant(7, CelConstant.ofValue("world"))) + .build()); + } + + @Test + public void celExprBuilder_setStruct() { + CelStruct celStruct = + CelStruct.newBuilder() + .addEntries( + CelStruct.Entry.newBuilder() + .setId(1) + .setValue(CelExpr.newBuilder().build()) + .setFieldKey("field_key") + .build()) + .build(); + CelExpr celExpr = CelExpr.newBuilder().setStruct(celStruct).build(); + + assertThat(celExpr.struct().entries().get(0).optionalEntry()).isFalse(); + assertThat(celExpr.struct()).isEqualTo(celStruct); + assertThat(celExpr.toBuilder().struct()).isEqualTo(celStruct); + } + + @Test + public void structBuilder_getArgs() { + CelStruct celStruct = + CelStruct.newBuilder() + .addEntries( + CelStruct.Entry.newBuilder() + .setId(1) + .setValue(CelExpr.newBuilder().build()) + .setFieldKey("field_key") + .build()) + .build(); + + assertThat(celStruct.toBuilder().getEntries()) + .containsExactly( + CelStruct.Entry.newBuilder() + .setId(1) + .setValue(CelExpr.newBuilder().build()) + .setFieldKey("field_key") + .build()); + } + + @Test + public void celExprBuilder_setStruct_setEntryByIndex() { + CelStruct celStruct = + CelStruct.newBuilder() + .addEntries( + CelStruct.Entry.newBuilder() + .setId(2) + .setValue( + CelExpr.ofConstant(5, CelConstant.ofValue("hello")).toBuilder().build()) + .setFieldKey("field_key") + .build(), + CelStruct.Entry.newBuilder() + .setId(3) + .setValue(CelExpr.ofConstant(6, CelConstant.ofValue(100)).toBuilder().build()) + .setFieldKey("field_key") + .build()) + .build(); + + CelExpr celExpr = + CelExpr.newBuilder() + .setStruct( + celStruct.toBuilder() + .setEntry( + 1, + CelStruct.Entry.newBuilder() + .setId(4) + .setValue( + CelExpr.ofConstant(6, CelConstant.ofValue("world")).toBuilder() + .build()) + .setFieldKey("field_key") + .build()) + .build()) + .build(); + + assertThat(celExpr.struct()) + .isEqualTo( + CelStruct.newBuilder() + .addEntries( + CelStruct.Entry.newBuilder() + .setId(2) + .setValue( + CelExpr.ofConstant(5, CelConstant.ofValue("hello")).toBuilder().build()) + .setFieldKey("field_key") + .build(), + CelStruct.Entry.newBuilder() + .setId(4) + .setValue( + CelExpr.ofConstant(6, CelConstant.ofValue("world")).toBuilder().build()) + .setFieldKey("field_key") + .build()) + .build()); + } + + @Test + public void celExprBuilder_setComprehension() { + CelComprehension celComprehension = + CelComprehension.newBuilder() + .setIterVar("iterVar") + .setIterRange(CelExpr.newBuilder().build()) + .setAccuVar("accuVar") + .setAccuInit(CelExpr.newBuilder().build()) + .setLoopCondition(CelExpr.newBuilder().build()) + .setLoopStep(CelExpr.newBuilder().build()) + .setResult(CelExpr.newBuilder().build()) + .build(); + CelExpr celExpr = CelExpr.newBuilder().setComprehension(celComprehension).build(); + + assertThat(celExpr.comprehension()).isEqualTo(celComprehension); + assertThat(celExpr.toBuilder().comprehension()).isEqualTo(celComprehension); + } + + @Test + public void celExprBuilder_setComprehensionV2() { + CelComprehension celComprehension = + CelComprehension.newBuilder() + .setIterVar("iterVar") + .setIterVar2("iterVar2") + .setIterRange(CelExpr.newBuilder().build()) + .setAccuVar("accuVar") + .setAccuInit(CelExpr.newBuilder().build()) + .setLoopCondition(CelExpr.newBuilder().build()) + .setLoopStep(CelExpr.newBuilder().build()) + .setResult(CelExpr.newBuilder().build()) + .build(); + CelExpr celExpr = CelExpr.newBuilder().setComprehension(celComprehension).build(); + + assertThat(celExpr.comprehension()).isEqualTo(celComprehension); + assertThat(celExpr.toBuilder().comprehension()).isEqualTo(celComprehension); + } + + @Test + public void getUnderlyingExpression_unmatchedKind_throws( + @TestParameter BuilderExprKindTestCase testCase) { + if (!testCase.expectedExprKind.equals(Kind.NOT_SET)) { + assertThrows(UnsupportedOperationException.class, () -> testCase.expr.exprKind().notSet()); + assertThrows( + UnsupportedOperationException.class, () -> testCase.expr.toBuilder().exprKind().notSet()); + } + if (!testCase.expectedExprKind.equals(Kind.CONSTANT)) { + assertThrows(UnsupportedOperationException.class, testCase.expr::constant); + assertThrows(UnsupportedOperationException.class, () -> testCase.expr.toBuilder().constant()); + } + if (!testCase.expectedExprKind.equals(Kind.IDENT)) { + assertThrows(UnsupportedOperationException.class, testCase.expr::ident); + assertThrows(UnsupportedOperationException.class, () -> testCase.expr.toBuilder().ident()); + } + if (!testCase.expectedExprKind.equals(Kind.SELECT)) { + assertThrows(UnsupportedOperationException.class, testCase.expr::select); + assertThrows(UnsupportedOperationException.class, () -> testCase.expr.toBuilder().select()); + } + if (!testCase.expectedExprKind.equals(Kind.CALL)) { + assertThrows(UnsupportedOperationException.class, testCase.expr::call); + assertThrows(UnsupportedOperationException.class, () -> testCase.expr.toBuilder().call()); + } + if (!testCase.expectedExprKind.equals(Kind.LIST)) { + assertThrows(UnsupportedOperationException.class, testCase.expr::list); + assertThrows(UnsupportedOperationException.class, () -> testCase.expr.toBuilder().list()); + } + if (!testCase.expectedExprKind.equals(Kind.STRUCT)) { + assertThrows(UnsupportedOperationException.class, testCase.expr::struct); + assertThrows(UnsupportedOperationException.class, () -> testCase.expr.toBuilder().struct()); + } + if (!testCase.expectedExprKind.equals(Kind.MAP)) { + assertThrows(UnsupportedOperationException.class, testCase.expr::map); + assertThrows(UnsupportedOperationException.class, () -> testCase.expr.toBuilder().map()); + } + if (!testCase.expectedExprKind.equals(Kind.COMPREHENSION)) { + assertThrows(UnsupportedOperationException.class, testCase.expr::comprehension); + assertThrows( + UnsupportedOperationException.class, () -> testCase.expr.toBuilder().comprehension()); + } + } + + @Test + public void getDefault_unmatchedKind_returnsDefaultInstance( + @TestParameter BuilderExprKindTestCase testCase) { + if (!testCase.expectedExprKind.equals(Kind.CONSTANT)) { + assertThat(testCase.expr.constantOrDefault()).isEqualTo(CelConstant.ofNotSet()); + } + if (!testCase.expectedExprKind.equals(Kind.IDENT)) { + assertThat(testCase.expr.identOrDefault()).isEqualTo(CelIdent.newBuilder().build()); + } + if (!testCase.expectedExprKind.equals(Kind.SELECT)) { + assertThat(testCase.expr.selectOrDefault()).isEqualTo(CelSelect.newBuilder().build()); + } + if (!testCase.expectedExprKind.equals(Kind.CALL)) { + assertThat(testCase.expr.callOrDefault()).isEqualTo(CelCall.newBuilder().build()); + } + if (!testCase.expectedExprKind.equals(Kind.LIST)) { + assertThat(testCase.expr.listOrDefault()).isEqualTo(CelList.newBuilder().build()); + } + if (!testCase.expectedExprKind.equals(Kind.STRUCT)) { + assertThat(testCase.expr.structOrDefault()).isEqualTo(CelStruct.newBuilder().build()); + } + if (!testCase.expectedExprKind.equals(Kind.MAP)) { + assertThat(testCase.expr.mapOrDefault()).isEqualTo(CelMap.newBuilder().build()); + } + if (!testCase.expectedExprKind.equals(Kind.COMPREHENSION)) { + assertThat(testCase.expr.comprehensionOrDefault()) + .isEqualTo(CelComprehension.newBuilder().build()); + } + } + + @Test + public void getDefault_matchedKind_returnsUnderlyingExpression( + @TestParameter BuilderExprKindTestCase testCase) { + switch (testCase.expectedExprKind) { + case NOT_SET: + // no-op + break; + case CONSTANT: + assertThat(testCase.expr.constantOrDefault()).isEqualTo(testCase.expr.constant()); + break; + case IDENT: + assertThat(testCase.expr.identOrDefault()).isEqualTo(testCase.expr.ident()); + break; + case SELECT: + assertThat(testCase.expr.selectOrDefault()).isEqualTo(testCase.expr.select()); + break; + case CALL: + assertThat(testCase.expr.callOrDefault()).isEqualTo(testCase.expr.call()); + break; + case LIST: + assertThat(testCase.expr.listOrDefault()).isEqualTo(testCase.expr.list()); + break; + case STRUCT: + assertThat(testCase.expr.structOrDefault()).isEqualTo(testCase.expr.struct()); + break; + case MAP: + assertThat(testCase.expr.mapOrDefault()).isEqualTo(testCase.expr.map()); + break; + case COMPREHENSION: + assertThat(testCase.expr.comprehensionOrDefault()).isEqualTo(testCase.expr.comprehension()); + break; + } + } + + @Test + public void celMapEntry_keyOrValueNotSet_throws() { + assertThrows(IllegalStateException.class, () -> CelMap.Entry.newBuilder().build()); + assertThrows( + IllegalStateException.class, + () -> CelMap.Entry.newBuilder().setKey(CelExpr.ofNotSet(1)).build()); + assertThrows( + IllegalStateException.class, + () -> CelMap.Entry.newBuilder().setValue(CelExpr.ofNotSet(1)).build()); + } + + @Test + public void celMapEntry_default() { + CelMap.Entry entry = + CelMap.Entry.newBuilder().setKey(CelExpr.ofNotSet(1)).setValue(CelExpr.ofNotSet(2)).build(); + + assertThat(entry.id()).isEqualTo(0); + assertThat(entry.optionalEntry()).isFalse(); + } + + @Test + public void celStructEntry_fieldKeyOrValueNotSet_throws() { + assertThrows(IllegalStateException.class, () -> CelStruct.Entry.newBuilder().build()); + assertThrows( + IllegalStateException.class, + () -> CelStruct.Entry.newBuilder().setFieldKey("fieldKey").build()); + assertThrows( + IllegalStateException.class, + () -> CelStruct.Entry.newBuilder().setValue(CelExpr.ofNotSet(1)).build()); + } + + @Test + public void celStructEntry_default() { + CelStruct.Entry entry = + CelStruct.Entry.newBuilder().setFieldKey("fieldKey").setValue(CelExpr.ofNotSet(1)).build(); + + assertThat(entry.id()).isEqualTo(0); + assertThat(entry.optionalEntry()).isFalse(); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/CelExprV1Alpha1ConverterTest.java b/common/src/test/java/dev/cel/common/ast/CelExprV1Alpha1ConverterTest.java new file mode 100644 index 000000000..193bfa2df --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelExprV1Alpha1ConverterTest.java @@ -0,0 +1,617 @@ +// Copyright 2022 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.ast; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.api.expr.v1alpha1.Constant; +import com.google.api.expr.v1alpha1.Expr; +import com.google.api.expr.v1alpha1.Expr.Call; +import com.google.api.expr.v1alpha1.Expr.Comprehension; +import com.google.api.expr.v1alpha1.Expr.CreateList; +import com.google.api.expr.v1alpha1.Expr.CreateStruct; +import com.google.api.expr.v1alpha1.Expr.Ident; +import com.google.api.expr.v1alpha1.Expr.Select; +import com.google.api.expr.v1alpha1.Reference; +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import com.google.protobuf.NullValue; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.values.CelByteString; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +// LINT.IfChange +@RunWith(TestParameterInjector.class) +public class CelExprV1Alpha1ConverterTest { + private enum ConstantTestCase { + NOT_SET( + Expr.newBuilder().setId(1).setConstExpr(Constant.getDefaultInstance()).build(), + CelExpr.ofConstant(1, CelConstant.ofNotSet())), + NULL( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setNullValue(NullValue.NULL_VALUE).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(dev.cel.common.values.NullValue.NULL_VALUE))), + BOOLEAN( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setBoolValue(true).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(true))), + INT64( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setInt64Value(10).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(10))), + UINT64( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setUint64Value(15).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(UnsignedLong.valueOf(15)))), + DOUBLE( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setDoubleValue(1.5).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(1.5))), + STRING( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setStringValue("Test").build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue("Test"))), + BYTES( + Expr.newBuilder() + .setId(1) + .setConstExpr( + Constant.newBuilder().setBytesValue(ByteString.copyFromUtf8("TEST")).build()) + .build(), + CelExpr.ofConstant(1, CelConstant.ofValue(CelByteString.copyFromUtf8("TEST")))); + + final Expr protoExpr; + final CelExpr celExpr; + + ConstantTestCase(Expr expr, CelExpr celExpr) { + this.protoExpr = expr; + this.celExpr = celExpr; + } + } + + @Test + public void convertConstant_bidirectional(@TestParameter ConstantTestCase constantTestCase) { + CelExpr celExpr = CelExprV1Alpha1Converter.fromExpr(constantTestCase.protoExpr); + Expr expr = CelExprV1Alpha1Converter.fromCelExpr(constantTestCase.celExpr); + + assertThat(celExpr).isEqualTo(constantTestCase.celExpr); + assertThat(expr).isEqualTo(constantTestCase.protoExpr); + } + + @Test + public void convertExprNotSet_toCelNotSet() { + Expr expr = Expr.newBuilder().setId(1).build(); + + CelExpr celExpr = CelExprV1Alpha1Converter.fromExpr(expr); + + assertThat(celExpr).isEqualTo(CelExpr.ofNotSet(1)); + } + + @Test + public void convertExprIdent_toCelIdent() { + Expr expr = + Expr.newBuilder().setId(2).setIdentExpr(Ident.newBuilder().setName("Test").build()).build(); + + CelExpr celExpr = CelExprV1Alpha1Converter.fromExpr(expr); + + assertThat(celExpr).isEqualTo(CelExpr.ofIdent(2, "Test")); + } + + @Test + @TestParameters("{isTestOnly: true}") + @TestParameters("{isTestOnly: false}") + public void convertExprSelect_toCelSelect(boolean isTestOnly) { + Expr expr = + Expr.newBuilder() + .setId(3) + .setSelectExpr( + Select.newBuilder() + .setField("field") + .setOperand( + Expr.newBuilder() + .setId(4) + .setConstExpr(Constant.newBuilder().setBoolValue(true).build())) + .setTestOnly(isTestOnly)) + .build(); + + CelExpr celExpr = CelExprV1Alpha1Converter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofSelect( + 3, CelExpr.ofConstant(4, CelConstant.ofValue(true)), "field", isTestOnly)); + } + + @Test + public void convertExprCall_toCelCall() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setCallExpr( + Call.newBuilder() + .setTarget(newInt64ConstantExpr(2, 10)) + .setFunction("func") + .addArgs(newInt64ConstantExpr(3, 20)) + .build()) + .build(); + + CelExpr celExpr = CelExprV1Alpha1Converter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofCall( + 1, + Optional.of(CelExpr.ofConstant(2, CelConstant.ofValue(10))), + "func", + ImmutableList.of(CelExpr.ofConstant(3, CelConstant.ofValue(20))))); + } + + @Test + public void convertExprList_toCelList() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setListExpr( + CreateList.newBuilder() + .addElements(newInt64ConstantExpr(2, 10)) + .addElements(newInt64ConstantExpr(3, 15)) + .addOptionalIndices(1) + .build()) + .build(); + + CelExpr celExpr = CelExprV1Alpha1Converter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofList( + 1, + ImmutableList.of( + CelExpr.ofConstant(2, CelConstant.ofValue(10)), + CelExpr.ofConstant(3, CelConstant.ofValue(15))), + ImmutableList.of(1))); + } + + @Test + public void convertExprStructExpr_toCelStruct() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .setMessageName("messageName") + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setFieldKey("fieldKey") + .setValue(newInt64ConstantExpr(3, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build(); + + CelExpr celExpr = CelExprV1Alpha1Converter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofStruct( + 1, + "messageName", + ImmutableList.of( + CelExpr.ofStructEntry( + 2, "fieldKey", CelExpr.ofConstant(3, CelConstant.ofValue(10)), true)))); + } + + @Test + public void convertExprStructExpr_invalidMapKey_throws() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .setMessageName("messageName") + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setMapKey( + Expr.getDefaultInstance()) // A message creation should not have a + // map key set. + .setValue(newInt64ConstantExpr(3, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build(); + + IllegalArgumentException e = + assertThrows(IllegalArgumentException.class, () -> CelExprV1Alpha1Converter.fromExpr(expr)); + + assertThat(e).hasMessageThat().contains("Unexpected struct key kind case"); + } + + @Test + public void convertExprStructExpr_invalidFieldKey_throws() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setFieldKey("Bogus") // A map creation should not have a field key set + .setValue(newInt64ConstantExpr(3, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build(); + + IllegalArgumentException e = + assertThrows(IllegalArgumentException.class, () -> CelExprV1Alpha1Converter.fromExpr(expr)); + + assertThat(e).hasMessageThat().contains("Unexpected map key kind case"); + } + + @Test + public void convertExprStructExpr_toCelMap() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setMapKey(newInt64ConstantExpr(3, 15)) + .setValue(newInt64ConstantExpr(4, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build(); + + CelExpr celExpr = CelExprV1Alpha1Converter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofMap( + 1, + ImmutableList.of( + CelExpr.ofMapEntry( + 2, + CelExpr.ofConstant(3, CelConstant.ofValue(15)), + CelExpr.ofConstant(4, CelConstant.ofValue(10)), + true)))); + } + + @Test + public void convertExprComprehensionExpr_toCelComprehension() { + Expr expr = + Expr.newBuilder() + .setId(1) + .setComprehensionExpr( + Comprehension.newBuilder() + .setIterVar("iterVar") + .setIterRange(newInt64ConstantExpr(2, 10)) + .setAccuVar("accuVar") + .setAccuInit(newInt64ConstantExpr(3, 20)) + .setLoopCondition( + Expr.newBuilder() + .setId(4) + .setCallExpr(Call.newBuilder().setFunction("testCondition").build()) + .build()) + .setLoopStep( + Expr.newBuilder() + .setId(5) + .setCallExpr(Call.newBuilder().setFunction("testStep").build()) + .build()) + .setResult(newInt64ConstantExpr(6, 30)) + .build()) + .build(); + + CelExpr celExpr = CelExprV1Alpha1Converter.fromExpr(expr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofComprehension( + 1, + "iterVar", + CelExpr.ofConstant(2, CelConstant.ofValue(10)), + "accuVar", + CelExpr.ofConstant(3, CelConstant.ofValue(20)), + CelExpr.ofCall(4, Optional.empty(), "testCondition", ImmutableList.of()), + CelExpr.ofCall(5, Optional.empty(), "testStep", ImmutableList.of()), + CelExpr.ofConstant(6, CelConstant.ofValue(30)))); + } + + @Test + public void convertExprReference_toCelReference_withOverloadIds() { + Reference reference = + Reference.newBuilder().setName("ref").addAllOverloadId(ImmutableList.of("a", "b")).build(); + + CelReference celReference = CelExprV1Alpha1Converter.exprReferenceToCelReference(reference); + + assertThat(celReference) + .isEqualTo( + CelReference.newBuilder() + .setName("ref") + .addOverloadIds(ImmutableList.of("a", "b")) + .build()); + } + + @Test + public void convertExprReference_toCelReference_withValue() { + Reference reference = + Reference.newBuilder() + .setName("ref") + .setValue(Constant.newBuilder().setInt64Value(1).build()) + .build(); + + CelReference celReference = CelExprV1Alpha1Converter.exprReferenceToCelReference(reference); + + assertThat(celReference) + .isEqualTo( + CelReference.newBuilder().setName("ref").setValue(CelConstant.ofValue(1)).build()); + } + + @Test + public void convertCelNotSet_toExprNotSet() { + CelExpr celExpr = CelExpr.ofNotSet(1); + + Expr expr = CelExprV1Alpha1Converter.fromCelExpr(celExpr); + + assertThat(expr).isEqualTo(Expr.newBuilder().setId(1).build()); + } + + @Test + public void convertCelIdent_toExprIdent() { + CelExpr celExpr = CelExpr.ofIdent(2, "Test"); + + Expr expr = CelExprV1Alpha1Converter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(2) + .setIdentExpr(Ident.newBuilder().setName("Test").build()) + .build()); + } + + @Test + @TestParameters("{isTestOnly: true}") + @TestParameters("{isTestOnly: false}") + public void convertCelSelect_toExprSelect(boolean isTestOnly) { + CelExpr celExpr = + CelExpr.ofSelect(3, CelExpr.ofConstant(4, CelConstant.ofValue(true)), "field", isTestOnly); + + Expr expr = CelExprV1Alpha1Converter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(3) + .setSelectExpr( + Select.newBuilder() + .setField("field") + .setOperand( + Expr.newBuilder() + .setId(4) + .setConstExpr(Constant.newBuilder().setBoolValue(true).build())) + .setTestOnly(isTestOnly)) + .build()); + } + + @Test + public void convertCelCall_toExprCall() { + CelExpr celExpr = + CelExpr.ofCall( + 1, + Optional.of(CelExpr.ofConstant(2, CelConstant.ofValue(10))), + "func", + ImmutableList.of(CelExpr.ofConstant(3, CelConstant.ofValue(20)))); + + Expr expr = CelExprV1Alpha1Converter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setCallExpr( + Call.newBuilder() + .setTarget(newInt64ConstantExpr(2, 10)) + .setFunction("func") + .addArgs(newInt64ConstantExpr(3, 20)) + .build()) + .build()); + } + + @Test + public void convertCelList_toExprList() { + CelExpr celExpr = + CelExpr.ofList( + 1, + ImmutableList.of( + CelExpr.ofConstant(2, CelConstant.ofValue(10)), + CelExpr.ofConstant(3, CelConstant.ofValue(15))), + ImmutableList.of(1)); + + Expr expr = CelExprV1Alpha1Converter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setListExpr( + CreateList.newBuilder() + .addElements(newInt64ConstantExpr(2, 10)) + .addElements(newInt64ConstantExpr(3, 15)) + .addOptionalIndices(1) + .build()) + .build()); + } + + @Test + public void convertCelStructExpr_toExprStruct_withFieldKey() { + CelExpr celExpr = + CelExpr.ofStruct( + 1, + "messageName", + ImmutableList.of( + CelExpr.ofStructEntry( + 2, "fieldKey", CelExpr.ofConstant(3, CelConstant.ofValue(10)), true))); + + Expr expr = CelExprV1Alpha1Converter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .setMessageName("messageName") + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setFieldKey("fieldKey") + .setValue(newInt64ConstantExpr(3, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build()); + } + + @Test + public void convertCelMapExpr_toExprStruct() { + CelExpr celExpr = + CelExpr.ofMap( + 1, + ImmutableList.of( + CelExpr.ofMapEntry( + 2, + CelExpr.ofConstant(3, CelConstant.ofValue(15)), + CelExpr.ofConstant(4, CelConstant.ofValue(10)), + true))); + + Expr expr = CelExprV1Alpha1Converter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setStructExpr( + CreateStruct.newBuilder() + .addEntries( + CreateStruct.Entry.newBuilder() + .setId(2) + .setMapKey(newInt64ConstantExpr(3, 15)) + .setValue(newInt64ConstantExpr(4, 10)) + .setOptionalEntry(true) + .build()) + .build()) + .build()); + } + + @Test + public void convertCelComprehensionExpr_toExprComprehension() { + CelExpr celExpr = + CelExpr.ofComprehension( + 1, + "iterVar", + CelExpr.ofConstant(2, CelConstant.ofValue(10)), + "accuVar", + CelExpr.ofConstant(3, CelConstant.ofValue(20)), + CelExpr.ofCall(4, Optional.empty(), "testCondition", ImmutableList.of()), + CelExpr.ofCall(5, Optional.empty(), "testStep", ImmutableList.of()), + CelExpr.ofConstant(6, CelConstant.ofValue(30))); + + Expr expr = CelExprV1Alpha1Converter.fromCelExpr(celExpr); + + assertThat(expr) + .isEqualTo( + Expr.newBuilder() + .setId(1) + .setComprehensionExpr( + Comprehension.newBuilder() + .setIterVar("iterVar") + .setIterRange(newInt64ConstantExpr(2, 10)) + .setAccuVar("accuVar") + .setAccuInit(newInt64ConstantExpr(3, 20)) + .setLoopCondition( + Expr.newBuilder() + .setId(4) + .setCallExpr(Call.newBuilder().setFunction("testCondition").build()) + .build()) + .setLoopStep( + Expr.newBuilder() + .setId(5) + .setCallExpr(Call.newBuilder().setFunction("testStep").build()) + .build()) + .setResult(newInt64ConstantExpr(6, 30)) + .build()) + .build()); + } + + @Test + public void convertCelReference_toExprReference_withOverloadIds() { + CelReference celReference = + CelReference.newBuilder().setName("ref").addOverloadIds(ImmutableList.of("a", "b")).build(); + + Reference reference = CelExprV1Alpha1Converter.celReferenceToExprReference(celReference); + + assertThat(reference) + .isEqualTo( + Reference.newBuilder() + .setName("ref") + .addAllOverloadId(ImmutableList.of("a", "b")) + .build()); + } + + @Test + public void convertCelReference_toExprReference_withValue() { + CelReference celReference = + CelReference.newBuilder().setName("ref").setValue(CelConstant.ofValue(1)).build(); + + Reference reference = CelExprV1Alpha1Converter.celReferenceToExprReference(celReference); + + assertThat(reference) + .isEqualTo( + Reference.newBuilder() + .setName("ref") + .setValue(Constant.newBuilder().setInt64Value(1).build()) + .build()); + } + + private Expr newInt64ConstantExpr(long id, long value) { + return Expr.newBuilder() + .setId(id) + .setConstExpr(Constant.newBuilder().setInt64Value(value).build()) + .build(); + } +} +// LINT.ThenChange(CelExprConverterTest.java) diff --git a/common/src/test/java/dev/cel/common/ast/CelExprVisitorTest.java b/common/src/test/java/dev/cel/common/ast/CelExprVisitorTest.java new file mode 100644 index 000000000..97f1a4a1b --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelExprVisitorTest.java @@ -0,0 +1,367 @@ +// Copyright 2023 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.ast; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelComprehension; +import dev.cel.common.ast.CelExpr.CelIdent; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.common.ast.CelExpr.CelStruct.Entry; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.parser.CelStandardMacro; +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelExprVisitorTest { + + @AutoValue + public abstract static class VisitedReference { + public abstract Optional constant(); + + public abstract Optional identifier(); + + public abstract Optional select(); + + public abstract Optional call(); + + public abstract Optional struct(); + + public abstract Optional map(); + + public abstract Optional list(); + + public abstract Optional comprehension(); + + public abstract ImmutableList arguments(); + + @AutoValue.Builder + public abstract static class Builder { + public abstract Builder setConstant(CelConstant value); + + public abstract Builder setIdentifier(CelIdent value); + + public abstract Builder setSelect(CelSelect value); + + public abstract Builder setCall(CelCall value); + + public abstract Builder setStruct(CelStruct value); + + public abstract Builder setMap(CelMap value); + + public abstract Builder setList(CelList value); + + public abstract Builder setComprehension(CelComprehension value); + + public abstract Builder setArguments(ImmutableList value); + + abstract ImmutableList.Builder argumentsBuilder(); + + public Builder addArguments(CelExpr... arguments) { + argumentsBuilder().add(arguments); + return this; + } + + public abstract VisitedReference build(); + } + + public static Builder newBuilder() { + return new AutoValue_CelExprVisitorTest_VisitedReference.Builder(); + } + } + + private static class CelExprVisitorTestImpl extends CelExprVisitor { + private final VisitedReference.Builder visitedReference = VisitedReference.newBuilder(); + + @Override + protected void visit(CelExpr expr, CelConstant constant) { + visitedReference.setConstant(constant); + } + + @Override + protected void visit(CelExpr expr, CelIdent ident) { + visitedReference.setIdentifier(ident); + } + + @Override + protected void visit(CelExpr expr, CelSelect select) { + visitedReference.setSelect(select); + super.visit(expr, select); + } + + @Override + protected void visit(CelExpr expr, CelCall call) { + visitedReference.setCall(call); + super.visit(expr, call); + } + + @Override + protected void visit(CelExpr expr, CelStruct struct) { + visitedReference.setStruct(struct); + super.visit(expr, struct); + } + + @Override + protected void visit(CelExpr expr, CelMap map) { + visitedReference.setMap(map); + super.visit(expr, map); + } + + @Override + protected void visit(CelExpr expr, CelList list) { + visitedReference.setList(list); + super.visit(expr, list); + } + + @Override + protected void visit(CelExpr expr, CelComprehension comprehension) { + visitedReference.setComprehension(comprehension); + super.visit(expr, comprehension); + } + + @Override + protected void visitArg(CelExpr expr, CelExpr arg, int argNum) { + visitedReference.addArguments(arg); + super.visitArg(expr, arg, argNum); + } + } + + private CelExprVisitorTestImpl exprVisitorImpl; + + @Before + public void setUp() { + exprVisitorImpl = new CelExprVisitorTestImpl(); + } + + @Test + public void visitConstant() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("'a'").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + assertThat(visited) + .isEqualTo(VisitedReference.newBuilder().setConstant(CelConstant.ofValue("a")).build()); + } + + @Test + public void visitIdentifier() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("ident", SimpleType.INT).build(); + CelAbstractSyntaxTree ast = celCompiler.compile("ident").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setIdentifier(CelIdent.newBuilder().setName("ident").build()) + .build()); + } + + @Test + public void visitSelect() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("TestAllTypes{}.single_int64").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setStruct( + CelStruct.newBuilder() + .setMessageName("cel.expr.conformance.proto3.TestAllTypes") + .build()) + .setSelect( + CelSelect.newBuilder() + .setOperand( + CelExpr.newBuilder() + .setId(1) + .setStruct( + CelStruct.newBuilder() + .setMessageName("cel.expr.conformance.proto3.TestAllTypes") + .build()) + .build()) + .setField("single_int64") + .build()) + .build()); + } + + @Test + public void visitCall() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("'hi'.contains('h')").getAst(); + + exprVisitorImpl.visit(ast); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + CelConstant stringVal = CelConstant.ofValue("h"); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setConstant(stringVal) + .setCall( + CelCall.newBuilder() + .setFunction("contains") + .setTarget(CelExpr.ofConstant(1, CelConstant.ofValue("hi"))) + .addArgs(CelExpr.ofConstant(3, stringVal)) + .build()) + .addArguments(CelExpr.ofConstant(3, stringVal)) + .build()); + } + + @Test + public void visitStruct_fieldkey() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("TestAllTypes{single_int64: 1}").getAst(); + + exprVisitorImpl.visit(ast); + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + + CelConstant longConstant = CelConstant.ofValue(1); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setConstant(longConstant) + .setStruct( + CelStruct.newBuilder() + .addEntries( + Entry.newBuilder() + .setId(2) + .setFieldKey("single_int64") + .setValue(CelExpr.ofConstant(3, longConstant)) + .build()) + .setMessageName("cel.expr.conformance.proto3.TestAllTypes") + .build()) + .build()); + } + + @Test + public void visitMap() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("{'a': 'b'}").getAst(); + + exprVisitorImpl.visit(ast); + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setConstant(CelConstant.ofValue("b")) + .setMap( + CelMap.newBuilder() + .addEntries( + CelMap.Entry.newBuilder() + .setId(2) + .setKey(CelExpr.ofConstant(3, CelConstant.ofValue("a"))) + .setValue(CelExpr.ofConstant(4, CelConstant.ofValue("b"))) + .build()) + .build()) + .build()); + } + + @Test + public void visitList() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("[1, 1]").getAst(); + + exprVisitorImpl.visit(ast.getExpr()); + + VisitedReference visited = exprVisitorImpl.visitedReference.build(); + CelConstant integerVal = CelConstant.ofValue(1); + assertThat(visited) + .isEqualTo( + VisitedReference.newBuilder() + .setConstant(integerVal) + .setList( + CelList.newBuilder() + .addElements(CelExpr.newBuilder().setId(2).setConstant(integerVal).build()) + .addElements(CelExpr.newBuilder().setId(3).setConstant(integerVal).build()) + .build()) + .build()); + } + + @Test + public void visitComprehension() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableHiddenAccumulatorVar(true).build()) + .setStandardMacros(CelStandardMacro.ALL) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("[1, 1].all(x, x == 1)").getAst(); + + exprVisitorImpl.visit(ast.getExpr()); + + VisitedReference visitedReference = exprVisitorImpl.visitedReference.build(); + CelComprehension comprehension = visitedReference.comprehension().get(); + ImmutableList iterRangeElements = + ImmutableList.of( + CelExpr.ofConstant(2, CelConstant.ofValue(1)), + CelExpr.ofConstant(3, CelConstant.ofValue(1))); + + assertThat(comprehension.iterVar()).isEqualTo("x"); + assertThat(comprehension.iterRange().list().elements()).isEqualTo(iterRangeElements); + assertThat(comprehension.accuInit().constant()).isEqualTo(CelConstant.ofValue(true)); + assertThat(comprehension.loopCondition().call().function()) + .isEqualTo(Operator.NOT_STRICTLY_FALSE.getFunction()); + assertThat(comprehension.loopStep().call().function()) + .isEqualTo(Operator.LOGICAL_AND.getFunction()); + assertThat(comprehension.loopStep().call().args()).hasSize(2); + assertThat(visitedReference.list().get().elements()).isEqualTo(iterRangeElements); + assertThat(visitedReference.identifier()) + .hasValue(CelIdent.newBuilder().setName("@result").build()); + assertThat(visitedReference.arguments()).hasSize(10); + } + + @Test + public void visitNotSet_throwsException() { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> exprVisitorImpl.visit(CelExpr.newBuilder().build())); + + assertThat(e).hasMessageThat().contains("unexpected expr kind: NOT_SET"); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/CelMutableAstTest.java b/common/src/test/java/dev/cel/common/ast/CelMutableAstTest.java new file mode 100644 index 000000000..6d2c07b17 --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelMutableAstTest.java @@ -0,0 +1,92 @@ +// Copyright 2024 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.ast; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelMutableAst; +import dev.cel.common.CelMutableSource; +import dev.cel.common.CelOptions; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelStandardMacro; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelMutableAstTest { + + @Test + public void constructMutableAst() { + CelMutableExpr mutableExpr = CelMutableExpr.ofConstant(1L, CelConstant.ofValue("hello world")); + CelMutableSource mutableSource = CelMutableSource.newInstance(); + + CelMutableAst celMutableAst = CelMutableAst.of(mutableExpr, mutableSource); + + assertThat(celMutableAst.expr()).isEqualTo(mutableExpr); + assertThat(celMutableAst.source()).isSameInstanceAs(mutableSource); + } + + @Test + public void fromCelAst_mutableAst_containsMutableExpr() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("'hello world'").getAst(); + + CelMutableAst celMutableAst = CelMutableAst.fromCelAst(ast); + + assertThat(celMutableAst.expr()) + .isEqualTo(CelMutableExpr.ofConstant(1L, CelConstant.ofValue("hello world"))); + } + + @Test + public void getType_success() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("'hello world'").getAst(); + CelMutableAst celMutableAst = CelMutableAst.fromCelAst(ast); + + assertThat(celMutableAst.getType(1L)).hasValue(SimpleType.STRING); + } + + @Test + public void getReference_success() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("size('test')").getAst(); + CelMutableAst celMutableAst = CelMutableAst.fromCelAst(ast); + + assertThat(celMutableAst.getReference(1L)) + .hasValue(CelReference.newBuilder().addOverloadIds("size_string").build()); + } + + @Test + public void parsedAst_roundTrip() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().populateMacroCalls(true).build()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + CelAbstractSyntaxTree ast = celCompiler.parse("[1].exists(x, x > 0)").getAst(); + CelMutableAst celMutableAst = CelMutableAst.fromCelAst(ast); + + CelAbstractSyntaxTree roundTrippedAst = celMutableAst.toParsedAst(); + + assertThat(ast.getExpr()).isEqualTo(roundTrippedAst.getExpr()); + assertThat(roundTrippedAst.getSource().getMacroCalls()).hasSize(1); + assertThat(roundTrippedAst.getSource().getMacroCalls()) + .containsExactlyEntriesIn(ast.getSource().getMacroCalls()); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/CelMutableExprConverterTest.java b/common/src/test/java/dev/cel/common/ast/CelMutableExprConverterTest.java new file mode 100644 index 000000000..76f9f2027 --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelMutableExprConverterTest.java @@ -0,0 +1,514 @@ +// Copyright 2024 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.ast; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.UnsignedLong; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.common.ast.CelMutableExpr.CelMutableCall; +import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; +import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelMutableExprConverterTest { + @SuppressWarnings("Immutable") // Mutable by design + private enum ConstantTestCase { + NOT_SET( + CelMutableExpr.ofConstant(1, CelConstant.ofNotSet()), + CelExpr.ofConstant(1, CelConstant.ofNotSet())), + NULL( + CelMutableExpr.ofConstant(1, CelConstant.ofValue(NullValue.NULL_VALUE)), + CelExpr.ofConstant(1, CelConstant.ofValue(NullValue.NULL_VALUE))), + BOOLEAN( + CelMutableExpr.ofConstant(1, CelConstant.ofValue(true)), + CelExpr.ofConstant(1, CelConstant.ofValue(true))), + INT64( + CelMutableExpr.ofConstant(1, CelConstant.ofValue(10)), + CelExpr.ofConstant(1, CelConstant.ofValue(10))), + UINT64( + CelMutableExpr.ofConstant(1, CelConstant.ofValue(UnsignedLong.valueOf(15))), + CelExpr.ofConstant(1, CelConstant.ofValue(UnsignedLong.valueOf(15)))), + DOUBLE( + CelMutableExpr.ofConstant(1, CelConstant.ofValue(1.5)), + CelExpr.ofConstant(1, CelConstant.ofValue(1.5))), + STRING( + CelMutableExpr.ofConstant(1, CelConstant.ofValue("Test")), + CelExpr.ofConstant(1, CelConstant.ofValue("Test"))), + BYTES( + CelMutableExpr.ofConstant(1, CelConstant.ofValue(CelByteString.copyFromUtf8("TEST"))), + CelExpr.ofConstant(1, CelConstant.ofValue(CelByteString.copyFromUtf8("TEST")))); + + final CelMutableExpr mutableExpr; + final CelExpr celExpr; + + ConstantTestCase(CelMutableExpr mutableExpr, CelExpr celExpr) { + this.mutableExpr = mutableExpr; + this.celExpr = celExpr; + } + } + + @Test + public void convertConstant_bidirectional(@TestParameter ConstantTestCase constantTestCase) { + CelExpr convertedCelExpr = + CelMutableExprConverter.fromMutableExpr(constantTestCase.mutableExpr); + CelMutableExpr convertedMutableExpr = + CelMutableExprConverter.fromCelExpr(constantTestCase.celExpr); + + assertThat(convertedCelExpr).isEqualTo(constantTestCase.celExpr); + assertThat(convertedMutableExpr).isEqualTo(constantTestCase.mutableExpr); + } + + @Test + public void convertMutableNotSet_toCelNotSet() { + CelMutableExpr mutableExpr = CelMutableExpr.ofNotSet(1L); + + CelExpr celExpr = CelMutableExprConverter.fromMutableExpr(mutableExpr); + + assertThat(celExpr).isEqualTo(CelExpr.ofNotSet(1L)); + } + + @Test + public void convertCelNotSet_toMutableNotSet() { + CelExpr celExpr = CelExpr.ofNotSet(1L); + + CelMutableExpr mutableExpr = CelMutableExprConverter.fromCelExpr(celExpr); + + assertThat(mutableExpr).isEqualTo(CelMutableExpr.ofNotSet(1L)); + } + + @Test + public void convertMutableIdent_toCelIdent() { + CelMutableExpr mutableExpr = CelMutableExpr.ofIdent(1L, "x"); + + CelExpr celExpr = CelMutableExprConverter.fromMutableExpr(mutableExpr); + + assertThat(celExpr).isEqualTo(CelExpr.ofIdent(1L, "x")); + } + + @Test + public void convertCelIdent_toMutableIdent() { + CelExpr celExpr = CelExpr.ofIdent(1L, "x"); + + CelMutableExpr mutableExpr = CelMutableExprConverter.fromCelExpr(celExpr); + + assertThat(mutableExpr).isEqualTo(CelMutableExpr.ofIdent(1L, "x")); + } + + @Test + public void convertMutableSelect_toCelSelect() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofSelect( + 1L, + CelMutableSelect.create( + CelMutableExpr.ofIdent(2L, "x"), "field", /* testOnly= */ true)); + + CelExpr celExpr = CelMutableExprConverter.fromMutableExpr(mutableExpr); + + assertThat(celExpr) + .isEqualTo(CelExpr.ofSelect(1L, CelExpr.ofIdent(2L, "x"), "field", /* isTestOnly= */ true)); + } + + @Test + public void convertCelSelect_toMutableSelect() { + CelExpr celExpr = + CelExpr.ofSelect(1L, CelExpr.ofIdent(2L, "x"), "field", /* isTestOnly= */ true); + + CelMutableExpr mutableExpr = CelMutableExprConverter.fromCelExpr(celExpr); + + assertThat(mutableExpr) + .isEqualTo( + CelMutableExpr.ofSelect( + 1L, + CelMutableSelect.create( + CelMutableExpr.ofIdent(2L, "x"), "field", /* testOnly= */ true))); + } + + @Test + public void convertMutableCall_toCelCall() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofCall( + 1L, + CelMutableCall.create( + CelMutableExpr.ofConstant(2L, CelConstant.ofValue("target")), + "function", + CelMutableExpr.ofConstant(3L, CelConstant.ofValue("arg")))); + + CelExpr celExpr = CelMutableExprConverter.fromMutableExpr(mutableExpr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.newBuilder() + .setId(1L) + .setCall( + CelCall.newBuilder() + .setFunction("function") + .setTarget(CelExpr.ofConstant(2L, CelConstant.ofValue("target"))) + .addArgs(CelExpr.ofConstant(3L, CelConstant.ofValue("arg"))) + .build()) + .build()); + } + + @Test + public void convertCelCall_toMutableCall() { + CelExpr celExpr = + CelExpr.newBuilder() + .setId(1L) + .setCall( + CelCall.newBuilder() + .setFunction("function") + .setTarget(CelExpr.ofConstant(2L, CelConstant.ofValue("target"))) + .addArgs(CelExpr.ofConstant(3L, CelConstant.ofValue("arg"))) + .build()) + .build(); + + CelMutableExpr mutableExpr = CelMutableExprConverter.fromCelExpr(celExpr); + + assertThat(mutableExpr) + .isEqualTo( + CelMutableExpr.ofCall( + 1L, + CelMutableCall.create( + CelMutableExpr.ofConstant(2L, CelConstant.ofValue("target")), + "function", + CelMutableExpr.ofConstant(3L, CelConstant.ofValue("arg"))))); + } + + @Test + public void convertMutableList_toCelList() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofList( + 1L, + CelMutableList.create( + ImmutableList.of( + CelMutableExpr.ofConstant(2L, CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(3L, CelConstant.ofValue("element2"))), + ImmutableList.of(0, 1))); + + CelExpr celExpr = CelMutableExprConverter.fromMutableExpr(mutableExpr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofList( + 1L, + ImmutableList.of( + CelExpr.ofConstant(2L, CelConstant.ofValue("element1")), + CelExpr.ofConstant(3L, CelConstant.ofValue("element2"))), + ImmutableList.of(0, 1))); + } + + @Test + public void convertCelList_toMutableList() { + CelExpr celExpr = + CelExpr.ofList( + 1L, + ImmutableList.of( + CelExpr.ofConstant(2L, CelConstant.ofValue("element1")), + CelExpr.ofConstant(3L, CelConstant.ofValue("element2"))), + ImmutableList.of(0, 1)); + + CelMutableExpr mutableExpr = CelMutableExprConverter.fromCelExpr(celExpr); + + assertThat(mutableExpr) + .isEqualTo( + CelMutableExpr.ofList( + 1L, + CelMutableList.create( + ImmutableList.of( + CelMutableExpr.ofConstant(2L, CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(3L, CelConstant.ofValue("element2"))), + ImmutableList.of(0, 1)))); + } + + @Test + public void convertMutableStruct_toCelStruct() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofStruct( + 8L, + CelMutableStruct.create( + "message", + ImmutableList.of( + CelMutableStruct.Entry.create( + 9L, + "field", + CelMutableExpr.ofConstant(10L, CelConstant.ofValue("value")), + /* optionalEntry= */ true)))); + + CelExpr celExpr = CelMutableExprConverter.fromMutableExpr(mutableExpr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofStruct( + 8L, + "message", + ImmutableList.of( + CelStruct.Entry.newBuilder() + .setId(9L) + .setFieldKey("field") + .setValue(CelExpr.ofConstant(10L, CelConstant.ofValue("value"))) + .setOptionalEntry(true) + .build()))); + } + + @Test + public void convertCelStruct_toMutableStruct() { + CelExpr celExpr = + CelExpr.ofStruct( + 8L, + "message", + ImmutableList.of( + CelStruct.Entry.newBuilder() + .setId(9L) + .setFieldKey("field") + .setValue(CelExpr.ofConstant(10L, CelConstant.ofValue("value"))) + .setOptionalEntry(true) + .build())); + + CelMutableExpr mutableExpr = CelMutableExprConverter.fromCelExpr(celExpr); + + assertThat(mutableExpr) + .isEqualTo( + CelMutableExpr.ofStruct( + 8L, + CelMutableStruct.create( + "message", + ImmutableList.of( + CelMutableStruct.Entry.create( + 9L, + "field", + CelMutableExpr.ofConstant(10L, CelConstant.ofValue("value")), + /* optionalEntry= */ true))))); + } + + @Test + public void convertMutableMap_toCelMap() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofMap( + 9L, + CelMutableMap.create( + ImmutableList.of( + CelMutableMap.Entry.create( + 10L, + CelMutableExpr.ofConstant(11L, CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(12L, CelConstant.ofValue("value")), + /* optionalEntry= */ true)))); + + CelExpr celExpr = CelMutableExprConverter.fromMutableExpr(mutableExpr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofMap( + 9L, + ImmutableList.of( + CelExpr.ofMapEntry( + 10L, + CelExpr.ofConstant(11L, CelConstant.ofValue("key")), + CelExpr.ofConstant(12L, CelConstant.ofValue("value")), + true)))); + } + + @Test + public void convertCelMap_toMutableMap() { + CelExpr celExpr = + CelExpr.ofMap( + 9L, + ImmutableList.of( + CelExpr.ofMapEntry( + 10L, + CelExpr.ofConstant(11L, CelConstant.ofValue("key")), + CelExpr.ofConstant(12L, CelConstant.ofValue("value")), + true))); + + CelMutableExpr mutableExpr = CelMutableExprConverter.fromCelExpr(celExpr); + + assertThat(mutableExpr) + .isEqualTo( + CelMutableExpr.ofMap( + 9L, + CelMutableMap.create( + ImmutableList.of( + CelMutableMap.Entry.create( + 10L, + CelMutableExpr.ofConstant(11L, CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(12L, CelConstant.ofValue("value")), + /* optionalEntry= */ true))))); + } + + @Test + public void convertMutableComprehension_toCelComprehension() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofComprehension( + 1L, + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofList( + 2L, + CelMutableList.create( + CelMutableExpr.ofConstant(3L, CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(4L, CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(5L, CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(6L, CelConstant.ofValue(true)), + CelMutableExpr.ofIdent(7L, "__result__"))); + + CelExpr celExpr = CelMutableExprConverter.fromMutableExpr(mutableExpr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofComprehension( + 1L, + "iterVar", + CelExpr.newBuilder() + .setId(2L) + .setList( + CelList.newBuilder() + .addElements(CelExpr.ofConstant(3L, CelConstant.ofValue(true))) + .build()) + .build(), + "accuVar", + CelExpr.ofConstant(4L, CelConstant.ofValue(true)), + CelExpr.ofConstant(5L, CelConstant.ofValue(true)), + CelExpr.ofConstant(6L, CelConstant.ofValue(true)), + CelExpr.ofIdent(7L, "__result__"))); + } + + @Test + public void convertCelComprehension_toMutableComprehension() { + CelExpr celExpr = + CelExpr.ofComprehension( + 1L, + "iterVar", + CelExpr.newBuilder() + .setId(2L) + .setList( + CelList.newBuilder() + .addElements(CelExpr.ofConstant(3L, CelConstant.ofValue(true))) + .build()) + .build(), + "accuVar", + CelExpr.ofConstant(4L, CelConstant.ofValue(true)), + CelExpr.ofConstant(5L, CelConstant.ofValue(true)), + CelExpr.ofConstant(6L, CelConstant.ofValue(true)), + CelExpr.ofIdent(7L, "__result__")); + + CelMutableExpr mutableExpr = CelMutableExprConverter.fromCelExpr(celExpr); + assertThat(mutableExpr) + .isEqualTo( + CelMutableExpr.ofComprehension( + 1L, + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofList( + 2L, + CelMutableList.create( + CelMutableExpr.ofConstant(3L, CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(4L, CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(5L, CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(6L, CelConstant.ofValue(true)), + CelMutableExpr.ofIdent(7L, "__result__")))); + } + + @Test + public void convertMutableComprehension_withTwoIterVars_toCelComprehension() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofComprehension( + 1L, + CelMutableComprehension.create( + "iterVar", + "iterVar2", + CelMutableExpr.ofList( + 2L, + CelMutableList.create( + CelMutableExpr.ofConstant(3L, CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(4L, CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(5L, CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(6L, CelConstant.ofValue(true)), + CelMutableExpr.ofIdent(7L, "__result__"))); + + CelExpr celExpr = CelMutableExprConverter.fromMutableExpr(mutableExpr); + + assertThat(celExpr) + .isEqualTo( + CelExpr.ofComprehension( + 1L, + "iterVar", + "iterVar2", + CelExpr.newBuilder() + .setId(2L) + .setList( + CelList.newBuilder() + .addElements(CelExpr.ofConstant(3L, CelConstant.ofValue(true))) + .build()) + .build(), + "accuVar", + CelExpr.ofConstant(4L, CelConstant.ofValue(true)), + CelExpr.ofConstant(5L, CelConstant.ofValue(true)), + CelExpr.ofConstant(6L, CelConstant.ofValue(true)), + CelExpr.ofIdent(7L, "__result__"))); + } + + @Test + public void convertCelComprehension_withTwoIterVars_toMutableComprehension() { + CelExpr celExpr = + CelExpr.ofComprehension( + 1L, + "iterVar", + "iterVar2", + CelExpr.newBuilder() + .setId(2L) + .setList( + CelList.newBuilder() + .addElements(CelExpr.ofConstant(3L, CelConstant.ofValue(true))) + .build()) + .build(), + "accuVar", + CelExpr.ofConstant(4L, CelConstant.ofValue(true)), + CelExpr.ofConstant(5L, CelConstant.ofValue(true)), + CelExpr.ofConstant(6L, CelConstant.ofValue(true)), + CelExpr.ofIdent(7L, "__result__")); + + CelMutableExpr mutableExpr = CelMutableExprConverter.fromCelExpr(celExpr); + assertThat(mutableExpr) + .isEqualTo( + CelMutableExpr.ofComprehension( + 1L, + CelMutableComprehension.create( + "iterVar", + "iterVar2", + CelMutableExpr.ofList( + 2L, + CelMutableList.create( + CelMutableExpr.ofConstant(3L, CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(4L, CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(5L, CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(6L, CelConstant.ofValue(true)), + CelMutableExpr.ofIdent(7L, "__result__")))); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/CelMutableExprTest.java b/common/src/test/java/dev/cel/common/ast/CelMutableExprTest.java new file mode 100644 index 000000000..a44c30bb1 --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelMutableExprTest.java @@ -0,0 +1,1052 @@ +// Copyright 2024 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.ast; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.testing.EqualsTester; +import com.google.common.truth.Correspondence; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelMutableExpr.CelMutableCall; +import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; +import dev.cel.common.ast.CelMutableExpr.CelMutableIdent; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; +import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; +import java.util.ArrayList; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelMutableExprTest { + + @Test + public void ofNotSet() { + CelMutableExpr mutableExpr = CelMutableExpr.ofNotSet(); + + assertThat(mutableExpr.id()).isEqualTo(0L); + assertThat(mutableExpr.notSet()).isNotNull(); + } + + @Test + public void ofNotSet_withId() { + CelMutableExpr mutableExpr = CelMutableExpr.ofNotSet(1L); + + assertThat(mutableExpr.id()).isEqualTo(1L); + assertThat(mutableExpr.notSet()).isNotNull(); + } + + @Test + public void ofConstant() { + CelMutableExpr mutableExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(5L)); + + assertThat(mutableExpr.id()).isEqualTo(0L); + assertThat(mutableExpr.constant()).isEqualTo(CelConstant.ofValue(5L)); + } + + @Test + public void ofConstant_withId() { + CelMutableExpr mutableExpr = CelMutableExpr.ofConstant(1L, CelConstant.ofValue(5L)); + + assertThat(mutableExpr.id()).isEqualTo(1L); + assertThat(mutableExpr.constant()).isEqualTo(CelConstant.ofValue(5L)); + } + + @Test + public void mutableConstant_deepCopy() { + CelMutableExpr mutableExpr = CelMutableExpr.ofConstant(1L, CelConstant.ofValue(5L)); + + CelMutableExpr deepCopiedExpr = CelMutableExpr.newInstance(mutableExpr); + + assertThat(mutableExpr).isEqualTo(deepCopiedExpr); + assertThat(mutableExpr.constant()).isEqualTo(deepCopiedExpr.constant()); + assertThat(mutableExpr).isNotSameInstanceAs(deepCopiedExpr); + // The stored constant itself is immutable, thus remain referentially equal when copied. + assertThat(mutableExpr.constant()).isSameInstanceAs(deepCopiedExpr.constant()); + } + + @Test + public void ofIdent() { + CelMutableExpr mutableExpr = CelMutableExpr.ofIdent("x"); + + assertThat(mutableExpr.id()).isEqualTo(0L); + assertThat(mutableExpr.ident().name()).isEqualTo("x"); + } + + @Test + public void ofIdent_withId() { + CelMutableExpr mutableExpr = CelMutableExpr.ofIdent(1L, "x"); + + assertThat(mutableExpr.id()).isEqualTo(1L); + assertThat(mutableExpr.ident().name()).isEqualTo("x"); + } + + @Test + public void mutableIdent_setName() { + CelMutableIdent ident = CelMutableIdent.create("x"); + + ident.setName("y"); + + assertThat(ident.name()).isEqualTo("y"); + } + + @Test + public void mutableIdent_deepCopy() { + CelMutableExpr mutableExpr = CelMutableExpr.ofIdent(1L, "x"); + + CelMutableExpr deepCopiedExpr = CelMutableExpr.newInstance(mutableExpr); + + assertThat(mutableExpr).isEqualTo(deepCopiedExpr); + assertThat(mutableExpr.ident()).isEqualTo(deepCopiedExpr.ident()); + assertThat(mutableExpr).isNotSameInstanceAs(deepCopiedExpr); + assertThat(mutableExpr.ident()).isNotSameInstanceAs(deepCopiedExpr.ident()); + } + + @Test + public void ofSelect() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofSelect(CelMutableSelect.create(CelMutableExpr.ofIdent("x"), "field")); + + assertThat(mutableExpr.id()).isEqualTo(0L); + assertThat(mutableExpr.select().testOnly()).isFalse(); + assertThat(mutableExpr.select().field()).isEqualTo("field"); + assertThat(mutableExpr.select().operand()).isEqualTo(CelMutableExpr.ofIdent("x")); + } + + @Test + public void ofSelect_withId() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofSelect( + 1L, + CelMutableSelect.create(CelMutableExpr.ofIdent("x"), "field", /* testOnly= */ true)); + + assertThat(mutableExpr.id()).isEqualTo(1L); + assertThat(mutableExpr.select().testOnly()).isTrue(); + assertThat(mutableExpr.select().field()).isEqualTo("field"); + assertThat(mutableExpr.select().operand()).isEqualTo(CelMutableExpr.ofIdent("x")); + } + + @Test + public void mutableSelect_setters() { + CelMutableSelect select = + CelMutableSelect.create(CelMutableExpr.ofIdent("x"), "field", /* testOnly= */ true); + + select.setOperand(CelMutableExpr.ofConstant(CelConstant.ofValue(1L))); + select.setField("field2"); + select.setTestOnly(false); + + assertThat(select.operand()).isEqualTo(CelMutableExpr.ofConstant(CelConstant.ofValue(1L))); + assertThat(select.field()).isEqualTo("field2"); + assertThat(select.testOnly()).isFalse(); + } + + @Test + public void mutableSelect_deepCopy() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofSelect( + 1L, + CelMutableSelect.create(CelMutableExpr.ofIdent("x"), "field", /* testOnly= */ true)); + + CelMutableExpr deepCopiedExpr = CelMutableExpr.newInstance(mutableExpr); + + assertThat(mutableExpr).isEqualTo(deepCopiedExpr); + assertThat(mutableExpr.select()).isEqualTo(deepCopiedExpr.select()); + assertThat(mutableExpr).isNotSameInstanceAs(deepCopiedExpr); + assertThat(mutableExpr.select()).isNotSameInstanceAs(deepCopiedExpr.select()); + } + + @Test + public void ofCall() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofCall( + CelMutableCall.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("target")), + "function", + CelMutableExpr.ofConstant(CelConstant.ofValue("arg")))); + + assertThat(mutableExpr.id()).isEqualTo(0L); + assertThat(mutableExpr.call().target()) + .hasValue(CelMutableExpr.ofConstant(CelConstant.ofValue("target"))); + assertThat(mutableExpr.call().function()).isEqualTo("function"); + assertThat(mutableExpr.call().args()) + .containsExactly(CelMutableExpr.ofConstant(CelConstant.ofValue("arg"))); + } + + @Test + public void ofCall_withId() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofCall( + 1L, + CelMutableCall.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("target")), + "function", + CelMutableExpr.ofConstant(CelConstant.ofValue("arg")))); + + assertThat(mutableExpr.id()).isEqualTo(1L); + assertThat(mutableExpr.call().target()) + .hasValue(CelMutableExpr.ofConstant(CelConstant.ofValue("target"))); + assertThat(mutableExpr.call().function()).isEqualTo("function"); + assertThat(mutableExpr.call().args()) + .containsExactly(CelMutableExpr.ofConstant(CelConstant.ofValue("arg"))); + } + + @Test + public void setId_success() { + CelMutableExpr mutableExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(5L)); + + mutableExpr.setId(2L); + + assertThat(mutableExpr.id()).isEqualTo(2L); + } + + @Test + public void mutableCall_setArgumentAtIndex() { + CelMutableCall call = + CelMutableCall.create("function", CelMutableExpr.ofConstant(CelConstant.ofValue(1L))); + + call.setArg(0, CelMutableExpr.ofConstant(CelConstant.ofValue("hello"))); + + assertThat(call.args()) + .containsExactly(CelMutableExpr.ofConstant(CelConstant.ofValue("hello"))); + assertThat(call.args()).isInstanceOf(ArrayList.class); + } + + @Test + public void mutableCall_setArguments() { + CelMutableCall call = + CelMutableCall.create("function", CelMutableExpr.ofConstant(CelConstant.ofValue(1L))); + + call.setArgs( + ImmutableList.of( + CelMutableExpr.ofConstant(CelConstant.ofValue(2)), + CelMutableExpr.ofConstant(CelConstant.ofValue(3)))); + + assertThat(call.args()) + .containsExactly( + CelMutableExpr.ofConstant(CelConstant.ofValue(2)), + CelMutableExpr.ofConstant(CelConstant.ofValue(3))) + .inOrder(); + assertThat(call.args()).isInstanceOf(ArrayList.class); + } + + @Test + public void mutableCall_addArguments() { + CelMutableCall call = + CelMutableCall.create("function", CelMutableExpr.ofConstant(CelConstant.ofValue(1L))); + + call.addArgs( + CelMutableExpr.ofConstant(CelConstant.ofValue(2)), + CelMutableExpr.ofConstant(CelConstant.ofValue(3))); + + assertThat(call.args()) + .containsExactly( + CelMutableExpr.ofConstant(CelConstant.ofValue(1)), + CelMutableExpr.ofConstant(CelConstant.ofValue(2)), + CelMutableExpr.ofConstant(CelConstant.ofValue(3))) + .inOrder(); + assertThat(call.args()).isInstanceOf(ArrayList.class); + } + + @Test + public void mutableCall_clearArguments() { + CelMutableCall call = + CelMutableCall.create( + "function", + CelMutableExpr.ofConstant(CelConstant.ofValue(1L)), + CelMutableExpr.ofConstant(CelConstant.ofValue(2L))); + + call.clearArgs(); + + assertThat(call.args()).isEmpty(); + } + + @Test + public void mutableCall_setTarget() { + CelMutableCall call = CelMutableCall.create("function"); + + call.setTarget(CelMutableExpr.ofConstant(CelConstant.ofValue("hello"))); + + assertThat(call.target()).hasValue(CelMutableExpr.ofConstant(CelConstant.ofValue("hello"))); + } + + @Test + public void mutableCall_deepCopy() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofCall( + 1L, + CelMutableCall.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("target")), + "function", + CelMutableExpr.ofConstant(CelConstant.ofValue("arg")))); + + CelMutableExpr deepCopiedExpr = CelMutableExpr.newInstance(mutableExpr); + + assertThat(mutableExpr).isEqualTo(deepCopiedExpr); + assertThat(mutableExpr.call()).isEqualTo(deepCopiedExpr.call()); + assertThat(mutableExpr).isNotSameInstanceAs(deepCopiedExpr); + assertThat(mutableExpr.call()).isNotSameInstanceAs(deepCopiedExpr.call()); + } + + @Test + public void mutableCall_setFunction() { + CelMutableCall call = CelMutableCall.create("function"); + + call.setFunction("function2"); + + assertThat(call.function()).isEqualTo("function2"); + } + + @Test + public void ofList() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2")))); + + assertThat(mutableExpr.id()).isEqualTo(0L); + assertThat(mutableExpr.list().elements()) + .containsExactly( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))) + .inOrder(); + assertThat(mutableExpr.list().optionalIndices()).isEmpty(); + } + + @Test + public void ofList_withId() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofList( + 1L, + CelMutableList.create( + ImmutableList.of( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))), + ImmutableList.of(0, 1))); + + assertThat(mutableExpr.id()).isEqualTo(1L); + assertThat(mutableExpr.list().elements()) + .containsExactly( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))) + .inOrder(); + assertThat(mutableExpr.list().optionalIndices()).containsExactly(0, 1).inOrder(); + } + + @Test + public void mutableList_setElementAtIndex() { + CelMutableList list = + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue("element1"))); + + list.setElement(0, CelMutableExpr.ofConstant(CelConstant.ofValue("hello"))); + + assertThat(list.elements()) + .containsExactly(CelMutableExpr.ofConstant(CelConstant.ofValue("hello"))); + assertThat(list.elements()).isInstanceOf(ArrayList.class); + } + + @Test + @SuppressWarnings("ReferenceEquality") // test only on iterating through elements + public void mutableList_deepCopy() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2")))); + + CelMutableExpr deepCopiedExpr = CelMutableExpr.newInstance(mutableExpr); + + assertThat(mutableExpr).isEqualTo(deepCopiedExpr); + assertThat(mutableExpr.list()).isEqualTo(deepCopiedExpr.list()); + assertThat(mutableExpr).isNotSameInstanceAs(deepCopiedExpr); + assertThat(mutableExpr.list()).isNotSameInstanceAs(deepCopiedExpr.list()); + assertThat(mutableExpr.list().elements()) + .comparingElementsUsing( + Correspondence.from( + (e1, e2) -> e1 != e2 && e1.equals(e2), + "are only value equal and not referentially equal")) + .containsExactlyElementsIn(deepCopiedExpr.list().elements()); + } + + @Test + public void ofStruct() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofStruct(CelMutableStruct.create("message", ImmutableList.of())); + + assertThat(mutableExpr.id()).isEqualTo(0L); + assertThat(mutableExpr.struct().messageName()).isEqualTo("message"); + assertThat(mutableExpr.struct().entries()).isEmpty(); + } + + @Test + public void ofStruct_withId() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofStruct( + 8L, + CelMutableStruct.create( + "message", + ImmutableList.of( + CelMutableStruct.Entry.create( + 9L, + "field", + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)))); + + assertThat(mutableExpr.id()).isEqualTo(8L); + assertThat(mutableExpr.struct().messageName()).isEqualTo("message"); + assertThat(mutableExpr.struct().entries()) + .containsExactly( + CelMutableStruct.Entry.create( + 9L, + "field", + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)); + } + + @Test + public void mutableStruct_setEntryAtIndex() { + CelMutableStruct struct = + CelMutableStruct.create( + "message", + ImmutableList.of( + CelMutableStruct.Entry.create( + 1L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value"))))); + CelMutableStruct.Entry newEntry = + CelMutableStruct.Entry.create( + 2L, + "field2", + CelMutableExpr.ofConstant(CelConstant.ofValue("value2")), + /* optionalEntry= */ true); + + struct.setEntry(0, newEntry); + + assertThat(struct.entries()).containsExactly(newEntry); + } + + @Test + public void mutableStructEntry_setters() { + CelMutableStruct.Entry structEntry = + CelMutableStruct.Entry.create( + 1L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value"))); + + structEntry.setId(2L); + structEntry.setFieldKey("field2"); + structEntry.setValue(CelMutableExpr.ofConstant(CelConstant.ofValue("value2"))); + structEntry.setOptionalEntry(true); + + assertThat(structEntry) + .isEqualTo( + CelMutableStruct.Entry.create( + 2L, "field2", CelMutableExpr.ofConstant(CelConstant.ofValue("value2")), true)); + } + + @Test + @SuppressWarnings("ReferenceEquality") // test only on iterating through elements + public void mutableStruct_deepCopy() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofStruct( + 8L, + CelMutableStruct.create( + "message", + ImmutableList.of( + CelMutableStruct.Entry.create( + 8L, + "field", + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)))); + + CelMutableExpr deepCopiedExpr = CelMutableExpr.newInstance(mutableExpr); + + assertThat(mutableExpr).isEqualTo(deepCopiedExpr); + assertThat(mutableExpr.struct()).isEqualTo(deepCopiedExpr.struct()); + assertThat(mutableExpr).isNotSameInstanceAs(deepCopiedExpr); + assertThat(mutableExpr.struct()).isNotSameInstanceAs(deepCopiedExpr.struct()); + assertThat(mutableExpr.struct().entries()) + .isNotSameInstanceAs(deepCopiedExpr.struct().entries()); + assertThat(mutableExpr.struct().entries()) + .comparingElementsUsing( + Correspondence.from( + (e1, e2) -> + e1 != e2 + && e1.equals(e2) + && e1.value() != e2.value() + && e1.value().equals(e2.value()), + "are only value equal and not referentially equal")) + .containsExactlyElementsIn(deepCopiedExpr.struct().entries()); + } + + @Test + public void ofMap() { + CelMutableExpr mutableExpr = CelMutableExpr.ofMap(CelMutableMap.create(ImmutableList.of())); + + assertThat(mutableExpr.id()).isEqualTo(0L); + assertThat(mutableExpr.map().entries()).isEmpty(); + } + + @Test + public void ofMap_withId() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofMap( + 9L, + CelMutableMap.create( + ImmutableList.of( + CelMutableMap.Entry.create( + 10L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)))); + + assertThat(mutableExpr.id()).isEqualTo(9L); + assertThat(mutableExpr.map().entries()) + .containsExactly( + CelMutableMap.Entry.create( + 10L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)); + } + + @Test + public void mutableMap_setEntryAtIndex() { + CelMutableMap map = + CelMutableMap.create( + ImmutableList.of( + CelMutableMap.Entry.create( + 10L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value"))))); + CelMutableMap.Entry newEntry = + CelMutableMap.Entry.create( + 2L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key2")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value2")), + /* optionalEntry= */ true); + + map.setEntry(0, newEntry); + + assertThat(map.entries()).containsExactly(newEntry); + } + + @Test + public void mutableMapEntry_setters() { + CelMutableMap.Entry mapEntry = + CelMutableMap.Entry.create( + 1L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value"))); + + mapEntry.setId(2L); + mapEntry.setKey(CelMutableExpr.ofConstant(CelConstant.ofValue("key2"))); + mapEntry.setValue(CelMutableExpr.ofConstant(CelConstant.ofValue("value2"))); + mapEntry.setOptionalEntry(true); + + assertThat(mapEntry) + .isEqualTo( + CelMutableMap.Entry.create( + 2L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key2")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value2")), + true)); + } + + @Test + @SuppressWarnings("ReferenceEquality") // test only on iterating through elements + public void mutableMap_deepCopy() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofMap( + 9L, + CelMutableMap.create( + ImmutableList.of( + CelMutableMap.Entry.create( + 10L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)))); + + CelMutableExpr deepCopiedExpr = CelMutableExpr.newInstance(mutableExpr); + + assertThat(mutableExpr).isEqualTo(deepCopiedExpr); + assertThat(mutableExpr.map()).isEqualTo(deepCopiedExpr.map()); + assertThat(mutableExpr).isNotSameInstanceAs(deepCopiedExpr); + assertThat(mutableExpr.map()).isNotSameInstanceAs(deepCopiedExpr.map()); + assertThat(mutableExpr.map().entries()) + .comparingElementsUsing( + Correspondence.from( + (e1, e2) -> + e1 != e2 + && e1.equals(e2) + && e1.key() != e2.key() + && e1.key().equals(e2.key()) + && e1.value() != e2.value() + && e1.value().equals(e2.value()), + "are only value equal and not referentially equal")) + .containsExactlyElementsIn(deepCopiedExpr.map().entries()); + } + + @Test + public void ofComprehension() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofComprehension( + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))); + + assertThat(mutableExpr.id()).isEqualTo(0L); + assertThat(mutableExpr.comprehension()) + .isEqualTo( + CelMutableComprehension.create( + "iterVar", + "", + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))); + } + + @Test + public void ofComprehension_withId() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofComprehension( + 10L, + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))); + + assertThat(mutableExpr.id()).isEqualTo(10L); + assertThat(mutableExpr.comprehension()) + .isEqualTo( + CelMutableComprehension.create( + "iterVar", + "", + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))); + } + + @Test + public void mutableComprehension_setters() { + CelMutableComprehension mutableComprehension = + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofNotSet(), + "accuVar", + CelMutableExpr.ofNotSet(), + CelMutableExpr.ofNotSet(), + CelMutableExpr.ofNotSet(), + CelMutableExpr.ofNotSet()); + + mutableComprehension.setIterVar("iterVar2"); + mutableComprehension.setAccuVar("accuVar2"); + mutableComprehension.setIterRange( + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true))))); + mutableComprehension.setAccuInit(CelMutableExpr.ofConstant(CelConstant.ofValue(true))); + mutableComprehension.setLoopCondition(CelMutableExpr.ofConstant(CelConstant.ofValue(true))); + mutableComprehension.setLoopStep(CelMutableExpr.ofConstant(CelConstant.ofValue(true))); + mutableComprehension.setResult(CelMutableExpr.ofIdent("__result__")); + + assertThat(mutableComprehension) + .isEqualTo( + CelMutableComprehension.create( + "iterVar2", + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar2", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))); + } + + @Test + public void mutableComprehension_deepCopy() { + CelMutableExpr mutableExpr = + CelMutableExpr.ofComprehension( + 10L, + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))); + + CelMutableExpr deepCopiedExpr = CelMutableExpr.newInstance(mutableExpr); + + assertThat(mutableExpr).isEqualTo(deepCopiedExpr); + assertThat(mutableExpr).isNotSameInstanceAs(deepCopiedExpr); + assertThat(mutableExpr.comprehension()).isEqualTo(deepCopiedExpr.comprehension()); + assertThat(mutableExpr.comprehension()).isNotSameInstanceAs(deepCopiedExpr.comprehension()); + assertThat(mutableExpr.comprehension().accuInit()) + .isEqualTo(deepCopiedExpr.comprehension().accuInit()); + assertThat(mutableExpr.comprehension().accuInit()) + .isNotSameInstanceAs(deepCopiedExpr.comprehension().accuInit()); + assertThat(mutableExpr.comprehension().iterRange()) + .isEqualTo(deepCopiedExpr.comprehension().iterRange()); + assertThat(mutableExpr.comprehension().iterRange()) + .isNotSameInstanceAs(deepCopiedExpr.comprehension().iterRange()); + assertThat(mutableExpr.comprehension().loopCondition()) + .isEqualTo(deepCopiedExpr.comprehension().loopCondition()); + assertThat(mutableExpr.comprehension().loopCondition()) + .isNotSameInstanceAs(deepCopiedExpr.comprehension().loopCondition()); + assertThat(mutableExpr.comprehension().loopStep()) + .isEqualTo(deepCopiedExpr.comprehension().loopStep()); + assertThat(mutableExpr.comprehension().loopStep()) + .isNotSameInstanceAs(deepCopiedExpr.comprehension().loopStep()); + assertThat(mutableExpr.comprehension().result()) + .isEqualTo(deepCopiedExpr.comprehension().result()); + assertThat(mutableExpr.comprehension().result()) + .isNotSameInstanceAs(deepCopiedExpr.comprehension().result()); + } + + @Test + public void equalityTest() { + new EqualsTester() + .addEqualityGroup(CelMutableExpr.ofNotSet()) + .addEqualityGroup(CelMutableExpr.ofNotSet(1L), CelMutableExpr.ofNotSet(1L)) + .addEqualityGroup(CelMutableExpr.ofConstant(1L, CelConstant.ofValue(2L))) + .addEqualityGroup( + CelMutableExpr.ofConstant(5L, CelConstant.ofValue("hello")), + CelMutableExpr.ofConstant(5L, CelConstant.ofValue("hello"))) + .addEqualityGroup(CelMutableExpr.ofIdent("x")) + .addEqualityGroup(CelMutableExpr.ofIdent(2L, "y"), CelMutableExpr.ofIdent(2L, "y")) + .addEqualityGroup( + CelMutableExpr.ofSelect(CelMutableSelect.create(CelMutableExpr.ofIdent("y"), "field"))) + .addEqualityGroup( + CelMutableExpr.ofSelect( + 4L, CelMutableSelect.create(CelMutableExpr.ofIdent("x"), "test")), + CelMutableExpr.ofSelect( + 4L, CelMutableSelect.create(CelMutableExpr.ofIdent("x"), "test"))) + .addEqualityGroup(CelMutableExpr.ofCall(CelMutableCall.create("function"))) + .addEqualityGroup( + CelMutableExpr.ofCall( + 5L, + CelMutableCall.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("target")), + "function", + CelMutableExpr.ofConstant(CelConstant.ofValue("arg")))), + CelMutableExpr.ofCall( + 5L, + CelMutableCall.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("target")), + "function", + CelMutableExpr.ofConstant(CelConstant.ofValue("arg"))))) + .addEqualityGroup(CelMutableExpr.ofList(CelMutableList.create())) + .addEqualityGroup( + CelMutableExpr.ofList( + 6L, + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2")))), + CelMutableExpr.ofList( + 6L, + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))))) + .addEqualityGroup( + CelMutableExpr.ofStruct(CelMutableStruct.create("message", ImmutableList.of()))) + .addEqualityGroup( + CelMutableExpr.ofStruct( + 7L, + CelMutableStruct.create( + "message", + ImmutableList.of( + CelMutableStruct.Entry.create( + 8L, + "field", + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)))), + CelMutableExpr.ofStruct( + 7L, + CelMutableStruct.create( + "message", + ImmutableList.of( + CelMutableStruct.Entry.create( + 8L, + "field", + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true))))) + .addEqualityGroup(CelMutableExpr.ofMap(CelMutableMap.create(ImmutableList.of()))) + .addEqualityGroup( + CelMutableMap.create( + ImmutableList.of( + CelMutableMap.Entry.create( + 9L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true))), + CelMutableMap.create( + ImmutableList.of( + CelMutableMap.Entry.create( + 9L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)))) + .addEqualityGroup( + CelMutableExpr.ofComprehension( + 10L, + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofNotSet(), + "accuVar", + CelMutableExpr.ofNotSet(), + CelMutableExpr.ofNotSet(), + CelMutableExpr.ofNotSet(), + CelMutableExpr.ofNotSet()))) + .addEqualityGroup( + CelMutableExpr.ofComprehension( + 11L, + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))), + CelMutableExpr.ofComprehension( + 11L, + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__")))) + .addEqualityGroup( + CelMutableExpr.ofComprehension( + 12L, + CelMutableComprehension.create( + "iterVar", + "iterVar2", + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))), + CelMutableExpr.ofComprehension( + 12L, + CelMutableComprehension.create( + "iterVar", + "iterVar2", + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__")))) + .testEquals(); + } + + @SuppressWarnings("Immutable") // Mutable by design + private enum MutableExprKindTestCase { + NOT_SET(CelMutableExpr.ofNotSet(1L)), + CONSTANT(CelMutableExpr.ofConstant(CelConstant.ofValue(2L))), + IDENT(CelMutableExpr.ofIdent("test")), + SELECT(CelMutableExpr.ofSelect(CelMutableSelect.create(CelMutableExpr.ofNotSet(), "field"))), + CALL(CelMutableExpr.ofCall(CelMutableCall.create("call"))), + LIST(CelMutableExpr.ofList(CelMutableList.create())), + STRUCT(CelMutableExpr.ofStruct(CelMutableStruct.create("message", ImmutableList.of()))), + MAP(CelMutableExpr.ofMap(CelMutableMap.create(ImmutableList.of()))), + COMPREHENSION( + CelMutableExpr.ofComprehension( + 10L, + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofNotSet(), + "accuVar", + CelMutableExpr.ofNotSet(), + CelMutableExpr.ofNotSet(), + CelMutableExpr.ofNotSet(), + CelMutableExpr.ofNotSet()))), + ; + + private final CelMutableExpr mutableExpr; + + MutableExprKindTestCase(CelMutableExpr mutableExpr) { + this.mutableExpr = mutableExpr; + } + } + + @Test + public void getExprValue_invalidKind_throws(@TestParameter MutableExprKindTestCase testCase) { + Kind testCaseKind = testCase.mutableExpr.getKind(); + if (!testCaseKind.equals(Kind.NOT_SET)) { + assertThrows(IllegalArgumentException.class, testCase.mutableExpr::notSet); + } + if (!testCaseKind.equals(Kind.CONSTANT)) { + assertThrows(IllegalArgumentException.class, testCase.mutableExpr::constant); + } + if (!testCaseKind.equals(Kind.IDENT)) { + assertThrows(IllegalArgumentException.class, testCase.mutableExpr::ident); + } + if (!testCaseKind.equals(Kind.SELECT)) { + assertThrows(IllegalArgumentException.class, testCase.mutableExpr::select); + } + if (!testCaseKind.equals(Kind.CALL)) { + assertThrows(IllegalArgumentException.class, testCase.mutableExpr::call); + } + if (!testCaseKind.equals(Kind.LIST)) { + assertThrows(IllegalArgumentException.class, testCase.mutableExpr::list); + } + if (!testCaseKind.equals(Kind.STRUCT)) { + assertThrows(IllegalArgumentException.class, testCase.mutableExpr::struct); + } + if (!testCaseKind.equals(Kind.MAP)) { + assertThrows(IllegalArgumentException.class, testCase.mutableExpr::map); + } + if (!testCaseKind.equals(Kind.COMPREHENSION)) { + assertThrows(IllegalArgumentException.class, testCase.mutableExpr::comprehension); + } + } + + @SuppressWarnings("Immutable") // Mutable by design + private enum HashCodeTestCase { + NOT_SET(CelMutableExpr.ofNotSet(1L), -722379961), + CONSTANT(CelMutableExpr.ofConstant(2L, CelConstant.ofValue("test")), -724279919), + IDENT(CelMutableExpr.ofIdent("x"), -721379855), + SELECT( + CelMutableExpr.ofSelect( + 4L, + CelMutableSelect.create(CelMutableExpr.ofIdent("y"), "field", /* testOnly= */ true)), + 1458249843), + CALL( + CelMutableExpr.ofCall( + 5L, + CelMutableCall.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("target")), + "function", + CelMutableExpr.ofConstant(CelConstant.ofValue("arg")))), + -1735261193), + LIST( + CelMutableExpr.ofList( + 6L, + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2")))), + 165341403), + STRUCT( + CelMutableExpr.ofStruct( + 7L, + CelMutableStruct.create( + "message", + ImmutableList.of( + CelMutableStruct.Entry.create( + 8L, + "field", + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)))), + 2064611987), + MAP( + CelMutableExpr.ofMap( + 8L, + CelMutableMap.create( + ImmutableList.of( + CelMutableMap.Entry.create( + 9L, + CelMutableExpr.ofConstant(CelConstant.ofValue("key")), + CelMutableExpr.ofConstant(CelConstant.ofValue("value")), + /* optionalEntry= */ true)))), + 1260717292), + COMPREHENSION( + CelMutableExpr.ofComprehension( + 10L, + CelMutableComprehension.create( + "iterVar", + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))), + -707426392), + COMPREHENSIONV2( + CelMutableExpr.ofComprehension( + 10L, + CelMutableComprehension.create( + "iterVar", + "iterVar2", + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + "accuVar", + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + CelMutableExpr.ofIdent("__result__"))), + 1063550879); + + private final CelMutableExpr mutableExpr; + private final int expectedHashCode; + + HashCodeTestCase(CelMutableExpr mutableExpr, int expectedHashCode) { + this.mutableExpr = mutableExpr; + this.expectedHashCode = expectedHashCode; + } + } + + @Test + public void hashCodeTest(@TestParameter HashCodeTestCase testCase) { + assertThat(testCase.mutableExpr.hashCode()).isEqualTo(testCase.expectedHashCode); + // Run it twice to ensure cached value is stable + assertThat(testCase.mutableExpr.hashCode()).isEqualTo(testCase.expectedHashCode); + } + + @Test + public void propertyMutated_hashCodeChanged() { + CelMutableExpr mutableExpr = CelMutableExpr.ofIdent("x"); + int originalHash = mutableExpr.hashCode(); + + mutableExpr.ident().setName("y"); + + assertThat(originalHash).isNotEqualTo(mutableExpr.hashCode()); + } +} diff --git a/common/src/test/java/dev/cel/common/ast/CelReferenceTest.java b/common/src/test/java/dev/cel/common/ast/CelReferenceTest.java new file mode 100644 index 000000000..dbe6613be --- /dev/null +++ b/common/src/test/java/dev/cel/common/ast/CelReferenceTest.java @@ -0,0 +1,73 @@ +// Copyright 2023 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.ast; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelReferenceTest { + + @Test + public void constructCelReference_withEmptyArguments() { + CelReference reference = CelReference.newBuilder().setName("refName").build(); + + assertThat(reference.name()).isEqualTo("refName"); + assertThat(reference.overloadIds()).isEmpty(); + assertThat(reference.value()).isEmpty(); + } + + @Test + public void constructCelReference_withOverloadIds() { + CelReference reference = + CelReference.newBuilder().setName("refName").addOverloadIds("a", "b", "c").build(); + + assertThat(reference.name()).isEqualTo("refName"); + assertThat(reference.overloadIds()).containsExactly("a", "b", "c"); + assertThat(reference.value()).isEmpty(); + } + + @Test + public void constructCelReference_withValue() { + CelReference reference = + CelReference.newBuilder().setName("refName").setValue(CelConstant.ofValue(10)).build(); + + assertThat(reference.name()).isEqualTo("refName"); + assertThat(reference.overloadIds()).isEmpty(); + assertThat(reference.value()).hasValue(CelConstant.ofValue(10)); + } + + @Test + public void constructCelReference_bothArgumentsSet_throws() { + IllegalArgumentException exception = + assertThrows( + IllegalArgumentException.class, + () -> + CelReference.newBuilder() + .setName("refName") + .addOverloadIds(ImmutableList.of("a", "b", "c")) + .setValue(CelConstant.ofValue(10)) + .build()); + + assertThat(exception) + .hasMessageThat() + .contains("Value and overloadIds cannot be set at the same time."); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/BUILD.bazel b/common/src/test/java/dev/cel/common/internal/BUILD.bazel new file mode 100644 index 000000000..a70489fb4 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/BUILD.bazel @@ -0,0 +1,62 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = [ + "//:license", + ], +) + +java_library( + name = "tests", + testonly = 1, + srcs = glob(["*.java"]), + resources = ["//common/src/test/resources"], + deps = [ + "//:auto_value", + "//:java_truth", + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "//common:options", + "//common/ast", + "//common/internal", + "//common/internal:cel_descriptor_pools", + "//common/internal:comparison_functions", + "//common/internal:converter", + "//common/internal:default_instance_message_factory", + "//common/internal:default_lite_descriptor_pool", + "//common/internal:default_message_factory", + "//common/internal:dynamic_proto", + "//common/internal:errors", + "//common/internal:proto_equality", + "//common/internal:proto_message_factory", + "//common/internal:proto_time_utils", + "//common/internal:well_known_proto", + "//common/src/test/resources:default_instance_message_test_protos_java_proto", + "//common/src/test/resources:service_conflicting_name_java_proto", + "//common/testing", + "//common/values", + "//common/values:cel_byte_string", + "//protobuf:cel_lite_descriptor", + "//testing/protos:multi_file_java_proto", + "//testing/protos:single_file_java_proto", + "//testing/protos:test_all_types_cel_java_proto3", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@com_google_googleapis//google/type:type_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/common/src/test/java/dev/cel/common/internal/CelCodePointArrayTest.java b/common/src/test/java/dev/cel/common/internal/CelCodePointArrayTest.java new file mode 100644 index 000000000..7cb02c5a8 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/CelCodePointArrayTest.java @@ -0,0 +1,77 @@ +// Copyright 2024 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.internal; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameterValuesProvider; +import java.util.Arrays; +import java.util.List; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelCodePointArrayTest { + + @Test + public void computeLineOffset( + @TestParameter(valuesProvider = LineOffsetDataProvider.class) LineOffsetTestCase testCase) { + CelCodePointArray codePointArray = CelCodePointArray.fromString(testCase.text()); + + assertThat(codePointArray.lineOffsets()) + .containsExactlyElementsIn(testCase.offsets()) + .inOrder(); + } + + @AutoValue + abstract static class LineOffsetTestCase { + abstract String text(); + + abstract ImmutableList offsets(); + + static LineOffsetTestCase of(String text, Integer... offsets) { + return of(text, Arrays.asList(offsets)); + } + + static LineOffsetTestCase of(String text, List offsets) { + return new AutoValue_CelCodePointArrayTest_LineOffsetTestCase( + text, ImmutableList.copyOf(offsets)); + } + } + + private static final class LineOffsetDataProvider extends TestParameterValuesProvider { + + @Override + protected List provideValues(Context context) { + return Arrays.asList( + // Empty + LineOffsetTestCase.of("", 1), + // ISO-8859-1 + LineOffsetTestCase.of("hello world", 12), + LineOffsetTestCase.of("hello\nworld", 6, 12), + LineOffsetTestCase.of("hello\nworld\n\nfoo\n", 6, 12, 13, 17, 18), + // BMP + LineOffsetTestCase.of("abc κ°€λ‚˜λ‹€", 8), + LineOffsetTestCase.of("abc\nκ°€λ‚˜λ‹€\nζˆ‘b很ε₯½\n", 4, 8, 13, 14), + // SMP + LineOffsetTestCase.of(" text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘ ", 15), + LineOffsetTestCase.of(" text\nκ°€λ‚˜λ‹€ \nπŸ˜¦πŸ˜πŸ˜‘\n\n", 6, 11, 15, 16, 17)); + } + } +} diff --git a/common/src/test/java/dev/cel/common/internal/CombinedDescriptorPoolTest.java b/common/src/test/java/dev/cel/common/internal/CombinedDescriptorPoolTest.java new file mode 100644 index 000000000..877d6a976 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/CombinedDescriptorPoolTest.java @@ -0,0 +1,107 @@ +// Copyright 2023 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.internal; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.Value; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import dev.cel.expr.conformance.proto2.TestAllTypesExtensions; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CombinedDescriptorPoolTest { + + @Test + public void findDescriptor_descriptorReturnedFromBothPool() { + CelDescriptorPool dynamicDescriptorPool = + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + TestAllTypes.getDescriptor().getFile())); + CombinedDescriptorPool combinedDescriptorPool = + CombinedDescriptorPool.create( + ImmutableList.of(DefaultDescriptorPool.INSTANCE, dynamicDescriptorPool)); + + assertThat(combinedDescriptorPool.findDescriptor(Value.getDescriptor().getFullName())) + .hasValue( + Value.getDescriptor()); // Retrieved from default descriptor pool (well-known-type) + assertThat(combinedDescriptorPool.findDescriptor(TestAllTypes.getDescriptor().getFullName())) + .hasValue(TestAllTypes.getDescriptor()); // Retrieved from the dynamic descriptor pool. + } + + @Test + public void findDescriptor_returnsEmpty() { + CelDescriptorPool descriptorPool = + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + TestAllTypes.getDescriptor().getFile())); + CombinedDescriptorPool combinedDescriptorPool = + CombinedDescriptorPool.create( + ImmutableList.of(DefaultDescriptorPool.INSTANCE, descriptorPool)); + + assertThat(combinedDescriptorPool.findDescriptor("bogus")).isEmpty(); + } + + @Test + public void findExtensionDescriptor_success() { + CelDescriptorPool dynamicDescriptorPool = + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + TestAllTypesExtensions.getDescriptor().getFile())); + CombinedDescriptorPool combinedDescriptorPool = + CombinedDescriptorPool.create( + ImmutableList.of(DefaultDescriptorPool.INSTANCE, dynamicDescriptorPool)); + + Optional fieldDescriptor = + combinedDescriptorPool.findExtensionDescriptor( + TestAllTypes.getDescriptor(), "cel.expr.conformance.proto2.test_all_types_ext"); + + assertThat(fieldDescriptor).isPresent(); + assertThat(fieldDescriptor.get().isExtension()).isTrue(); + assertThat(fieldDescriptor.get().getFullName()) + .isEqualTo("cel.expr.conformance.proto2.test_all_types_ext"); + } + + @Test + public void findExtensionDescriptor_returnsEmpty() { + CelDescriptorPool dynamicDescriptorPool = + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + TestAllTypesExtensions.getDescriptor().getFile())); + CombinedDescriptorPool combinedDescriptorPool = + CombinedDescriptorPool.create( + ImmutableList.of(DefaultDescriptorPool.INSTANCE, dynamicDescriptorPool)); + + assertThat( + combinedDescriptorPool.findExtensionDescriptor(TestAllTypes.getDescriptor(), "bogus")) + .isEmpty(); + } + + @Test + public void getExtensionRegistry_onDefaultPool_returnsEmptyRegistry() { + CombinedDescriptorPool combinedDescriptorPool = + CombinedDescriptorPool.create(ImmutableList.of(DefaultDescriptorPool.INSTANCE)); + + assertThat(combinedDescriptorPool.getExtensionRegistry()) + .isEqualTo(ExtensionRegistry.getEmptyRegistry()); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/ComparisonFunctionsTest.java b/common/src/test/java/dev/cel/common/internal/ComparisonFunctionsTest.java new file mode 100644 index 000000000..7508d2ed8 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/ComparisonFunctionsTest.java @@ -0,0 +1,96 @@ +// Copyright 2022 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.internal; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.primitives.UnsignedLong; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import java.math.BigInteger; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class ComparisonFunctionsTest { + + @Test + @TestParameters("{x: 1.0, y: 1, expect: 0}") + @TestParameters("{x: -2.1, y: -2, expect: -1}") + @TestParameters("{x: 2.1, y: -3, expect: 1}") + @TestParameters("{x: -9223372036854778809.0, y: 1, expect: -1}") + @TestParameters("{x: 9223372036854778809.0, y: 1, expect: 1}") + public void compareDoubleInt(double x, long y, int expect) { + assertThat(ComparisonFunctions.compareDoubleInt(x, y)).isEqualTo(expect); + assertThat(ComparisonFunctions.compareIntDouble(y, x)).isEqualTo(-1 * expect); + } + + @Test + @TestParameters("{x: 1.0, y: 1, expect: 0}") + @TestParameters("{x: -2.1, y: 0, expect: -1}") + @TestParameters("{x: 2.1, y: 1, expect: 1}") + @TestParameters("{x: 18446744073709653620.1, y: 1, expect: 1}") + public void compareDoubleUint(double x, long y, int expect) { + UnsignedLong uy = UnsignedLong.valueOf(y); + assertThat(ComparisonFunctions.compareDoubleUint(x, uy)).isEqualTo(expect); + assertThat(ComparisonFunctions.compareUintDouble(uy, x)).isEqualTo(-1 * expect); + } + + @Test + @TestParameters("{x: 1, y: 1, expect: 0}") + @TestParameters("{x: 1, y: 2, expect: -1}") + @TestParameters("{x: 2, y: -1, expect: 1}") + public void compareUintInt(long x, long y, int expect) { + UnsignedLong ux = UnsignedLong.valueOf(x); + assertThat(ComparisonFunctions.compareUintInt(ux, y)).isEqualTo(expect); + assertThat(ComparisonFunctions.compareIntUint(y, ux)).isEqualTo(-1 * expect); + } + + @Test + public void compareUintIntEdgeCases() { + UnsignedLong ux = UnsignedLong.valueOf(BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE)); + assertThat(ComparisonFunctions.compareUintInt(ux, 1)).isEqualTo(1); + assertThat(ComparisonFunctions.compareIntUint(1, ux)).isEqualTo(-1); + } + + @Test + @TestParameters("{x: 1, y: 1, expect: 0}") + @TestParameters("{x: 1, y: 2, expect: -1}") + @TestParameters("{x: 2, y: -1, expect: 1}") + public void numericCompareDoubleInt(double x, long y, int expect) { + assertThat(ComparisonFunctions.numericCompare(x, y)).isEqualTo(expect); + assertThat(ComparisonFunctions.numericCompare(y, x)).isEqualTo(-1 * expect); + } + + @Test + @TestParameters("{x: 1, y: 1, expect: 0}") + @TestParameters("{x: 1, y: 2, expect: -1}") + @TestParameters("{x: 2, y: 1, expect: 1}") + public void numericCompareDoubleUint(double x, long y, int expect) { + UnsignedLong uy = UnsignedLong.valueOf(y); + assertThat(ComparisonFunctions.numericCompare(x, uy)).isEqualTo(expect); + assertThat(ComparisonFunctions.numericCompare(uy, x)).isEqualTo(-1 * expect); + } + + @Test + @TestParameters("{x: 1, y: 1, expect: 0}") + @TestParameters("{x: 1, y: 2, expect: -1}") + @TestParameters("{x: 2, y: -1, expect: 1}") + public void numericCompareUintInt(long x, long y, int expect) { + UnsignedLong ux = UnsignedLong.valueOf(x); + assertThat(ComparisonFunctions.numericCompare(ux, y)).isEqualTo(expect); + assertThat(ComparisonFunctions.numericCompare(y, ux)).isEqualTo(-1 * expect); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/ConstantsTest.java b/common/src/test/java/dev/cel/common/internal/ConstantsTest.java new file mode 100644 index 000000000..f4a9fc32e --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/ConstantsTest.java @@ -0,0 +1,420 @@ +// Copyright 2022 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.internal; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.primitives.UnsignedLong; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelConstant.Kind; +import dev.cel.common.values.CelByteString; +import java.text.ParseException; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class ConstantsTest { + + @Test + public void parseInt_base10Zero() throws Exception { + CelConstant constant = Constants.parseInt("0"); + assertThat(constant.getKind()).isEqualTo(Kind.INT64_VALUE); + assertThat(constant.int64Value()).isEqualTo(0L); + } + + @Test + public void parseInt_base10Max() throws Exception { + CelConstant constant = Constants.parseInt(Long.toString(Long.MAX_VALUE, 10)); + assertThat(constant.getKind()).isEqualTo(Kind.INT64_VALUE); + assertThat(constant.int64Value()).isEqualTo(Long.MAX_VALUE); + } + + @Test + public void parseInt_base10Min() throws Exception { + CelConstant constant = Constants.parseInt(Long.toString(Long.MIN_VALUE, 10)); + assertThat(constant.getKind()).isEqualTo(Kind.INT64_VALUE); + assertThat(constant.int64Value()).isEqualTo(Long.MIN_VALUE); + } + + @Test + public void parseInt_base16Zero() throws Exception { + CelConstant constant = Constants.parseInt("0x0"); + assertThat(constant.getKind()).isEqualTo(Kind.INT64_VALUE); + assertThat(constant.int64Value()).isEqualTo(0L); + } + + @Test + public void parseInt_base16Max() throws Exception { + CelConstant constant = Constants.parseInt("0x" + Long.toString(Long.MAX_VALUE, 16)); + assertThat(constant.getKind()).isEqualTo(Kind.INT64_VALUE); + assertThat(constant.int64Value()).isEqualTo(Long.MAX_VALUE); + } + + @Test + public void parseInt_base16Min() throws Exception { + CelConstant constant = + Constants.parseInt("-0x" + Long.toString(Long.MIN_VALUE, 16).substring(1)); + assertThat(constant.getKind()).isEqualTo(Kind.INT64_VALUE); + assertThat(constant.int64Value()).isEqualTo(Long.MIN_VALUE); + } + + @Test + public void parseInt_base16ThrowsOnInvalidArgument() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseInt("0xz")); + } + + @Test + public void parseInt_base10ThrowsOnInvalidArgument() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseInt("abcdef")); + } + + @Test + @TestParameters("{literal: 0u}") + @TestParameters("{literal: 0U}") + public void parseUint_base10Zero(String literal) throws Exception { + CelConstant constant = Constants.parseUint(literal); + assertThat(constant.getKind()).isEqualTo(Kind.UINT64_VALUE); + assertThat(constant.uint64Value()).isEqualTo(UnsignedLong.valueOf(0L)); + } + + @Test + @TestParameters("{literal: 18446744073709551615u}") + @TestParameters("{literal: 18446744073709551615U}") + public void parseUint_base10Max(String literal) throws Exception { + CelConstant constant = Constants.parseUint(literal); + assertThat(constant.getKind()).isEqualTo(Kind.UINT64_VALUE); + assertThat(constant.uint64Value()).isEqualTo(UnsignedLong.MAX_VALUE); + } + + @Test + @TestParameters("{literal: 0x0u}") + @TestParameters("{literal: 0x0U}") + public void parseUint_base16Zero(String literal) throws Exception { + CelConstant constant = Constants.parseUint(literal); + assertThat(constant.getKind()).isEqualTo(Kind.UINT64_VALUE); + assertThat(constant.uint64Value()).isEqualTo(UnsignedLong.valueOf(0L)); + } + + @Test + @TestParameters("{literal: 0xffffffffffffffffu}") + @TestParameters("{literal: 0xffffffffffffffffU}") + public void parseUint_base16Max(String literal) throws Exception { + CelConstant constant = Constants.parseUint(literal); + assertThat(constant.getKind()).isEqualTo(Kind.UINT64_VALUE); + assertThat(constant.uint64Value()).isEqualTo(UnsignedLong.MAX_VALUE); + } + + @Test + @TestParameters("{literal: 0xzu}") + @TestParameters("{literal: 0xZU}") + public void parseUint_base16ThrowsOnInvalidArgument(String literal) throws Exception { + assertThrows(ParseException.class, () -> Constants.parseUint(literal)); + } + + @Test + @TestParameters("{literal: abcdefu}") + @TestParameters("{literal: abcdefU}") + public void parseUint_base10ThrowsOnInvalidArgument(String literal) throws Exception { + assertThrows(ParseException.class, () -> Constants.parseUint(literal)); + } + + @Test + public void parseUint_throwsOnMissingSuffix() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseUint("0")); + } + + @Test + public void parseDouble_positiveZero() throws Exception { + CelConstant constant = Constants.parseDouble("0.0"); + assertThat(constant.getKind()).isEqualTo(Kind.DOUBLE_VALUE); + assertThat(constant.doubleValue()).isEqualTo(0.0); + } + + @Test + public void parseDouble_negativeZero() throws Exception { + CelConstant constant = Constants.parseDouble("-0.0"); + assertThat(constant.getKind()).isEqualTo(Kind.DOUBLE_VALUE); + assertThat(constant.doubleValue()).isEqualTo(-0.0); + } + + @Test + public void parseDouble_max() throws Exception { + CelConstant constant = Constants.parseDouble(Double.toString(Double.MAX_VALUE)); + assertThat(constant.getKind()).isEqualTo(Kind.DOUBLE_VALUE); + assertThat(constant.doubleValue()).isEqualTo(Double.MAX_VALUE); + } + + @Test + public void parseDouble_min() throws Exception { + CelConstant constant = Constants.parseDouble(Double.toString(-Double.MAX_VALUE)); + assertThat(constant.getKind()).isEqualTo(Kind.DOUBLE_VALUE); + assertThat(constant.doubleValue()).isEqualTo(-Double.MAX_VALUE); + } + + @Test + public void parseDouble_throwsOnInvalidArgument() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseDouble("0.#")); + } + + @Test + public void parseString_throwsOnInvalidArgument() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseString("")); + assertThrows(ParseException.class, () -> Constants.parseString("\" '")); + assertThrows(ParseException.class, () -> Constants.parseString("''''")); + } + + @Test + public void parseString_escapeSequence() throws Exception { + testQuotedString("\\a\\b\\f\\n\\r\\t\\v\\`\\'\\\"\\?\\\\", "\u0007\b\f\n\r\t\u000b`'\"?\\"); + } + + @Test + public void parseString_normalizesNewlines() throws Exception { + testQuotedString("\r\n\r\n\n", "\n\n\n"); + } + + @Test + public void parseString_throwsOnInvalidEscapeSequence() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseString("\"\\z\"")); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\\\\\\"")); + } + + @Test + public void parseString_octalEscapeSequence() throws Exception { + testQuotedString("\\150\\145\\154\\154\\157", "hello"); + } + + @Test + public void parseString_throwsOnInvalidOctalEscapeSequence() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseString("\"\\0\"")); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\029\"")); + } + + @Test + public void parseString_hexEscapeSequence() throws Exception { + testQuotedString("\\x68\\x65\\x6c\\x6c\\x6f", "hello"); + } + + @Test + public void parseString_throwsOnInvalidHexEscapeSequence() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseString("\"\\x9\"")); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\x9g\"")); + } + + @Test + public void parseString_shortUnicodeEscapeSequence() throws Exception { + testQuotedString("\\u0068\\u0065\\u006c\\u006c\\u006f", "hello"); + } + + @Test + public void parseString_throwsOnInvalidShortUnicodeEscapeSequence() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseString("\"\\u009\"")); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\u009g\"")); + } + + @Test + public void parseString_longUnicodeEscapeSequence() throws Exception { + testQuotedString("\\U00000068\\U00000065\\U0000006c\\U0000006c\\U0000006f", "hello"); + } + + @Test + public void parseString_throwsOnInvalidLongUnicodeEscapeSequence() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseString("\"\\U0000009\"")); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\U0000009g\"")); + } + + @Test + public void parseString_throwsOnInvalidCodePoint() throws Exception { + assertThat( + assertThrows(ParseException.class, () -> Constants.parseString("\"\\uD900\"")) + .getErrorOffset()) + // Should be 1, as the error should start at the beginning of the sequence. + .isEqualTo(1); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\uDD00\"")); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\uDD0\"")); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\U0000D900\"")); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\U0000DD00\"")); + assertThrows(ParseException.class, () -> Constants.parseString("\"\\U00110000\"")); + } + + private static void testString(String actual, String expected) throws Exception { + CelConstant constant = Constants.parseString(actual); + assertThat(constant.getKind()).isEqualTo(Kind.STRING_VALUE); + assertThat(constant.stringValue()).isEqualTo(expected); + } + + private static void testQuotedString(String actual, String expected) throws Exception { + testString("\"" + actual + "\"", expected); + testString("'" + actual + "'", expected); + testString("\"\"\"" + actual + "\"\"\"", expected); + testString("'''" + actual + "'''", expected); + } + + @Test + public void parseBytes_throwsOnInvalidArgument() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseBytes("")); + assertThrows(ParseException.class, () -> Constants.parseBytes("b")); + assertThrows(ParseException.class, () -> Constants.parseBytes("b\" '")); + assertThrows(ParseException.class, () -> Constants.parseBytes("b''''")); + } + + @Test + public void parseBytes_escapeSequence() throws Exception { + testQuotedBytes("\\a\\b\\f\\n\\r\\t\\v\\`\\'\\\"\\?\\\\", "\u0007\b\f\n\r\t\u000b`'\"?\\"); + } + + @Test + public void parseBytes_normalizesNewlines() throws Exception { + testQuotedBytes("\r\n\r\n\n", "\n\n\n"); + } + + @Test + public void parseBytes_throwsOnInvalidEscapeSequence() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseBytes("\"\\z\"")); + assertThrows(ParseException.class, () -> Constants.parseBytes("\"\\\\\\\"")); + } + + @Test + public void parseBytes_octalEscapeSequence() throws Exception { + testQuotedBytes("\\150\\145\\154\\154\\157", "hello"); + } + + @Test + public void parseBytes_throwsOnInvalidOctalEscapeSequence() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseBytes("\"\\0\"")); + assertThrows(ParseException.class, () -> Constants.parseBytes("\"\\029\"")); + } + + @Test + public void parseBytes_hexEscapeSequence() throws Exception { + testQuotedBytes("\\x68\\x65\\x6c\\x6c\\x6f", "hello"); + } + + @Test + public void parseBytes_throwsOnInvalidHexEscapeSequence() throws Exception { + assertThrows(ParseException.class, () -> Constants.parseBytes("\"\\x9\"")); + assertThrows(ParseException.class, () -> Constants.parseBytes("\"\\x9g\"")); + } + + @Test + public void parseBytes_throwsOnShortUnicodeEscapeSequence() throws Exception { + assertThrows( + ParseException.class, + () -> Constants.parseBytes("b\"\\u0068\\u0065\\u006c\\u006c\\u006f\"")); + } + + @Test + public void parseBytes_throwsOnLongUnicodeEscapeSequence() throws Exception { + assertThrows( + ParseException.class, + () -> Constants.parseBytes("b\"\\U00000068\\U00000065\\U0000006c\\U0000006c\\U0000006f\"")); + } + + @Test + public void parseBytes_multibyteCodePoints() throws Exception { + // An input string with 4 code points where each, when represented in UTF-8, encodes to + // different length code unit sequences. + String input = "a\u0080\u0800" + new String(Character.toChars(0x10000)); + testQuotedBytes(input, input); + } + + private static void testBytes(String actual, String expected) throws Exception { + CelConstant constant = Constants.parseBytes(actual); + assertThat(constant.getKind()).isEqualTo(Kind.BYTES_VALUE); + assertThat(constant.bytesValue()).isEqualTo(CelByteString.copyFromUtf8(expected)); + } + + private static void testQuotedBytes(String actual, String expected) throws Exception { + testBytes("b\"" + actual + "\"", expected); + testBytes("b'" + actual + "'", expected); + testBytes("b\"\"\"" + actual + "\"\"\"", expected); + testBytes("b'''" + actual + "'''", expected); + } + + @Test + public void parseRawString_escapeSequence() throws Exception { + // In raw strings, escape sequences are returned as is. + testRawQuotedString( + "\\a\\b\\f\\n\\r\\t\\v\\`\\'\\\"\\?\\\\", "\\a\\b\\f\\n\\r\\t\\v\\`\\'\\\"\\?\\\\"); + } + + private static void testRawString(String actual, String expected) throws Exception { + CelConstant constant = Constants.parseString(actual); + assertThat(constant.getKind()).isEqualTo(Kind.STRING_VALUE); + assertThat(constant.stringValue()).isEqualTo(expected); + } + + private static void testRawQuotedString(String actual, String expected) throws Exception { + testRawString("r\"" + actual + "\"", expected); + testRawString("R\"" + actual + "\"", expected); + testRawString("r'" + actual + "'", expected); + testRawString("R'" + actual + "'", expected); + testRawString("r\"\"\"" + actual + "\"\"\"", expected); + testRawString("R\"\"\"" + actual + "\"\"\"", expected); + testRawString("r'''" + actual + "'''", expected); + testRawString("R'''" + actual + "'''", expected); + } + + @Test + public void parseRawBytes_escapeSequence() throws Exception { + // In raw strings, escape sequences are returned as is. + testRawQuotedBytes( + "\\a\\b\\f\\n\\r\\t\\v\\`\\'\\\"\\?\\\\", "\\a\\b\\f\\n\\r\\t\\v\\`\\'\\\"\\?\\\\"); + } + + private static void testRawBytes(String actual, String expected) throws Exception { + CelConstant constant = Constants.parseBytes(actual); + assertThat(constant.getKind()).isEqualTo(Kind.BYTES_VALUE); + assertThat(constant.bytesValue()).isEqualTo(CelByteString.copyFromUtf8(expected)); + } + + private static void testRawQuotedBytes(String actual, String expected) throws Exception { + testRawBytes("br\"" + actual + "\"", expected); + testRawBytes("rb\"" + actual + "\"", expected); + testRawBytes("bR\"" + actual + "\"", expected); + testRawBytes("Rb\"" + actual + "\"", expected); + testRawBytes("Br\"" + actual + "\"", expected); + testRawBytes("rB\"" + actual + "\"", expected); + testRawBytes("BR\"" + actual + "\"", expected); + testRawBytes("RB\"" + actual + "\"", expected); + testRawBytes("br'" + actual + "'", expected); + testRawBytes("rb'" + actual + "'", expected); + testRawBytes("bR'" + actual + "'", expected); + testRawBytes("Rb'" + actual + "'", expected); + testRawBytes("Br'" + actual + "'", expected); + testRawBytes("rB'" + actual + "'", expected); + testRawBytes("BR'" + actual + "'", expected); + testRawBytes("RB'" + actual + "'", expected); + testRawBytes("br\"\"\"" + actual + "\"\"\"", expected); + testRawBytes("rb\"\"\"" + actual + "\"\"\"", expected); + testRawBytes("bR\"\"\"" + actual + "\"\"\"", expected); + testRawBytes("Rb\"\"\"" + actual + "\"\"\"", expected); + testRawBytes("Br\"\"\"" + actual + "\"\"\"", expected); + testRawBytes("rB\"\"\"" + actual + "\"\"\"", expected); + testRawBytes("BR\"\"\"" + actual + "\"\"\"", expected); + testRawBytes("RB\"\"\"" + actual + "\"\"\"", expected); + testRawBytes("br'''" + actual + "'''", expected); + testRawBytes("rb'''" + actual + "'''", expected); + testRawBytes("bR'''" + actual + "'''", expected); + testRawBytes("Rb'''" + actual + "'''", expected); + testRawBytes("Br'''" + actual + "'''", expected); + testRawBytes("rB'''" + actual + "'''", expected); + testRawBytes("BR'''" + actual + "'''", expected); + testRawBytes("RB'''" + actual + "'''", expected); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/DefaultInstanceMessageFactoryTest.java b/common/src/test/java/dev/cel/common/internal/DefaultInstanceMessageFactoryTest.java new file mode 100644 index 000000000..d6749a391 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/DefaultInstanceMessageFactoryTest.java @@ -0,0 +1,142 @@ +// Copyright 2022 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.internal; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.truth.Truth.assertThat; +import static java.util.Arrays.stream; + +import com.google.common.collect.ImmutableList; +import com.google.common.util.concurrent.MoreExecutors; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Message; +import dev.cel.common.testdata.EnumConflictingNameOuterClass.MessageInEnumConflictingName; +import dev.cel.common.testdata.MessageConflictingNameOuterClass.MessageConflictingName; +import dev.cel.common.testdata.MessageConflictingNameOuterClass.MessageInConflictingNameClass; +import dev.cel.common.testdata.ProtoWithoutJavaOpts.MessageWithoutJavaOpts; +import dev.cel.common.testdata.ServiceConflictingNameOuterClass.StubRequest; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.testdata.ProtoJavaApiVersion1.Proto2JavaVersion1Message; +import dev.cel.common.testing.RepeatedTestProvider; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.ThreadPoolExecutor; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class DefaultInstanceMessageFactoryTest { + + @Before + public void setUp() { + // Reset the statically initialized descriptor map to get clean test runs. + DefaultInstanceMessageLiteFactory.getInstance().resetTypeMap(); + } + + private enum PrototypeDescriptorTestCase { + MESSAGE(TestAllTypes.getDescriptor(), TestAllTypes.getDefaultInstance()), + NESTED_MESSAGE( + TestAllTypes.NestedMessage.getDescriptor(), + TestAllTypes.NestedMessage.getDefaultInstance()), + MESSAGE_WITHOUT_JAVA_OPTS( + MessageWithoutJavaOpts.getDescriptor(), MessageWithoutJavaOpts.getDefaultInstance()), + NESTED_MESSAGE_WITHOUT_JAVA_OPTS( + MessageWithoutJavaOpts.NestedMessage.getDescriptor(), + MessageWithoutJavaOpts.NestedMessage.getDefaultInstance()), + MESSAGE_WITH_CONFLICTING_OUTER_CLASS_NAME( + MessageConflictingName.getDescriptor(), MessageConflictingName.getDefaultInstance()), + NESTED_MESSAGE_WITH_CONFLICTING_OUTER_CLASS_NAME( + MessageConflictingName.NestedMessage.getDescriptor(), + MessageConflictingName.NestedMessage.getDefaultInstance()), + ENUM_WITH_CONFLICTING_OUTER_CLASS_NAME( + MessageInEnumConflictingName.getDescriptor(), + MessageInEnumConflictingName.getDefaultInstance()), + SERVICE_WITH_CONFLICTING_OUTER_CLASS_NAME( + StubRequest.getDescriptor(), StubRequest.getDefaultInstance()), + ANOTHER_MESSAGE_IN_CONFLICTING_OUTER_CLASS_NAME( + MessageInConflictingNameClass.getDescriptor(), + MessageInConflictingNameClass.getDefaultInstance()), + PROTO2_JAVA_VERSION_1_MESSAGE( + Proto2JavaVersion1Message.getDescriptor(), Proto2JavaVersion1Message.getDefaultInstance()); + + final Descriptor descriptor; + final Message defaultInstance; + + PrototypeDescriptorTestCase(Descriptor descriptor, Message defaultInstance) { + this.descriptor = descriptor; + this.defaultInstance = defaultInstance; + } + } + + @Test + public void getPrototype_success(@TestParameter PrototypeDescriptorTestCase testCase) { + Descriptor descriptor = testCase.descriptor; + + Optional defaultMessage = + DefaultInstanceMessageFactory.getInstance().getPrototype(descriptor); + + assertThat(defaultMessage).hasValue(testCase.defaultInstance); + } + + @Test + public void getPrototype_cached_success(@TestParameter PrototypeDescriptorTestCase testCase) { + Descriptor descriptor = testCase.descriptor; + + Optional defaultMessage = + DefaultInstanceMessageFactory.getInstance().getPrototype(descriptor); + Optional defaultMessage2 = + DefaultInstanceMessageFactory.getInstance().getPrototype(descriptor); + + assertThat(defaultMessage).hasValue(testCase.defaultInstance); + assertThat(defaultMessage2).hasValue(testCase.defaultInstance); + } + + @Test + public void getPrototype_concurrentAccess_doesNotThrow( + @TestParameter(valuesProvider = RepeatedTestProvider.class) int unusedTestRunIndex) + throws Exception { + // Arrange + int threadCount = 10; + ExecutorService executor = + MoreExecutors.getExitingExecutorService( + (ThreadPoolExecutor) Executors.newFixedThreadPool(threadCount)); + ImmutableList expectedDefaultInstances = + stream(PrototypeDescriptorTestCase.values()) + .map(x -> x.defaultInstance) + .collect(toImmutableList()); + + // Act + List>> futures = new ArrayList<>(); + for (PrototypeDescriptorTestCase testCase : PrototypeDescriptorTestCase.values()) { + futures.add( + executor.submit( + () -> DefaultInstanceMessageFactory.getInstance().getPrototype(testCase.descriptor))); + } + List evaluatedDefaultInstances = new ArrayList<>(); + for (Future> future : futures) { + evaluatedDefaultInstances.add(future.get().get()); + } + + // Assert + assertThat(evaluatedDefaultInstances).containsExactlyElementsIn(expectedDefaultInstances); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/DefaultLiteDescriptorPoolTest.java b/common/src/test/java/dev/cel/common/internal/DefaultLiteDescriptorPoolTest.java new file mode 100644 index 000000000..198cfde41 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/DefaultLiteDescriptorPoolTest.java @@ -0,0 +1,121 @@ +// Copyright 2025 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.internal; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableSet; +import com.google.common.truth.Expect; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.expr.conformance.proto3.TestAllTypesCelDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.EncodingType; +import dev.cel.protobuf.CelLiteDescriptor.MessageLiteDescriptor; +import java.util.NoSuchElementException; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class DefaultLiteDescriptorPoolTest { + @Rule public final Expect expect = Expect.create(); + + @Test + public void containsAllWellKnownProtos() { + DefaultLiteDescriptorPool descriptorPool = + DefaultLiteDescriptorPool.newInstance(ImmutableSet.of()); + + for (WellKnownProto wellKnownProto : WellKnownProto.values()) { + MessageLiteDescriptor liteDescriptor = + descriptorPool.getDescriptorOrThrow(wellKnownProto.typeName()); + expect.that(liteDescriptor.getProtoTypeName()).isEqualTo(wellKnownProto.typeName()); + } + } + + @Test + public void wellKnownProto_compareAgainstFullDescriptors_allFieldPropertiesAreEqual() { + DefaultLiteDescriptorPool descriptorPool = + DefaultLiteDescriptorPool.newInstance(ImmutableSet.of()); + + for (WellKnownProto wellKnownProto : WellKnownProto.values()) { + Descriptor fullDescriptor = + DefaultDescriptorPool.INSTANCE.findDescriptor(wellKnownProto.typeName()).get(); + MessageLiteDescriptor liteDescriptor = + descriptorPool.getDescriptorOrThrow(wellKnownProto.typeName()); + + for (FieldDescriptor fullFieldDescriptor : fullDescriptor.getFields()) { + String expectMessageTitle = + wellKnownProto.typeName() + ", field number: " + fullFieldDescriptor.getNumber(); + FieldLiteDescriptor fieldLiteDescriptor = + liteDescriptor.getByFieldNumberOrThrow(fullFieldDescriptor.getNumber()); + + expect + .withMessage(expectMessageTitle) + .that(fieldLiteDescriptor.getFieldName()) + .isEqualTo(fullFieldDescriptor.getName()); + expect + .withMessage(expectMessageTitle) + .that(fieldLiteDescriptor.getIsPacked()) + .isEqualTo(fullFieldDescriptor.isPacked()); + expect + .withMessage(expectMessageTitle) + .that(fieldLiteDescriptor.getEncodingType()) + .isEqualTo( + fullFieldDescriptor.isMapField() + ? EncodingType.MAP + : fullFieldDescriptor.isRepeated() ? EncodingType.LIST : EncodingType.SINGULAR); + // Note: enums such as JavaType are semantically equal, but their instances differ. + expect + .withMessage(expectMessageTitle) + .that(fieldLiteDescriptor.getJavaType().toString()) + .isEqualTo(fullFieldDescriptor.getJavaType().toString()); + expect + .withMessage(expectMessageTitle) + .that(fieldLiteDescriptor.getProtoFieldType().toString()) + .isEqualTo(fullFieldDescriptor.getType().toString()); + if (fullFieldDescriptor.getType().equals(FieldDescriptor.Type.MESSAGE)) { + expect + .withMessage(expectMessageTitle) + .that(fieldLiteDescriptor.getFieldProtoTypeName()) + .isEqualTo(fullFieldDescriptor.getMessageType().getFullName()); + } + } + } + } + + @Test + public void findDescriptor_success() { + DefaultLiteDescriptorPool descriptorPool = + DefaultLiteDescriptorPool.newInstance( + ImmutableSet.of(TestAllTypesCelDescriptor.getDescriptor())); + + MessageLiteDescriptor liteDescriptor = + descriptorPool.getDescriptorOrThrow("cel.expr.conformance.proto3.TestAllTypes"); + + assertThat(liteDescriptor.getProtoTypeName()) + .isEqualTo("cel.expr.conformance.proto3.TestAllTypes"); + } + + @Test + public void findDescriptor_throws() { + DefaultLiteDescriptorPool descriptorPool = + DefaultLiteDescriptorPool.newInstance(ImmutableSet.of()); + + assertThrows(NoSuchElementException.class, () -> descriptorPool.getDescriptorOrThrow("foo")); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/DefaultMessageFactoryTest.java b/common/src/test/java/dev/cel/common/internal/DefaultMessageFactoryTest.java new file mode 100644 index 000000000..b26197d04 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/DefaultMessageFactoryTest.java @@ -0,0 +1,118 @@ +// Copyright 2023 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.internal; + +import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; + +import com.google.common.base.Ascii; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.io.Resources; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.TextFormat; +import com.google.protobuf.Value; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import dev.cel.common.internal.ProtoMessageFactory.CombinedMessageFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class DefaultMessageFactoryTest { + + @Test + public void newBuilder_wellKnownType_producesNewMessage() { + DefaultMessageFactory messageFactory = DefaultMessageFactory.INSTANCE; + + Value.Builder valueBuilder = + (Value.Builder) messageFactory.newBuilder("google.protobuf.Value").get(); + + assertThat(valueBuilder.setStringValue("hello").build()) + .isEqualTo(Value.newBuilder().setStringValue("hello").build()); + } + + @Test + public void newBuilder_withDescriptor_producesNewMessageBuilder() { + CelDescriptorPool celDescriptorPool = + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + TestAllTypes.getDescriptor().getFile())); + DefaultMessageFactory messageFactory = DefaultMessageFactory.create(celDescriptorPool); + + TestAllTypes.Builder builder = + (TestAllTypes.Builder) + messageFactory.newBuilder("cel.expr.conformance.proto3.TestAllTypes").get(); + + assertThat(builder.setSingleInt64(5L).build()) + .isEqualTo(TestAllTypes.newBuilder().setSingleInt64(5L).build()); + } + + @Test + public void newBuilder_unknownMessage_returnsEmpty() { + DefaultMessageFactory messageFactory = DefaultMessageFactory.INSTANCE; + + assertThat(messageFactory.newBuilder("unknown_message")).isEmpty(); + } + + @Test + public void newBuilder_unequalDescriptorForSameMessage_returnsDynamicMessage() throws Exception { + String fdsContent = + Resources.toString(Resources.getResource(Ascii.toLowerCase("value.fds")), UTF_8); + FileDescriptorSet fds = TextFormat.parse(fdsContent, FileDescriptorSet.class); + ImmutableSet files = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds); + CelDescriptors celDescriptors = CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(files); + + DefaultMessageFactory messageFactory = + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors)); + + assertThat(messageFactory.newBuilder("google.api.expr.Value")).isPresent(); + assertThat(messageFactory.newBuilder("google.api.expr.Value").get()) + .isInstanceOf(DynamicMessage.Builder.class); + } + + @Test + public void getDescriptorPoolTest() { + CelDescriptorPool celDescriptorPool = + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + TestAllTypes.getDescriptor().getFile())); + DefaultMessageFactory messageFactory = DefaultMessageFactory.create(celDescriptorPool); + + assertThat(messageFactory.getDescriptorPool()).isEqualTo(celDescriptorPool); + } + + @Test + public void combinedMessageFactoryTest() { + CombinedMessageFactory messageFactory = + new ProtoMessageFactory.CombinedMessageFactory( + ImmutableList.of( + DefaultMessageFactory.INSTANCE, + (messageName) -> + messageName.equals("test") + ? Optional.of(TestAllTypes.newBuilder()) + : Optional.empty())); + + assertThat(messageFactory.newBuilder("test").get().build()) + .isEqualTo(TestAllTypes.getDefaultInstance()); + assertThat(messageFactory.newBuilder("bogus")).isEmpty(); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/DynamicProtoTest.java b/common/src/test/java/dev/cel/common/internal/DynamicProtoTest.java new file mode 100644 index 000000000..7be994391 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/DynamicProtoTest.java @@ -0,0 +1,274 @@ +// Copyright 2022 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.internal; + +import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.junit.Assert.assertThrows; + +import com.google.common.base.Ascii; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.io.Resources; +import com.google.protobuf.Any; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.Message; +import com.google.protobuf.Struct; +import com.google.protobuf.TextFormat; +import com.google.protobuf.Value; +import com.google.type.Expr; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import dev.cel.testing.testdata.MultiFile; +import dev.cel.testing.testdata.SingleFile; +import java.io.IOException; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class DynamicProtoTest { + + @Test + public void unpackLinkedMessageType_withTypeRegistry() throws Exception { + Expr expr = + Expr.newBuilder().setExpression("a < b").setTitle("Simple ordering predicate").build(); + Any packedExpr = Any.pack(expr); + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(Expr.getDescriptor().getFile()); + DynamicProto dynamicProto = + DynamicProto.create( + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors))); + + Message unpacked = dynamicProto.unpack(packedExpr); + + assertThat(expr).isEqualTo(unpacked); + assertThat(unpacked).isInstanceOf(Expr.class); + } + + @Test + public void unpackLinkedMessageType_withTypeRegistry_multiFileNested() throws Exception { + MultiFile.File file = + MultiFile.File.newBuilder() + .setName("my_file") + .setPath(MultiFile.File.Path.newBuilder().addFragments("dir")) + .build(); + Any packed = Any.pack(file); + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(MultiFile.getDescriptor().getFile()); + DynamicProto dynamicProto = + DynamicProto.create( + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors))); + + Message unpacked = dynamicProto.unpack(packed); + + assertThat(file).isEqualTo(unpacked); + assertThat(unpacked).isInstanceOf(MultiFile.File.class); + } + + @Test + public void unpackLinkedMessageType_withTypeRegistry_singleFileNested() throws Exception { + SingleFile.Path path = SingleFile.Path.newBuilder().addFragments("dir").build(); + Any packed = Any.pack(path); + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(SingleFile.getDescriptor().getFile()); + DynamicProto dynamicProto = + DynamicProto.create( + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors))); + + Message unpacked = dynamicProto.unpack(packed); + + assertThat(path).isEqualTo(unpacked); + assertThat(unpacked).isInstanceOf(SingleFile.Path.class); + } + + @Test + public void unpackLinkedMessageType_withTypeRegistryCached() throws Exception { + Expr expr = + Expr.newBuilder().setExpression("a < b").setTitle("Simple ordering predicate").build(); + Any packedExpr = Any.pack(expr); + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(Expr.getDescriptor().getFile()); + DynamicProto dynamicProto = + DynamicProto.create( + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors))); + + // Order is important here. + Message unpacked = dynamicProto.unpack(packedExpr); + assertThat(expr).isEqualTo(unpacked); + assertThat(unpacked).isInstanceOf(Expr.class); + Message unpacked2 = dynamicProto.unpack(packedExpr); + assertThat(expr).isEqualTo(unpacked2); + } + + @Test + public void unpackLinkedMessageType_removeDescriptorLocalLinkedType() throws Exception { + Struct struct = + Struct.newBuilder() + .putFields("hello", Value.newBuilder().setStringValue("world").build()) + .build(); + Any packedStruct = Any.pack(struct); + // This descriptor set will contain an overlapping reference to Struct type + FileDescriptorSet fds = TextFormat.parse(readFile("value.fds"), FileDescriptorSet.class); + ImmutableList.Builder fileDescriptorBuilder = ImmutableList.builder(); + fileDescriptorBuilder.add(Struct.getDescriptor().getFile()); + fileDescriptorBuilder.addAll(CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds)); + // Unpacking should still use the linked class. + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(fileDescriptorBuilder.build()); + DynamicProto dynamicProto = + DynamicProto.create( + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors))); + + Message unpacked = dynamicProto.unpack(packedStruct); + + assertThat(unpacked).isInstanceOf(Struct.class); + assertThat(struct).isEqualTo(unpacked); + } + + @Test + public void unpackDynamicMessageType_noDescriptor() throws Exception { + DynamicProto dynamicProto = DynamicProto.create(DefaultMessageFactory.INSTANCE); + Any.Builder anyValue = Any.newBuilder(); + TextFormat.merge(readFile("value.textproto"), anyValue); + assertThat(anyValue.getTypeUrl()).isEqualTo("type.googleapis.com/google.api.expr.Value"); + assertThrows(InvalidProtocolBufferException.class, () -> dynamicProto.unpack(anyValue.build())); + } + + @Test + public void unpackDynamicMessageType_badDescriptor() throws Exception { + DynamicProto dynamicProto = DynamicProto.create(DefaultMessageFactory.INSTANCE); + Any.Builder anyValue = Any.newBuilder(); + TextFormat.merge(readFile("value.textproto"), anyValue); + anyValue.setTypeUrl("google.api.expr.Value"); + assertThrows(InvalidProtocolBufferException.class, () -> dynamicProto.unpack(anyValue.build())); + } + + @Test + public void unpackDynamicMessageType() throws Exception { + FileDescriptorSet fds = TextFormat.parse(readFile("value.fds"), FileDescriptorSet.class); + ImmutableSet files = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds); + CelDescriptors celDescriptors = CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(files); + DynamicProto dynamicProto = + DynamicProto.create( + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors))); + Any.Builder anyValue = Any.newBuilder(); + TextFormat.merge(readFile("value.textproto"), anyValue); + assertThat(anyValue.getTypeUrl()).isEqualTo("type.googleapis.com/google.api.expr.Value"); + Message message = dynamicProto.unpack(anyValue.build()); + assertThat(message).isNotNull(); + + Descriptor valueDescriptor = message.getDescriptorForType(); + FieldDescriptor listValueField = valueDescriptor.findFieldByName("list_value"); + assertThat(listValueField).isNotNull(); + FieldDescriptor valuesField = listValueField.getMessageType().findFieldByName("values"); + assertThat(valuesField).isNotNull(); + FieldDescriptor stringValueField = valueDescriptor.findFieldByName("string_value"); + assertThat(stringValueField).isNotNull(); + FieldDescriptor int64ValueField = valueDescriptor.findFieldByName("int64_value"); + assertThat(int64ValueField).isNotNull(); + + Message listValue = (Message) message.getField(listValueField); + assertThat(listValue).isNotNull(); + + assertThat(((Message) listValue.getRepeatedField(valuesField, 0)).getField(stringValueField)) + .isEqualTo("Hello"); + assertThat(((Message) listValue.getRepeatedField(valuesField, 1)).getField(stringValueField)) + .isEqualTo("World"); + assertThat(((Message) listValue.getRepeatedField(valuesField, 2)).getField(int64ValueField)) + .isEqualTo(42L); + } + + @Test + public void unpackDynamicMessageType_cached() throws Exception { + FileDescriptorSet fds = TextFormat.parse(readFile("value.fds"), FileDescriptorSet.class); + ImmutableSet files = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds); + CelDescriptors celDescriptors = CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(files); + DynamicProto dynamicProto = + DynamicProto.create( + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors))); + Any.Builder anyValue = Any.newBuilder(); + TextFormat.merge(readFile("value.textproto"), anyValue); + assertThat(anyValue.getTypeUrl()).isEqualTo("type.googleapis.com/google.api.expr.Value"); + Message message = dynamicProto.unpack(anyValue.build()); + Message message2 = dynamicProto.unpack(anyValue.build()); + assertThat(message).isEqualTo(message2); + } + + @Test + public void maybeAdaptDynamicMessage() throws Exception { + DynamicProto dynamicProto = DynamicProto.create(DefaultMessageFactory.INSTANCE); + Struct struct = + Struct.newBuilder() + .putFields("hello", Value.newBuilder().setStringValue("world").build()) + .build(); + Any any = Any.pack(struct); + DynamicMessage anyDyn = + DynamicMessage.parseFrom( + Struct.getDescriptor(), + any.getValue(), + DefaultDescriptorPool.INSTANCE.getExtensionRegistry()); + Message adapted = dynamicProto.maybeAdaptDynamicMessage(anyDyn); + assertThat(adapted).isEqualTo(struct); + assertThat(adapted).isInstanceOf(Struct.class); + } + + @Test + public void maybeAdaptDynamicMessage_cached() throws Exception { + DynamicProto dynamicProto = DynamicProto.create(DefaultMessageFactory.INSTANCE); + Struct struct = + Struct.newBuilder() + .putFields("hello", Value.newBuilder().setStringValue("world").build()) + .build(); + Any any = Any.pack(struct); + DynamicMessage anyDyn = + DynamicMessage.parseFrom( + Struct.getDescriptor(), + any.getValue(), + DefaultDescriptorPool.INSTANCE.getExtensionRegistry()); + Message adapted = dynamicProto.maybeAdaptDynamicMessage(anyDyn); + Message adapted2 = dynamicProto.maybeAdaptDynamicMessage(anyDyn); + assertThat(adapted).isEqualTo(adapted2); + assertThat(adapted).isInstanceOf(Struct.class); + assertThat(adapted2).isInstanceOf(Struct.class); + } + + @Test + public void maybeAdaptDynamicMessage_notLinked() throws Exception { + FileDescriptorSet fds = TextFormat.parse(readFile("value.fds"), FileDescriptorSet.class); + ImmutableSet files = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds); + CelDescriptors celDescriptors = CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(files); + DynamicProto dynamicProto = + DynamicProto.create( + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors))); + Any any = TextFormat.parse(readFile("value.textproto"), Any.class); + Message unpacked = dynamicProto.unpack(any); + assertThat(unpacked).isInstanceOf(DynamicMessage.class); + assertThat(dynamicProto.maybeAdaptDynamicMessage((DynamicMessage) unpacked)) + .isSameInstanceAs(unpacked); + } + + private static String readFile(String path) throws IOException { + return Resources.toString(Resources.getResource(Ascii.toLowerCase(path)), UTF_8); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/ErrorsTest.java b/common/src/test/java/dev/cel/common/internal/ErrorsTest.java new file mode 100644 index 000000000..ad46f7737 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/ErrorsTest.java @@ -0,0 +1,68 @@ +// Copyright 2023 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.internal; + +import static com.google.common.truth.Truth.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class ErrorsTest { + + @Test + public void getLineOffsets() { + // There should be one offset for each newline and one for EOF. + Errors errors = new Errors("test", "\n\n\n\n"); + assertThat(errors.getLineOffsets().toArray()).isEqualTo(new int[] {1, 2, 3, 4, 5}); + } + + @Test + public void getLocationAt() { + Errors errors = new Errors("test", "hello\nworld"); + assertThat(errors.getLocationAt(0)).isEqualTo("test:1:1"); + assertThat(errors.getLocationAt(6)).isEqualTo("test:2:1"); + assertThat(errors.getLocationAt(11)).isEqualTo("test:2:6"); // EOF + assertThat(errors.getLocationAt(12)).isEqualTo("test:3:1"); // beyond EOF + } + + @Test + public void getLocationPosition() { + Errors errors = new Errors("test", "hello\nworld"); + assertThat(errors.getLocationPosition(1, 1)).isEqualTo(0); + assertThat(errors.getLocationPosition(2, 1)).isEqualTo(6); + assertThat(errors.getLocationPosition(2, 6)).isEqualTo(11); + assertThat(errors.getLocationPosition(3, 1)).isEqualTo(-1); + } + + @Test + public void getPositionLocation() { + Errors errors = new Errors("test", "hello\nworld"); + assertThat(errors.getPositionLocation(0)).isEqualTo(Errors.SourceLocation.of(1, 1)); + assertThat(errors.getPositionLocation(6)).isEqualTo(Errors.SourceLocation.of(2, 1)); + assertThat(errors.getPositionLocation(11)).isEqualTo(Errors.SourceLocation.of(2, 6)); + assertThat(errors.getPositionLocation(12)).isEqualTo(Errors.SourceLocation.of(3, 1)); + } + + @Test + public void getSnippet() { + Errors errors = new Errors("test", "hello\nworld\n"); + assertThat(errors.getSnippet(1)).hasValue("hello"); + assertThat(errors.getSnippet(2)).hasValue("world"); + assertThat(errors.getSnippet(3)).hasValue(""); + assertThat(errors.getSnippet(4)).isEmpty(); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/ProtoAdapterTest.java b/common/src/test/java/dev/cel/common/internal/ProtoAdapterTest.java new file mode 100644 index 000000000..91e0e22db --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/ProtoAdapterTest.java @@ -0,0 +1,305 @@ +// Copyright 2022 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.internal; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.Empty; +import com.google.protobuf.FieldMask; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.Message; +import com.google.protobuf.NullValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import com.google.type.Expr; +import dev.cel.common.CelOptions; +import dev.cel.common.values.CelByteString; +import java.time.Instant; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import org.junit.Test; +import org.junit.experimental.runners.Enclosed; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Enclosed.class) +public final class ProtoAdapterTest { + + private static final DynamicProto DYNAMIC_PROTO = + DynamicProto.create(DefaultMessageFactory.INSTANCE); + + @RunWith(Parameterized.class) + public static class BidirectionalConversionTest { + @Parameter(0) + public Object value; + + @Parameter(1) + public Message proto; + + @Parameters + public static List data() { + return Arrays.asList( + new Object[][] { + { + dev.cel.common.values.NullValue.NULL_VALUE, + Any.pack(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build()), + }, + {true, BoolValue.of(true)}, + {true, Any.pack(BoolValue.of(true))}, + {true, Value.newBuilder().setBoolValue(true).build()}, + { + CelByteString.copyFromUtf8("hello"), BytesValue.of(ByteString.copyFromUtf8("hello")), + }, + { + CelByteString.copyFromUtf8("hello"), + Any.pack(BytesValue.of(ByteString.copyFromUtf8("hello"))), + }, + {1.5D, DoubleValue.of(1.5D)}, + {1.5D, Any.pack(DoubleValue.of(1.5D))}, + {1.5D, Value.newBuilder().setNumberValue(1.5D).build()}, + { + java.time.Duration.ofSeconds(123), Duration.newBuilder().setSeconds(123).build(), + }, + { + java.time.Duration.ofSeconds(123), + Any.pack(Duration.newBuilder().setSeconds(123).build()), + }, + {1L, Int64Value.of(1L)}, + {1L, Any.pack(Int64Value.of(1L))}, + {UnsignedLong.valueOf(1L), UInt64Value.of(1L)}, + {"hello", StringValue.of("hello")}, + {"hello", Any.pack(StringValue.of("hello"))}, + {"hello", Value.newBuilder().setStringValue("hello").build()}, + { + Arrays.asList("hello", "world"), + Any.pack( + ListValue.newBuilder() + .addValues(Value.newBuilder().setStringValue("hello")) + .addValues(Value.newBuilder().setStringValue("world")) + .build()), + }, + { + ImmutableMap.of("hello", "world"), + Any.pack( + Struct.newBuilder() + .putFields("hello", Value.newBuilder().setStringValue("world").build()) + .build()), + }, + { + ImmutableMap.of( + "list_value", + ImmutableList.of(false, dev.cel.common.values.NullValue.NULL_VALUE)), + Struct.newBuilder() + .putFields( + "list_value", + Value.newBuilder() + .setListValue( + ListValue.newBuilder() + .addValues(Value.newBuilder().setBoolValue(false)) + .addValues(Value.newBuilder().setNullValue(NullValue.NULL_VALUE))) + .build()) + .build(), + }, + { + Instant.ofEpochSecond(123), Timestamp.newBuilder().setSeconds(123).build(), + }, + { + Instant.ofEpochSecond(123), Any.pack(Timestamp.newBuilder().setSeconds(123).build()), + }, + {UnsignedLong.valueOf(1L), UInt64Value.of(1L)}, + {UnsignedLong.valueOf(1L), Any.pack(UInt64Value.of(1L))}, + {Empty.getDefaultInstance(), Empty.getDefaultInstance()}, + { + FieldMask.newBuilder().addPaths("foo").build(), + FieldMask.newBuilder().addPaths("foo").build() + } + }); + } + + @Test + public void adaptValueToProto_bidirectionalConversion() { + DynamicProto dynamicProto = DynamicProto.create(DefaultMessageFactory.INSTANCE); + ProtoAdapter protoAdapter = new ProtoAdapter(dynamicProto, CelOptions.current().build()); + assertThat(protoAdapter.adaptValueToProto(value, proto.getDescriptorForType().getFullName())) + .isEqualTo(proto); + assertThat(protoAdapter.adaptProtoToValue(proto)).isEqualTo(value); + } + } + + @RunWith(JUnit4.class) + public static class BidirectionalConversionCustomMessageTest { + @Test + public void adaptAnyValue_hermeticTypes_bidirectionalConversion() { + Expr expr = Expr.newBuilder().setExpression("test").build(); + ProtoAdapter protoAdapter = + new ProtoAdapter( + DynamicProto.create( + (typeName) -> + typeName.equals(Expr.getDescriptor().getFullName()) + ? Optional.of(Expr.newBuilder()) + : Optional.empty()), + CelOptions.DEFAULT); + assertThat(protoAdapter.adaptValueToProto(expr, Any.getDescriptor().getFullName())) + .isEqualTo(Any.pack(expr)); + assertThat(protoAdapter.adaptProtoToValue(Any.pack(expr))).isEqualTo(expr); + } + } + + @RunWith(JUnit4.class) + public static class AsymmetricConversionTest { + + @Test + public void unpackAny_celNullValue() throws Exception { + ProtoAdapter protoAdapter = new ProtoAdapter(DYNAMIC_PROTO, CelOptions.DEFAULT); + Any any = + (Any) + protoAdapter.adaptValueToProto( + dev.cel.common.values.NullValue.NULL_VALUE, "google.protobuf.Any"); + Object unpacked = protoAdapter.adaptProtoToValue(any); + assertThat(unpacked).isEqualTo(dev.cel.common.values.NullValue.NULL_VALUE); + } + + @Test + public void adaptValueToProto_asymmetricFloatConversion() { + ProtoAdapter protoAdapter = new ProtoAdapter(DYNAMIC_PROTO, CelOptions.DEFAULT); + assertThat(protoAdapter.adaptValueToProto(1.5F, Any.getDescriptor().getFullName())) + .isEqualTo(Any.pack(FloatValue.of(1.5F))); + assertThat(protoAdapter.adaptProtoToValue(Any.pack(FloatValue.of(1.5F)))).isEqualTo(1.5D); + } + + @Test + public void adaptValueToProto_asymmetricDoubleFloatConversion() { + ProtoAdapter protoAdapter = new ProtoAdapter(DYNAMIC_PROTO, CelOptions.DEFAULT); + assertThat(protoAdapter.adaptValueToProto(1.5D, FloatValue.getDescriptor().getFullName())) + .isEqualTo(FloatValue.of(1.5F)); + assertThat(protoAdapter.adaptProtoToValue(FloatValue.of(1.5F))).isEqualTo(1.5D); + } + + @Test + public void adaptValueToProto_asymmetricFloatDoubleConversion() { + ProtoAdapter protoAdapter = new ProtoAdapter(DYNAMIC_PROTO, CelOptions.DEFAULT); + assertThat(protoAdapter.adaptValueToProto(1.5F, DoubleValue.getDescriptor().getFullName())) + .isEqualTo(DoubleValue.of(1.5D)); + } + + @Test + public void adaptValueToProto_asymmetricJsonConversion() { + ProtoAdapter protoAdapter = new ProtoAdapter(DYNAMIC_PROTO, CelOptions.DEFAULT); + assertThat( + protoAdapter.adaptValueToProto( + UnsignedLong.valueOf(1L), Value.getDescriptor().getFullName())) + .isEqualTo(Value.newBuilder().setNumberValue(1).build()); + assertThat( + protoAdapter.adaptValueToProto( + UnsignedLong.fromLongBits(-1L), Value.getDescriptor().getFullName())) + .isEqualTo(Value.newBuilder().setStringValue(Long.toUnsignedString(-1L)).build()); + assertThat(protoAdapter.adaptValueToProto(1L, Value.getDescriptor().getFullName())) + .isEqualTo(Value.newBuilder().setNumberValue(1).build()); + assertThat( + protoAdapter.adaptValueToProto(Long.MAX_VALUE, Value.getDescriptor().getFullName())) + .isEqualTo(Value.newBuilder().setStringValue(Long.toString(Long.MAX_VALUE)).build()); + assertThat( + protoAdapter.adaptValueToProto( + CelByteString.copyFromUtf8("foo"), Value.getDescriptor().getFullName())) + .isEqualTo(Value.newBuilder().setStringValue("Zm9v").build()); + } + + @Test + public void adaptValueToProto_unsupportedJsonConversion() { + ProtoAdapter protoAdapter = new ProtoAdapter(DYNAMIC_PROTO, CelOptions.DEFAULT); + + assertThrows( + ClassCastException.class, + () -> + protoAdapter.adaptValueToProto( + ImmutableMap.of(1, 1), Any.getDescriptor().getFullName())); + } + + @Test + public void adaptValueToProto_unsupportedJsonListConversion() { + ProtoAdapter protoAdapter = new ProtoAdapter(DYNAMIC_PROTO, CelOptions.DEFAULT); + + assertThrows( + ClassCastException.class, + () -> + protoAdapter.adaptValueToProto( + ImmutableMap.of(1, 1), ListValue.getDescriptor().getFullName())); + } + + @Test + public void adaptValueToProto_unsupportedConversion() { + ProtoAdapter protoAdapter = new ProtoAdapter(DYNAMIC_PROTO, CelOptions.DEFAULT); + + assertThrows( + IllegalStateException.class, + () -> protoAdapter.adaptValueToProto("Hello", Expr.getDescriptor().getFullName())); + } + + @Test + public void signedUint32Converter_bidiSignedLong() { + BidiConverter converter = ProtoAdapter.SIGNED_UINT32_CONVERTER; + assertThat(converter.forwardConverter().convert(12)).isEqualTo(12L); + assertThat(converter.forwardConverter().convert(Integer.MIN_VALUE)) + .isEqualTo(Integer.MAX_VALUE + 1L); + assertThat(converter.backwardConverter().convert(12L)).isEqualTo(12); + assertThat(converter.backwardConverter().convert(Integer.MAX_VALUE + 1L)) + .isEqualTo(Integer.MIN_VALUE); + } + + @Test + public void unsignedUint32Converter_bidiUnsignedLong() { + BidiConverter converter = ProtoAdapter.UNSIGNED_UINT32_CONVERTER; + assertThat(converter.forwardConverter().convert(12)).isEqualTo(UnsignedLong.valueOf(12L)); + assertThat(converter.forwardConverter().convert(Integer.MIN_VALUE)) + .isEqualTo(UnsignedLong.fromLongBits(Integer.MAX_VALUE + 1L)); + assertThat(converter.backwardConverter().convert(UnsignedLong.valueOf(12L))).isEqualTo(12); + assertThat( + converter + .backwardConverter() + .convert(UnsignedLong.fromLongBits(Integer.MAX_VALUE + 1L))) + .isEqualTo(Integer.MIN_VALUE); + } + + @Test + public void unsignedUint64Converter() { + BidiConverter converter = ProtoAdapter.UNSIGNED_UINT64_CONVERTER; + assertThat(converter.forwardConverter().convert(12L)).isEqualTo(UnsignedLong.valueOf(12L)); + assertThat(converter.forwardConverter().convert(Long.MIN_VALUE)) + .isEqualTo(UnsignedLong.fromLongBits(Long.MIN_VALUE)); + assertThat(converter.backwardConverter().convert(UnsignedLong.valueOf(12L))).isEqualTo(12L); + assertThat(converter.backwardConverter().convert(UnsignedLong.fromLongBits(Long.MIN_VALUE))) + .isEqualTo(Long.MIN_VALUE); + } + } +} diff --git a/common/src/test/java/dev/cel/common/internal/ProtoEqualityTest.java b/common/src/test/java/dev/cel/common/internal/ProtoEqualityTest.java new file mode 100644 index 000000000..d35947b9a --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/ProtoEqualityTest.java @@ -0,0 +1,279 @@ +// Copyright 2022 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.internal; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.protobuf.Any; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.Struct; +import com.google.protobuf.Value; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedEnum; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedMessage; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class ProtoEqualityTest { + + private DynamicProto dynamicProto; + private ProtoEquality protoEquality; + + @Before + public void setUp() { + this.dynamicProto = DynamicProto.create(DefaultMessageFactory.INSTANCE); + this.protoEquality = new ProtoEquality(dynamicProto); + } + + @Test + public void equalsFloatFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().setSingleDouble(1.3).build(), + TestAllTypes.newBuilder().setSingleDouble(1.3).build())) + .isTrue(); + } + + @Test + public void notEqualsFloatFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().setSingleDouble(4.88888).build(), + TestAllTypes.newBuilder().setSingleDouble(4.8).build())) + .isFalse(); + } + + @Test + public void notEqualsNaNFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().setSingleDouble(Double.NaN).build(), + TestAllTypes.newBuilder().setSingleDouble(Double.NaN).build())) + .isFalse(); + } + + @Test + public void equalsIntFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().setSingleInt32(2).build(), + TestAllTypes.newBuilder().setSingleInt32(2).build())) + .isTrue(); + } + + @Test + public void notEqualsIntFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().setSingleInt32(1).build(), + TestAllTypes.newBuilder().setSingleInt32(2).build())) + .isFalse(); + } + + @Test + public void equalsStringFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().setSingleString("hello").build(), + TestAllTypes.newBuilder().setSingleString("hello").build())) + .isTrue(); + } + + @Test + public void notEqualsStringFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().setSingleString("hello").build(), + TestAllTypes.newBuilder().setSingleString("world").build())) + .isFalse(); + } + + @Test + public void equalsMessage_sameInstance() { + assertThat( + protoEquality.equals( + TestAllTypes.getDefaultInstance(), TestAllTypes.getDefaultInstance())) + .isTrue(); + } + + @Test + public void notEqualsMessage_differentTypes() { + assertThat( + protoEquality.equals( + TestAllTypes.getDefaultInstance(), NestedMessage.getDefaultInstance())) + .isFalse(); + } + + @Test + public void equalsMessageFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder() + .setSingleNestedMessage(NestedMessage.newBuilder().setBb(42)) + .build(), + TestAllTypes.newBuilder() + .setSingleNestedMessage(NestedMessage.newBuilder().setBb(42)) + .build())) + .isTrue(); + } + + @Test + public void notEqualsMessageFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder() + .setSingleNestedMessage(NestedMessage.getDefaultInstance()) + .build(), + TestAllTypes.newBuilder() + .setSingleNestedMessage(NestedMessage.newBuilder().setBb(42)) + .build())) + .isFalse(); + } + + @Test + public void notEqualsMessageFields_differentFieldSet() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().setSingleInt32(1).build(), + TestAllTypes.newBuilder().setSingleInt64(2L).build())) + .isFalse(); + } + + @Test + public void equalsRepeatedFields() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder() + .addRepeatedNestedEnum(NestedEnum.FOO) + .addRepeatedNestedMessage(NestedMessage.newBuilder().setBb(42)) + .addRepeatedInt32(1) + .addRepeatedInt32(2) + .addRepeatedInt32(3) + .putMapStringString("key", "value") + .build(), + TestAllTypes.newBuilder() + .addRepeatedNestedMessage(NestedMessage.newBuilder().setBb(42)) + .addRepeatedNestedEnum(NestedEnum.FOO) + .addRepeatedInt32(1) + .addRepeatedInt32(2) + .addRepeatedInt32(3) + .putMapStringString("key", "value") + .build())) + .isTrue(); + } + + @Test + public void notEqualsRepeatedFields_differentLengths() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().addRepeatedInt32(1).addRepeatedInt32(2).build(), + TestAllTypes.newBuilder() + .addRepeatedInt32(1) + .addRepeatedInt32(2) + .addRepeatedInt32(3) + .build())) + .isFalse(); + } + + @Test + public void notEqualsRepeatedFields_differentValues() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().addRepeatedInt32(1).addRepeatedInt32(2).build(), + TestAllTypes.newBuilder().addRepeatedInt32(1).addRepeatedInt32(3).build())) + .isFalse(); + } + + @Test + public void notEqualsRepeatedFields_differentMapSizes() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder() + .putMapStringString("hello", "world") + .putMapStringString("goodbye", "world") + .build(), + TestAllTypes.newBuilder().putMapStringString("goodbye", "world").build())) + .isFalse(); + } + + @Test + public void notEqualsRepeatedFields_differentMapKeys() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().putMapStringString("hello", "world").build(), + TestAllTypes.newBuilder().putMapStringString("goodbye", "world").build())) + .isFalse(); + } + + @Test + public void notEqualsRepeatedFields_differentMapValues() { + assertThat( + protoEquality.equals( + TestAllTypes.newBuilder().putMapStringString("hello", "world").build(), + TestAllTypes.newBuilder().putMapStringString("hello", "universe").build())) + .isFalse(); + } + + @Test + public void equalsMessageAnyFields() { + Struct struct = + Struct.newBuilder() + .putFields("first", Value.newBuilder().setStringValue("entry1").build()) + .putFields("second", Value.newBuilder().setStringValue("entry2").build()) + .build(); + Any packedStruct = Any.pack(struct); + Any packedStruct2 = Any.pack(struct); + assertThat(protoEquality.equals(packedStruct, packedStruct2)).isTrue(); + } + + @Test + public void equalsMessageUnknownAnyFields() { + Struct struct = + Struct.newBuilder() + .putFields("first", Value.newBuilder().setStringValue("entry1").build()) + .putFields("second", Value.newBuilder().setStringValue("entry2").build()) + .build(); + Any packedStruct = Any.pack(struct); + Any packedStruct2 = Any.pack(struct); + packedStruct = packedStruct.toBuilder().setTypeUrl("type.googleapis.com/Unknown").build(); + assertThat(protoEquality.equals(packedStruct, packedStruct2)).isTrue(); + } + + @Test + public void equalsMessageDynamicAnyFields() throws InvalidProtocolBufferException { + Struct struct = + Struct.newBuilder() + .putFields("first", Value.newBuilder().setStringValue("entry1").build()) + .putFields("second", Value.newBuilder().setStringValue("entry2").build()) + .build(); + Any packedStruct = Any.pack(struct); + Any doublePackedStruct = Any.pack(packedStruct); + DynamicMessage dynAny = + DynamicMessage.parseFrom( + Any.getDescriptor(), + doublePackedStruct.getValue(), + DefaultDescriptorPool.INSTANCE.getExtensionRegistry()); + DynamicMessage dynAny2 = + DynamicMessage.parseFrom( + Any.getDescriptor(), + doublePackedStruct.getValue(), + DefaultDescriptorPool.INSTANCE.getExtensionRegistry()); + assertThat(protoEquality.equals(dynAny, dynAny2)).isTrue(); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/ProtoTimeUtilsTest.java b/common/src/test/java/dev/cel/common/internal/ProtoTimeUtilsTest.java new file mode 100644 index 000000000..31ee9a9eb --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/ProtoTimeUtilsTest.java @@ -0,0 +1,72 @@ +// Copyright 2025 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.internal; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.internal.ProtoTimeUtils.DURATION_SECONDS_MAX; +import static dev.cel.common.internal.ProtoTimeUtils.DURATION_SECONDS_MIN; + +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import java.time.Instant; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class ProtoTimeUtilsTest { + + @Test + public void toJavaInstant_overRfc3339Range() { + Timestamp ts = + Timestamp.newBuilder().setSeconds(ProtoTimeUtils.TIMESTAMP_SECONDS_MAX + 1).build(); + + Instant instant = ProtoTimeUtils.toJavaInstant(ts); + + assertThat(instant).isEqualTo(Instant.ofEpochSecond(ProtoTimeUtils.TIMESTAMP_SECONDS_MAX + 1)); + } + + @Test + public void toJavaInstant_underRfc3339Range() { + Timestamp ts = + Timestamp.newBuilder().setSeconds(ProtoTimeUtils.TIMESTAMP_SECONDS_MIN - 1).build(); + + Instant instant = ProtoTimeUtils.toJavaInstant(ts); + + assertThat(instant).isEqualTo(Instant.ofEpochSecond(ProtoTimeUtils.TIMESTAMP_SECONDS_MIN - 1)); + } + + @Test + public void toJavaDuration_overRfc3339Range() { + Duration d = Duration.newBuilder() + .setSeconds(DURATION_SECONDS_MAX + 1) + .build(); + + java.time.Duration duration = ProtoTimeUtils.toJavaDuration(d); + + assertThat(duration).isEqualTo(java.time.Duration.ofSeconds(DURATION_SECONDS_MAX + 1)); + } + + @Test + public void toJavaDuration_underRfc3339Range() { + Duration d = Duration.newBuilder() + .setSeconds(DURATION_SECONDS_MIN - 1) + .build(); + + java.time.Duration duration = ProtoTimeUtils.toJavaDuration(d); + + assertThat(duration).isEqualTo(java.time.Duration.ofSeconds(DURATION_SECONDS_MIN - 1)); + } +} diff --git a/common/src/test/java/dev/cel/common/internal/WellKnownProtoTest.java b/common/src/test/java/dev/cel/common/internal/WellKnownProtoTest.java new file mode 100644 index 000000000..c12411d95 --- /dev/null +++ b/common/src/test/java/dev/cel/common/internal/WellKnownProtoTest.java @@ -0,0 +1,146 @@ +// Copyright 2025 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.internal; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.Empty; +import com.google.protobuf.FieldMask; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import java.util.List; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class WellKnownProtoTest { + + @Test + @TestParameters("{typeName: 'google.protobuf.FloatValue'}") + @TestParameters("{typeName: 'google.protobuf.Int32Value'}") + @TestParameters("{typeName: 'google.protobuf.Int64Value'}") + @TestParameters("{typeName: 'google.protobuf.StringValue'}") + @TestParameters("{typeName: 'google.protobuf.BoolValue'}") + @TestParameters("{typeName: 'google.protobuf.BytesValue'}") + @TestParameters("{typeName: 'google.protobuf.DoubleValue'}") + @TestParameters("{typeName: 'google.protobuf.UInt32Value'}") + @TestParameters("{typeName: 'google.protobuf.UInt64Value'}") + @TestParameters("{typeName: 'google.protobuf.Empty'}") + @TestParameters("{typeName: 'google.protobuf.FieldMask'}") + public void isWrapperType_withTypeName_true(String typeName) { + assertThat(WellKnownProto.isWrapperType(typeName)).isTrue(); + } + + @Test + @TestParameters("{typeName: 'not.wellknown.type'}") + @TestParameters("{typeName: 'google.protobuf.Any'}") + @TestParameters("{typeName: 'google.protobuf.Duration'}") + @TestParameters("{typeName: 'google.protobuf.ListValue'}") + @TestParameters("{typeName: 'google.protobuf.Struct'}") + @TestParameters("{typeName: 'google.protobuf.Value'}") + @TestParameters("{typeName: 'google.protobuf.Timestamp'}") + public void isWrapperType_withTypeName_false(String typeName) { + assertThat(WellKnownProto.isWrapperType(typeName)).isFalse(); + } + + @Test + public void getByClass_success() { + assertThat(WellKnownProto.getByClass(FloatValue.class)).hasValue(WellKnownProto.FLOAT_VALUE); + } + + @Test + public void getByClass_unknownClass_returnsEmpty() { + assertThat(WellKnownProto.getByClass(List.class)).isEmpty(); + } + + @Test + public void getByPathName_singular() { + assertThat(WellKnownProto.getByPathName(Any.getDescriptor().getFile().getName())) + .containsExactly(WellKnownProto.ANY_VALUE); + assertThat(WellKnownProto.getByPathName(Duration.getDescriptor().getFile().getName())) + .containsExactly(WellKnownProto.DURATION); + assertThat(WellKnownProto.getByPathName(Timestamp.getDescriptor().getFile().getName())) + .containsExactly(WellKnownProto.TIMESTAMP); + assertThat(WellKnownProto.getByPathName(Empty.getDescriptor().getFile().getName())) + .containsExactly(WellKnownProto.EMPTY); + assertThat(WellKnownProto.getByPathName(FieldMask.getDescriptor().getFile().getName())) + .containsExactly(WellKnownProto.FIELD_MASK); + } + + @Test + public void getByPathName_json() { + ImmutableList expectedWellKnownProtos = + ImmutableList.of( + WellKnownProto.JSON_STRUCT_VALUE, + WellKnownProto.JSON_VALUE, + WellKnownProto.JSON_LIST_VALUE); + assertThat(WellKnownProto.getByPathName(Struct.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(Value.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(ListValue.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + } + + @Test + public void getByPathName_wrappers() { + ImmutableList expectedWellKnownProtos = + ImmutableList.of( + WellKnownProto.FLOAT_VALUE, + WellKnownProto.DOUBLE_VALUE, + WellKnownProto.INT32_VALUE, + WellKnownProto.INT64_VALUE, + WellKnownProto.UINT32_VALUE, + WellKnownProto.UINT64_VALUE, + WellKnownProto.BOOL_VALUE, + WellKnownProto.STRING_VALUE, + WellKnownProto.BYTES_VALUE); + + assertThat(WellKnownProto.getByPathName(FloatValue.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(DoubleValue.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(Int32Value.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(Int64Value.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(UInt32Value.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(UInt64Value.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(BoolValue.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(StringValue.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + assertThat(WellKnownProto.getByPathName(BytesValue.getDescriptor().getFile().getName())) + .containsExactlyElementsIn(expectedWellKnownProtos); + } +} diff --git a/common/src/test/java/dev/cel/common/navigation/BUILD.bazel b/common/src/test/java/dev/cel/common/navigation/BUILD.bazel new file mode 100644 index 000000000..f8b2b988b --- /dev/null +++ b/common/src/test/java/dev/cel/common/navigation/BUILD.bazel @@ -0,0 +1,43 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//common:cel_ast", + "//common:compiler_common", + "//common:container", + "//common:mutable_ast", + "//common:operator", + "//common:options", + "//common/ast", + "//common/ast:mutable_expr", + "//common/navigation", + "//common/navigation:common", + "//common/navigation:mutable_navigation", + "//common/types", + "//compiler", + "//compiler:compiler_builder", + "//parser:macro", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/common/src/test/java/dev/cel/common/navigation/CelNavigableAstTest.java b/common/src/test/java/dev/cel/common/navigation/CelNavigableAstTest.java new file mode 100644 index 000000000..6fa4cd203 --- /dev/null +++ b/common/src/test/java/dev/cel/common/navigation/CelNavigableAstTest.java @@ -0,0 +1,44 @@ +// Copyright 2023 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.navigation; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelNavigableAstTest { + + @Test + public void construct_success() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("'Hello World'").getAst(); + + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + assertThat(navigableAst.getAst()).isEqualTo(ast); + assertThat(navigableAst.getRoot().expr()) + .isEqualTo(CelExpr.ofConstant(1, CelConstant.ofValue("Hello World"))); + assertThat(navigableAst.getRoot().parent()).isEmpty(); + assertThat(navigableAst.getRoot().depth()).isEqualTo(0); + } +} diff --git a/common/src/test/java/dev/cel/common/navigation/CelNavigableExprTest.java b/common/src/test/java/dev/cel/common/navigation/CelNavigableExprTest.java new file mode 100644 index 000000000..69b244708 --- /dev/null +++ b/common/src/test/java/dev/cel/common/navigation/CelNavigableExprTest.java @@ -0,0 +1,54 @@ +// Copyright 2023 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.navigation; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelNavigableExprTest { + + @Test + public void construct_withoutParent_success() { + CelExpr constExpr = CelExpr.ofConstant(1, CelConstant.ofValue("test")); + CelNavigableExpr navigableExpr = + CelNavigableExpr.builder().setExpr(constExpr).setDepth(2).build(); + + assertThat(navigableExpr.expr()).isEqualTo(constExpr); + assertThat(navigableExpr.depth()).isEqualTo(2); + assertThat(navigableExpr.parent()).isEmpty(); + } + + @Test + public void construct_withParent_success() { + CelExpr constExpr = CelExpr.ofConstant(1, CelConstant.ofValue("test")); + CelExpr identExpr = CelExpr.ofIdent(2, "a"); + CelNavigableExpr parentExpr = CelNavigableExpr.builder().setExpr(identExpr).setDepth(1).build(); + CelNavigableExpr navigableExpr = + CelNavigableExpr.builder().setExpr(constExpr).setDepth(2).setParent(parentExpr).build(); + + assertThat(parentExpr.expr()).isEqualTo(identExpr); + assertThat(parentExpr.depth()).isEqualTo(1); + assertThat(parentExpr.parent()).isEmpty(); + assertThat(navigableExpr.expr()).isEqualTo(constExpr); + assertThat(navigableExpr.depth()).isEqualTo(2); + assertThat(navigableExpr.parent()).hasValue(parentExpr); + } +} diff --git a/common/src/test/java/dev/cel/common/navigation/CelNavigableExprVisitorTest.java b/common/src/test/java/dev/cel/common/navigation/CelNavigableExprVisitorTest.java new file mode 100644 index 000000000..15c6ac620 --- /dev/null +++ b/common/src/test/java/dev/cel/common/navigation/CelNavigableExprVisitorTest.java @@ -0,0 +1,1362 @@ +// Copyright 2023 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.navigation; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static dev.cel.common.CelOverloadDecl.newMemberOverload; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.UnsignedLong; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.parser.CelStandardMacro; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelNavigableExprVisitorTest { + + @Test + @TestParameters("{maxDepth: -1, expectedNodeCount: 0}") + @TestParameters("{maxDepth: 0, expectedNodeCount: 1}") + @TestParameters("{maxDepth: 1, expectedNodeCount: 3}") + @TestParameters("{maxDepth: 2, expectedNodeCount: 5}") + @TestParameters("{maxDepth: 3, expectedNodeCount: 5}") + public void collectWithMaxDepth_expectedNodeCountReturned(int maxDepth, int expectedNodeCount) + throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 2 + // 1 a + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + CelNavigableExprVisitor.collect(navigableAst.getRoot(), maxDepth, TraversalOrder.PRE_ORDER) + .collect(toImmutableList()); + + assertThat(allNodes).hasSize(expectedNodeCount); + } + + @Test + public void add_allNodes_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 2 + // 1 a + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst.getRoot().allNodes().map(CelNavigableExpr::expr).collect(toImmutableList()); + + CelExpr childAddCall = + CelExpr.ofCall( + 2, + Optional.empty(), + Operator.ADD.getFunction(), + ImmutableList.of( + CelExpr.ofConstant(1, CelConstant.ofValue(1)), // 1 + a + CelExpr.ofIdent(3, "a"))); + CelExpr rootAddCall = + CelExpr.ofCall( + 4, + Optional.empty(), + Operator.ADD.getFunction(), + ImmutableList.of(childAddCall, CelExpr.ofConstant(5, CelConstant.ofValue(2)))); + assertThat(allNodes) + .containsExactly( + rootAddCall, + childAddCall, + CelExpr.ofConstant(1, CelConstant.ofValue(1)), + CelExpr.ofIdent(3, "a"), + CelExpr.ofConstant(5, CelConstant.ofValue(2))); + } + + @Test + public void add_preOrder_heightSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 2 + // 1 a + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodeHeights = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + assertThat(allNodeHeights).containsExactly(2, 1, 0, 0, 0).inOrder(); // +, +, 1, a, 2 + } + + @Test + public void add_preOrder_maxIdsSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape (brackets are IDs): + // + [4] + // + [2] 2 [5] + // 1 [1] a [3] + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodeMaxIds = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + assertThat(allNodeMaxIds).containsExactly(5L, 3L, 1L, 3L, 5L).inOrder(); // +, +, 1, a, 2 + } + + @Test + public void add_postOrder_heightSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 2 + // 1 a + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodeHeights = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + assertThat(allNodeHeights).containsExactly(0, 0, 1, 0, 2).inOrder(); // 1, a, +, 2, + + } + + @Test + public void add_postOrder_maxIdsSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape (brackets are IDs): + // + [4] + // + [2] 2 [5] + // 1 [1] a [3] + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodeMaxIds = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + assertThat(allNodeMaxIds).containsExactly(1L, 3L, 3L, 5L, 5L).inOrder(); // 1, a, +, 2, + + } + + @Test + public void add_fromLeaf_heightSetForParents() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 3 + // + 2 + // a 1 + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2 + 3").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList.Builder heights = ImmutableList.builder(); + CelNavigableExpr navigableExpr = + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.expr().identOrDefault().name().equals("a")) + .findAny() + .get(); + heights.add(navigableExpr.height()); + while (navigableExpr.parent().isPresent()) { + navigableExpr = navigableExpr.parent().get(); + heights.add(navigableExpr.height()); + } + + assertThat(heights.build()).containsExactly(3, 2, 1, 0); + } + + @Test + public void add_fromLeaf_maxIdsSetForParents() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 3 + // + 2 + // a 1 + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2 + 3").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList.Builder heights = ImmutableList.builder(); + CelNavigableExpr navigableExpr = + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.expr().identOrDefault().name().equals("a")) + .findAny() + .get(); + heights.add(navigableExpr.maxId()); + while (navigableExpr.parent().isPresent()) { + navigableExpr = navigableExpr.parent().get(); + heights.add(navigableExpr.maxId()); + } + + assertThat(heights.build()).containsExactly(3L, 3L, 5L, 7L).inOrder(); + } + + @Test + public void add_children_heightSet(@TestParameter TraversalOrder traversalOrder) + throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 3 + // + 2 + // a 1 + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2 + 3").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodeHeights = + navigableAst + .getRoot() + .children(traversalOrder) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + assertThat(allNodeHeights).containsExactly(2, 0).inOrder(); // + (2), 2 (0) regardless of order + } + + @Test + public void add_children_maxIdsSet(@TestParameter TraversalOrder traversalOrder) + throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 3 + // + 2 + // a 1 + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2 + 3").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodeHeights = + navigableAst + .getRoot() + .children(traversalOrder) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + assertThat(allNodeHeights) + .containsExactly(5L, 7L) + .inOrder(); // + (5), 3 (7) regardless of order + } + + @Test + public void add_filterConstants_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 2 + // 1 a + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allConstants = + navigableAst + .getRoot() + .allNodes() + .filter(x -> x.getKind().equals(Kind.CONSTANT)) + .collect(toImmutableList()); + + assertThat(allConstants).hasSize(2); + assertThat(allConstants.get(0).expr()).isEqualTo(CelExpr.ofConstant(1, CelConstant.ofValue(1))); + assertThat(allConstants.get(1).expr()).isEqualTo(CelExpr.ofConstant(5, CelConstant.ofValue(2))); + } + + @Test + public void add_filterConstants_parentsPopulated() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 2 + // 1 a + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allConstants = + navigableAst + .getRoot() + .allNodes() + .filter(x -> x.getKind().equals(Kind.CONSTANT)) + .collect(toImmutableList()); + + assertThat(allConstants).hasSize(2); + CelExpr childAddCall = allConstants.get(0).parent().get().expr(); // 1 + a + CelExpr rootAddCall = allConstants.get(1).parent().get().expr(); // childAddCall + 2 + assertThat(childAddCall) + .isEqualTo( + CelExpr.ofCall( + 2, + Optional.empty(), + Operator.ADD.getFunction(), + ImmutableList.of( + CelExpr.ofConstant(1, CelConstant.ofValue(1)), CelExpr.ofIdent(3, "a")))); + assertThat(rootAddCall) + .isEqualTo( + CelExpr.ofCall( + 4, + Optional.empty(), + Operator.ADD.getFunction(), + ImmutableList.of(childAddCall, CelExpr.ofConstant(5, CelConstant.ofValue(2))))); + } + + @Test + public void add_filterConstants_singleChildReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 2 + // 1 a + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allConstants = + navigableAst + .getRoot() + .children() + .filter(x -> x.getKind().equals(Kind.CONSTANT)) + .collect(toImmutableList()); + + assertThat(allConstants).hasSize(1); + assertThat(allConstants.get(0).expr()).isEqualTo(CelExpr.ofConstant(5, CelConstant.ofValue(2))); + } + + @Test + public void add_filterConstants_parentOfChildPopulated() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 2 + // 1 a + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allConstants = + navigableAst + .getRoot() + .children() + .filter(x -> x.getKind().equals(Kind.CONSTANT)) + .collect(toImmutableList()); + + assertThat(allConstants).hasSize(1); + CelExpr parentExpr = allConstants.get(0).parent().get().expr(); + assertThat(parentExpr.exprKind().getKind()).isEqualTo(Kind.CALL); + assertThat(parentExpr.call().function()).isEqualTo(Operator.ADD.getFunction()); + assertThat(parentExpr.call().args().get(0).exprKind().getKind()).isEqualTo(Kind.CALL); + assertThat(parentExpr.call().args().get(1).constant()).isEqualTo(CelConstant.ofValue(2)); + } + + @Test + public void add_childrenOfMiddleBranch_success() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + // Tree shape: + // + + // + 2 + // 1 a + CelAbstractSyntaxTree ast = compiler.compile("1 + a + 2").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + CelNavigableExpr ident = + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.IDENT)) // Find "a" + .findAny() + .get(); + + ImmutableList children = + ident.parent().get().children().collect(toImmutableList()); + + // Assert that the children of add call in the middle branch are const(1) and ident("a") + assertThat(children).hasSize(2); + assertThat(children.get(0).expr()).isEqualTo(CelExpr.ofConstant(1, CelConstant.ofValue(1))); + assertThat(children.get(1).expr()).isEqualTo(ident.expr()); + } + + @Test + public void stringFormatCall_filterList_success() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "format", + newMemberOverload( + "string_format_overload", + SimpleType.STRING, + ImmutableList.of(SimpleType.STRING, ListType.create(SimpleType.DYN))))) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("'%f %s'.format([3.14, 'test'])").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allConstants = + navigableAst + .getRoot() + .allNodes() + .filter(x -> x.getKind().equals(Kind.LIST)) + .collect(toImmutableList()); + + assertThat(allConstants).hasSize(1); + CelNavigableExpr listExpr = allConstants.get(0); + assertThat(listExpr.getKind()).isEqualTo(Kind.LIST); + assertThat(listExpr.parent()).isPresent(); + CelNavigableExpr stringFormatExpr = listExpr.parent().get(); + assertThat(stringFormatExpr.getKind()).isEqualTo(Kind.CALL); + CelCall call = listExpr.parent().get().expr().exprKind().call(); + assertThat(call.function()).isEqualTo("format"); + assertThat(call.target().get().exprKind().constant().stringValue()).isEqualTo("%f %s"); + } + + @Test + public void stringFormatCall_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "format", + newMemberOverload( + "string_format_overload", + SimpleType.STRING, + ImmutableList.of(SimpleType.STRING, ListType.create(SimpleType.DYN))))) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("'%f %s'.format([3.14, 'test'])").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList targetExprs = + navigableAst.getRoot().allNodes().collect(toImmutableList()); + + assertThat(targetExprs).hasSize(5); + } + + @Test + public void message_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("msg.single_int64").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst.getRoot().allNodes().map(CelNavigableExpr::expr).collect(toImmutableList()); + + CelExpr operand = CelExpr.ofIdent(1, "msg"); + assertThat(allNodes) + .containsExactly(operand, CelExpr.ofSelect(2, operand, "single_int64", false)); + } + + @Test + public void nestedMessage_filterSelect_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("msg.standalone_message.bb").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allSelects = + navigableAst + .getRoot() + .allNodes() + .filter(x -> x.getKind().equals(Kind.SELECT)) + .map(CelNavigableExpr::expr) + .collect(toImmutableList()); + + CelExpr innerSelect = + CelExpr.ofSelect( + 2, CelExpr.ofIdent(1, "msg"), "standalone_message", false); // msg.standalone + CelExpr outerSelect = CelExpr.ofSelect(3, innerSelect, "bb", false); // innerSelect.bb + assertThat(allSelects).containsExactly(innerSelect, outerSelect); + } + + @Test + public void nestedMessage_filterSelect_singleChildReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = + compiler + .compile( + "1 + msg.standalone_message.bb") // "1 +" added to make something other than select + // the root. + .getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allSelects = + navigableAst + .getRoot() + .children() + .filter(x -> x.getKind().equals(Kind.SELECT)) + .collect(toImmutableList()); + + assertThat(allSelects).hasSize(1); + CelExpr innerSelect = + CelExpr.ofSelect( + 4, CelExpr.ofIdent(3, "msg"), "standalone_message", false); // msg.standalone + CelExpr outerSelect = CelExpr.ofSelect(5, innerSelect, "bb", false); // innerSelect.bb + assertThat(allSelects.get(0).expr()).isEqualTo(outerSelect); + } + + @Test + public void presenceTest_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("has(msg.standalone_message)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst.getRoot().allNodes().map(CelNavigableExpr::expr).collect(toImmutableList()); + + assertThat(allNodes).hasSize(2); + assertThat(allNodes) + .containsExactly( + CelExpr.ofIdent(2, "msg"), + CelExpr.ofSelect(4, CelExpr.ofIdent(2, "msg"), "standalone_message", true)); + } + + @Test + public void messageConstruction_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("TestAllTypes{single_int64: 1}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst.getRoot().allNodes().map(CelNavigableExpr::expr).collect(toImmutableList()); + + CelExpr constExpr = CelExpr.ofConstant(3, CelConstant.ofValue(1)); + assertThat(allNodes) + .containsExactly( + constExpr, + CelExpr.ofStruct( + 1, + "cel.expr.conformance.proto3.TestAllTypes", + ImmutableList.of(CelExpr.ofStructEntry(2, "single_int64", constExpr, false)))); + } + + @Test + public void messageConstruction_filterStruct_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("TestAllTypes{single_int64: 1}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes() + .filter(x -> x.getKind().equals(Kind.STRUCT)) + .collect(toImmutableList()); + + assertThat(allNodes).hasSize(1); + assertThat(allNodes.get(0).expr()) + .isEqualTo( + CelExpr.ofStruct( + 1, + "cel.expr.conformance.proto3.TestAllTypes", + ImmutableList.of( + CelExpr.ofStructEntry( + 2, "single_int64", CelExpr.ofConstant(3, CelConstant.ofValue(1)), false)))); + } + + @Test + public void messageConstruction_preOrder_heightSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("TestAllTypes{single_int64: 1}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(1, 0).inOrder(); + } + + @Test + public void messageConstruction_postOrder_heightSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("TestAllTypes{single_int64: 1}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(0, 1).inOrder(); + } + + @Test + public void messageConstruction_maxIdsSet(@TestParameter TraversalOrder traversalOrder) + throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("TestAllTypes{single_int64: 1}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(traversalOrder) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(3L, 3L).inOrder(); + } + + @Test + public void mapConstruction_allNodesReturned() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = compiler.compile("{'key': 2}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst.getRoot().allNodes().map(CelNavigableExpr::expr).collect(toImmutableList()); + + assertThat(allNodes).hasSize(3); + CelExpr mapKeyExpr = CelExpr.ofConstant(3, CelConstant.ofValue("key")); + CelExpr mapValueExpr = CelExpr.ofConstant(4, CelConstant.ofValue(2)); + assertThat(allNodes) + .containsExactly( + mapKeyExpr, + mapValueExpr, + CelExpr.ofMap( + 1, ImmutableList.of(CelExpr.ofMapEntry(2, mapKeyExpr, mapValueExpr, false)))); + } + + @Test + public void mapConstruction_filterMap_allNodesReturned() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = compiler.compile("{'key': 2}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes() + .filter(x -> x.getKind().equals(Kind.MAP)) + .collect(toImmutableList()); + + assertThat(allNodes).hasSize(1); + CelExpr mapKeyExpr = CelExpr.ofConstant(3, CelConstant.ofValue("key")); + CelExpr mapValueExpr = CelExpr.ofConstant(4, CelConstant.ofValue(2)); + assertThat(allNodes.get(0).expr()) + .isEqualTo( + CelExpr.ofMap( + 1, ImmutableList.of(CelExpr.ofMapEntry(2, mapKeyExpr, mapValueExpr, false)))); + } + + @Test + public void mapConstruction_preOrder_heightSet() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = compiler.compile("{'key': 2}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(1, 0, 0).inOrder(); + } + + @Test + public void mapConstruction_postOrder_heightSet() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = compiler.compile("{'key': 2}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(0, 0, 1).inOrder(); + } + + @Test + public void mapConstruction_preOrder_maxIdsSet() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = compiler.compile("{'key': 2}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(4L, 3L, 4L).inOrder(); + } + + @Test + public void mapConstruction_postOrder_maxIdsSet() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = compiler.compile("{'key': 2}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(3L, 4L, 4L).inOrder(); + } + + @Test + public void emptyMapConstruction_allNodesReturned() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelAbstractSyntaxTree ast = compiler.compile("{}").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst.getRoot().allNodes().collect(toImmutableList()); + + assertThat(allNodes).hasSize(1); + assertThat(allNodes.get(0).expr()).isEqualTo(CelExpr.ofMap(1, ImmutableList.of())); + } + + @Test + public void comprehension_preOrder_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableHiddenAccumulatorVar(true).build()) + .setStandardMacros(CelStandardMacro.EXISTS) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[true].exists(i, i)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::expr) + .collect(toImmutableList()); + + CelExpr iterRangeConstExpr = CelExpr.ofConstant(2, CelConstant.ofValue(true)); + CelExpr iterRange = CelExpr.ofList(1, ImmutableList.of(iterRangeConstExpr), ImmutableList.of()); + CelExpr accuInit = CelExpr.ofConstant(6, CelConstant.ofValue(false)); + CelExpr loopConditionIdentExpr = CelExpr.ofIdent(7, "@result"); + CelExpr loopConditionCallExpr = + CelExpr.ofCall( + 8, + Optional.empty(), + Operator.LOGICAL_NOT.getFunction(), + ImmutableList.of(loopConditionIdentExpr)); + CelExpr loopCondition = + CelExpr.ofCall( + 9, + Optional.empty(), + Operator.NOT_STRICTLY_FALSE.getFunction(), + ImmutableList.of(loopConditionCallExpr)); + CelExpr loopStepResultExpr = CelExpr.ofIdent(10, "@result"); + CelExpr loopStepVarExpr = CelExpr.ofIdent(5, "i"); + CelExpr loopStep = + CelExpr.ofCall( + 11, + Optional.empty(), + Operator.LOGICAL_OR.getFunction(), + ImmutableList.of(loopStepResultExpr, loopStepVarExpr)); + CelExpr result = CelExpr.ofIdent(12, "@result"); + CelExpr comprehension = + CelExpr.ofComprehension( + 13, "i", iterRange, "@result", accuInit, loopCondition, loopStep, result); + assertThat(allNodes).hasSize(11); + assertThat(allNodes) + .containsExactly( + comprehension, + iterRange, + iterRangeConstExpr, + accuInit, + loopCondition, + loopConditionCallExpr, + loopConditionIdentExpr, + loopStep, + loopStepResultExpr, + loopStepVarExpr, + result) + .inOrder(); + } + + @Test + public void comprehension_postOrder_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableHiddenAccumulatorVar(true).build()) + .setStandardMacros(CelStandardMacro.EXISTS) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[true].exists(i, i)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::expr) + .collect(toImmutableList()); + + CelExpr iterRangeConstExpr = CelExpr.ofConstant(2, CelConstant.ofValue(true)); + CelExpr iterRange = CelExpr.ofList(1, ImmutableList.of(iterRangeConstExpr), ImmutableList.of()); + CelExpr accuInit = CelExpr.ofConstant(6, CelConstant.ofValue(false)); + CelExpr loopConditionIdentExpr = CelExpr.ofIdent(7, "@result"); + CelExpr loopConditionCallExpr = + CelExpr.ofCall( + 8, + Optional.empty(), + Operator.LOGICAL_NOT.getFunction(), + ImmutableList.of(loopConditionIdentExpr)); + CelExpr loopCondition = + CelExpr.ofCall( + 9, + Optional.empty(), + Operator.NOT_STRICTLY_FALSE.getFunction(), + ImmutableList.of(loopConditionCallExpr)); + CelExpr loopStepResultExpr = CelExpr.ofIdent(10, "@result"); + CelExpr loopStepVarExpr = CelExpr.ofIdent(5, "i"); + CelExpr loopStep = + CelExpr.ofCall( + 11, + Optional.empty(), + Operator.LOGICAL_OR.getFunction(), + ImmutableList.of(loopStepResultExpr, loopStepVarExpr)); + CelExpr result = CelExpr.ofIdent(12, "@result"); + CelExpr comprehension = + CelExpr.ofComprehension( + 13, "i", iterRange, "@result", accuInit, loopCondition, loopStep, result); + assertThat(allNodes).hasSize(11); + assertThat(allNodes) + .containsExactly( + iterRangeConstExpr, + iterRange, + accuInit, + loopConditionIdentExpr, + loopConditionCallExpr, + loopCondition, + loopStepResultExpr, + loopStepVarExpr, + loopStep, + result, + comprehension) + .inOrder(); + } + + @Test + public void comprehension_preOrder_heightSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.EXISTS) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[true].exists(i, i)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(3, 1, 0, 0, 2, 1, 0, 1, 0, 0, 0).inOrder(); + } + + @Test + public void comprehension_postOrder_heightSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.EXISTS) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[true].exists(i, i)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(0, 1, 0, 0, 1, 2, 0, 0, 1, 0, 3).inOrder(); + } + + @Test + public void comprehension_preOrder_maxIdsSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.EXISTS) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[true].exists(i, i)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(13L, 2L, 2L, 6L, 9L, 8L, 7L, 11L, 10L, 5L, 12L).inOrder(); + } + + @Test + public void comprehension_postOrder_maxIdsSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.EXISTS) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[true].exists(i, i)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(2L, 2L, 6L, 7L, 8L, 9L, 10L, 5L, 11L, 12L, 13L).inOrder(); + } + + @Test + public void comprehension_allNodes_parentsPopulated() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableHiddenAccumulatorVar(true).build()) + .setStandardMacros(CelStandardMacro.EXISTS) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[true].exists(i, i)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst.getRoot().allNodes(TraversalOrder.PRE_ORDER).collect(toImmutableList()); + CelExpr iterRangeConstExpr = CelExpr.ofConstant(2, CelConstant.ofValue(true)); + CelExpr iterRange = CelExpr.ofList(1, ImmutableList.of(iterRangeConstExpr), ImmutableList.of()); + CelExpr accuInit = CelExpr.ofConstant(6, CelConstant.ofValue(false)); + CelExpr loopConditionIdentExpr = CelExpr.ofIdent(7, "@result"); + CelExpr loopConditionCallExpr = + CelExpr.ofCall( + 8, + Optional.empty(), + Operator.LOGICAL_NOT.getFunction(), + ImmutableList.of(loopConditionIdentExpr)); + CelExpr loopCondition = + CelExpr.ofCall( + 9, + Optional.empty(), + Operator.NOT_STRICTLY_FALSE.getFunction(), + ImmutableList.of(loopConditionCallExpr)); + CelExpr loopStepResultExpr = CelExpr.ofIdent(10, "@result"); + CelExpr loopStepVarExpr = CelExpr.ofIdent(5, "i"); + CelExpr loopStep = + CelExpr.ofCall( + 11, + Optional.empty(), + Operator.LOGICAL_OR.getFunction(), + ImmutableList.of(loopStepResultExpr, loopStepVarExpr)); + CelExpr result = CelExpr.ofIdent(12, "@result"); + CelExpr comprehension = + CelExpr.ofComprehension( + 13, "i", iterRange, "@result", accuInit, loopCondition, loopStep, result); + assertThat(allNodes).hasSize(11); + assertThat(allNodes.get(0).parent()).isEmpty(); // comprehension + assertThat(allNodes.get(1).parent().get().expr()).isEqualTo(comprehension); // iter_range + assertThat(allNodes.get(2).parent().get().expr()) + .isEqualTo(iterRange); // const_expr within iter_range + assertThat(allNodes.get(3).parent().get().expr()).isEqualTo(comprehension); // accu_init + assertThat(allNodes.get(4).parent().get().expr()).isEqualTo(comprehension); // loop_condition + assertThat(allNodes.get(5).parent().get().expr()) + .isEqualTo(loopCondition); // call_expr within loop_condition + assertThat(allNodes.get(6).parent().get().expr()) + .isEqualTo(loopConditionCallExpr); // ident_expr within call_expr within loop_condition + assertThat(allNodes.get(7).parent().get().expr()).isEqualTo(comprehension); // loop_step + assertThat(allNodes.get(8).parent().get().expr()) + .isEqualTo(loopStep); // ident_expr (result) argument within loop_step + assertThat(allNodes.get(9).parent().get().expr()) + .isEqualTo(loopStep); // ident_expr (i) argument within loop_step + assertThat(allNodes.get(10).parent().get().expr()).isEqualTo(comprehension); // result + } + + @Test + public void comprehension_filterComprehension_allNodesReturned() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableHiddenAccumulatorVar(true).build()) + .setStandardMacros(CelStandardMacro.EXISTS) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[true].exists(i, i)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes() + .filter(x -> x.getKind().equals(Kind.COMPREHENSION)) + .collect(toImmutableList()); + + CelExpr iterRangeConstExpr = CelExpr.ofConstant(2, CelConstant.ofValue(true)); + CelExpr iterRange = CelExpr.ofList(1, ImmutableList.of(iterRangeConstExpr), ImmutableList.of()); + CelExpr accuInit = CelExpr.ofConstant(6, CelConstant.ofValue(false)); + CelExpr loopConditionIdentExpr = CelExpr.ofIdent(7, "@result"); + CelExpr loopConditionCallExpr = + CelExpr.ofCall( + 8, + Optional.empty(), + Operator.LOGICAL_NOT.getFunction(), + ImmutableList.of(loopConditionIdentExpr)); + CelExpr loopCondition = + CelExpr.ofCall( + 9, + Optional.empty(), + Operator.NOT_STRICTLY_FALSE.getFunction(), + ImmutableList.of(loopConditionCallExpr)); + CelExpr loopStepResultExpr = CelExpr.ofIdent(10, "@result"); + CelExpr loopStepVarExpr = CelExpr.ofIdent(5, "i"); + CelExpr loopStep = + CelExpr.ofCall( + 11, + Optional.empty(), + Operator.LOGICAL_OR.getFunction(), + ImmutableList.of(loopStepResultExpr, loopStepVarExpr)); + CelExpr result = CelExpr.ofIdent(12, "@result"); + CelExpr comprehension = + CelExpr.ofComprehension( + 13, "i", iterRange, "@result", accuInit, loopCondition, loopStep, result); + assertThat(allNodes).hasSize(1); + assertThat(allNodes.get(0).expr()).isEqualTo(comprehension); + } + + @Test + public void callExpr_preOrder() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "test", + newMemberOverload( + "test_overload", + SimpleType.STRING, + SimpleType.STRING, + SimpleType.INT, + SimpleType.UINT))) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("'hello'.test(5, 6u)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::expr) + .collect(toImmutableList()); + + CelExpr targetExpr = CelExpr.ofConstant(1, CelConstant.ofValue("hello")); + CelExpr intArgExpr = CelExpr.ofConstant(3, CelConstant.ofValue(5)); + CelExpr uintArgExpr = CelExpr.ofConstant(4, CelConstant.ofValue(UnsignedLong.valueOf(6))); + assertThat(allNodes) + .containsExactly( + CelExpr.ofCall( + 2, Optional.of(targetExpr), "test", ImmutableList.of(intArgExpr, uintArgExpr)), + targetExpr, + intArgExpr, + uintArgExpr) + .inOrder(); + } + + @Test + public void callExpr_postOrder() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "test", + newMemberOverload( + "test_overload", + SimpleType.STRING, + SimpleType.STRING, + SimpleType.INT, + SimpleType.UINT))) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("'hello'.test(5, 6u)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::expr) + .collect(toImmutableList()); + + CelExpr targetExpr = CelExpr.ofConstant(1, CelConstant.ofValue("hello")); + CelExpr intArgExpr = CelExpr.ofConstant(3, CelConstant.ofValue(5)); + CelExpr uintArgExpr = CelExpr.ofConstant(4, CelConstant.ofValue(UnsignedLong.valueOf(6))); + assertThat(allNodes) + .containsExactly( + targetExpr, + intArgExpr, + uintArgExpr, + CelExpr.ofCall( + 2, Optional.of(targetExpr), "test", ImmutableList.of(intArgExpr, uintArgExpr))) + .inOrder(); + } + + @Test + public void callExpr_preOrder_heightSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "test", + newMemberOverload( + "test_overload", + SimpleType.STRING, + SimpleType.STRING, + SimpleType.INT, + SimpleType.UINT))) + .build(); + CelAbstractSyntaxTree ast = + compiler.compile("('a' + 'b' + 'c' + 'd').test((1 + 2 + 3), 6u)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(4, 3, 2, 1, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0).inOrder(); + } + + @Test + public void callExpr_postOrder_heightSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "test", + newMemberOverload( + "test_overload", + SimpleType.STRING, + SimpleType.STRING, + SimpleType.INT, + SimpleType.UINT))) + .build(); + CelAbstractSyntaxTree ast = + compiler.compile("('a' + 'b' + 'c' + 'd').test((1 + 2 + 3), 6u)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + + assertThat(allNodes).containsExactly(0, 0, 1, 0, 2, 0, 3, 0, 0, 1, 0, 2, 0, 4).inOrder(); + } + + @Test + public void callExpr_preOrder_maxIdsSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "test", + newMemberOverload( + "test_overload", + SimpleType.STRING, + SimpleType.STRING, + SimpleType.INT, + SimpleType.UINT))) + .build(); + CelAbstractSyntaxTree ast = + compiler.compile("('a' + 'b' + 'c' + 'd').test((1 + 2 + 3), 6u)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + + assertThat(allNodes) + .containsExactly(14L, 7L, 5L, 3L, 1L, 3L, 5L, 7L, 13L, 11L, 9L, 11L, 13L, 14L) + .inOrder(); + } + + @Test + public void callExpr_postOrder_maxIdsSet() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "test", + newMemberOverload( + "test_overload", + SimpleType.STRING, + SimpleType.STRING, + SimpleType.INT, + SimpleType.UINT))) + .build(); + CelAbstractSyntaxTree ast = + compiler.compile("('a' + 'b' + 'c' + 'd').test((1 + 2 + 3), 6u)").getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodes = + navigableAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + + assertThat(allNodes) + .containsExactly(1L, 3L, 3L, 5L, 5L, 7L, 7L, 9L, 11L, 11L, 13L, 13L, 14L, 14L) + .inOrder(); + } + + @Test + public void list_children_heightSet(@TestParameter TraversalOrder traversalOrder) + throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + CelAbstractSyntaxTree ast = compiler.compile("[1, a, (2 + 2), (3 + 4 + 5)]").getAst(); + + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodeHeights = + navigableAst + .getRoot() + .children(traversalOrder) + .map(CelNavigableExpr::height) + .collect(toImmutableList()); + assertThat(allNodeHeights).containsExactly(0, 0, 1, 2).inOrder(); + } + + @Test + public void list_children_maxIdsSet(@TestParameter TraversalOrder traversalOrder) + throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder().addVar("a", SimpleType.INT).build(); + CelAbstractSyntaxTree ast = compiler.compile("[1, a, (2 + 2), (3 + 4 + 5)]").getAst(); + + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + ImmutableList allNodeHeights = + navigableAst + .getRoot() + .children(traversalOrder) + .map(CelNavigableExpr::maxId) + .collect(toImmutableList()); + assertThat(allNodeHeights).containsExactly(2L, 3L, 6L, 11L).inOrder(); + } + + @Test + public void maxRecursionLimitReached_throws() throws Exception { + StringBuilder sb = new StringBuilder(); + sb.append("0"); + for (int i = 1; i < 501; i++) { + sb.append(" + ").append(i); + } // 0 + 1 + 2 + 3 + ... 500 + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().maxParseRecursionDepth(500).build()) + .build(); + CelAbstractSyntaxTree ast = compiler.compile(sb.toString()).getAst(); + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + + IllegalStateException e = + assertThrows(IllegalStateException.class, () -> navigableAst.getRoot().allNodes()); + assertThat(e).hasMessageThat().contains("Max recursion depth reached."); + } +} diff --git a/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableAstTest.java b/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableAstTest.java new file mode 100644 index 000000000..6b78b5f23 --- /dev/null +++ b/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableAstTest.java @@ -0,0 +1,44 @@ +// Copyright 2024 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.navigation; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.CelMutableAst; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelNavigableMutableAstTest { + + @Test + public void construct_success() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelMutableAst ast = CelMutableAst.fromCelAst(celCompiler.compile("'Hello World'").getAst()); + + CelNavigableMutableAst navigableAst = CelNavigableMutableAst.fromAst(ast); + + assertThat(navigableAst.getAst()).isEqualTo(ast); + assertThat(navigableAst.getRoot().expr()) + .isEqualTo(CelMutableExpr.ofConstant(1, CelConstant.ofValue("Hello World"))); + assertThat(navigableAst.getRoot().parent()).isEmpty(); + assertThat(navigableAst.getRoot().depth()).isEqualTo(0); + } +} diff --git a/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableExprTest.java b/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableExprTest.java new file mode 100644 index 000000000..6900d41aa --- /dev/null +++ b/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableExprTest.java @@ -0,0 +1,150 @@ +// Copyright 2024 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.navigation; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelNavigableMutableExprTest { + + @Test + public void construct_withoutParent() { + CelMutableExpr constExpr = CelMutableExpr.ofConstant(1, CelConstant.ofValue("test")); + + CelNavigableMutableExpr navigableExpr = + CelNavigableMutableExpr.builder().setExpr(constExpr).setDepth(2).build(); + + assertThat(navigableExpr.expr()).isEqualTo(constExpr); + assertThat(navigableExpr.depth()).isEqualTo(2); + assertThat(navigableExpr.parent()).isEmpty(); + } + + @Test + public void construct_withParent() { + CelMutableExpr constExpr = CelMutableExpr.ofConstant(1, CelConstant.ofValue("test")); + CelMutableExpr identExpr = CelMutableExpr.ofIdent(2, "a"); + + CelNavigableMutableExpr parentExpr = + CelNavigableMutableExpr.builder().setExpr(identExpr).setDepth(1).build(); + CelNavigableMutableExpr navigableExpr = + CelNavigableMutableExpr.builder() + .setExpr(constExpr) + .setDepth(2) + .setParent(parentExpr) + .build(); + + assertThat(parentExpr.expr()).isEqualTo(identExpr); + assertThat(parentExpr.depth()).isEqualTo(1); + assertThat(parentExpr.parent()).isEmpty(); + assertThat(navigableExpr.expr()).isEqualTo(constExpr); + assertThat(navigableExpr.depth()).isEqualTo(2); + assertThat(navigableExpr.parent()).hasValue(parentExpr); + } + + @Test + public void builderFromInstance_sameAsStaticBuilder() { + CelNavigableMutableExpr.Builder staticBuilder = + CelNavigableMutableExpr.builder().setExpr(CelMutableExpr.ofNotSet()); + + CelNavigableMutableExpr.Builder builderFromInstance = + CelNavigableMutableExpr.fromExpr(CelMutableExpr.ofNotSet()) + .builderFromInstance() + .setExpr(CelMutableExpr.ofNotSet()); + + assertThat(staticBuilder.build()).isEqualTo(builderFromInstance.build()); + } + + @Test + public void allNodes_filteredConstants_returnsAllConstants() { + CelNavigableMutableExpr mutableExpr = + CelNavigableMutableExpr.fromExpr( + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))))))); + + ImmutableList allNodes = + mutableExpr + .allNodes() + .filter(node -> node.getKind().equals(Kind.CONSTANT)) + .map(BaseNavigableExpr::expr) + .collect(toImmutableList()); + + assertThat(allNodes) + .containsExactly( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))) + .inOrder(); + } + + @Test + public void descendants_filteredConstants_returnsAllConstants() { + CelNavigableMutableExpr mutableExpr = + CelNavigableMutableExpr.fromExpr( + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))))))); + + ImmutableList allNodes = + mutableExpr + .descendants() + .filter(node -> node.getKind().equals(Kind.CONSTANT)) + .map(BaseNavigableExpr::expr) + .collect(toImmutableList()); + + assertThat(allNodes) + .containsExactly( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))) + .inOrder(); + } + + @Test + public void children_filteredConstants_returnsSingleConstant() { + CelNavigableMutableExpr mutableExpr = + CelNavigableMutableExpr.fromExpr( + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), + CelMutableExpr.ofList( + CelMutableList.create( + CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))))))); + + ImmutableList allNodes = + mutableExpr + .children() + .filter(node -> node.getKind().equals(Kind.CONSTANT)) + .map(BaseNavigableExpr::expr) + .collect(toImmutableList()); + + assertThat(allNodes) + .containsExactly(CelMutableExpr.ofConstant(CelConstant.ofValue("element1"))); + } +} diff --git a/common/src/test/java/dev/cel/common/types/BUILD.bazel b/common/src/test/java/dev/cel/common/types/BUILD.bazel new file mode 100644 index 000000000..64f555547 --- /dev/null +++ b/common/src/test/java/dev/cel/common/types/BUILD.bazel @@ -0,0 +1,39 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//common/types", + "//common/types:cel_internal_types", + "//common/types:cel_proto_message_types", + "//common/types:cel_proto_types", + "//common/types:cel_types", + "//common/types:message_type_provider", + "//common/types:type_providers", + "//testing/protos:single_file_java_proto", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:com_google_truth_extensions_truth_proto_extension", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/common/src/test/java/dev/cel/common/types/CelKindTest.java b/common/src/test/java/dev/cel/common/types/CelKindTest.java new file mode 100644 index 000000000..68b487afa --- /dev/null +++ b/common/src/test/java/dev/cel/common/types/CelKindTest.java @@ -0,0 +1,52 @@ +// Copyright 2023 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.types; + +import static com.google.common.truth.Truth.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelKindTest { + + @Test + public void isPrimitive_true() { + assertThat(CelKind.INT.isPrimitive()).isTrue(); + assertThat(CelKind.BOOL.isPrimitive()).isTrue(); + assertThat(CelKind.UINT.isPrimitive()).isTrue(); + assertThat(CelKind.DOUBLE.isPrimitive()).isTrue(); + assertThat(CelKind.STRING.isPrimitive()).isTrue(); + assertThat(CelKind.BYTES.isPrimitive()).isTrue(); + } + + @Test + public void isPrimitive_false() { + assertThat(CelKind.UNSPECIFIED.isPrimitive()).isFalse(); + assertThat(CelKind.ERROR.isPrimitive()).isFalse(); + assertThat(CelKind.DYN.isPrimitive()).isFalse(); + assertThat(CelKind.ANY.isPrimitive()).isFalse(); + assertThat(CelKind.DURATION.isPrimitive()).isFalse(); + assertThat(CelKind.LIST.isPrimitive()).isFalse(); + assertThat(CelKind.MAP.isPrimitive()).isFalse(); + assertThat(CelKind.NULL_TYPE.isPrimitive()).isFalse(); + assertThat(CelKind.OPAQUE.isPrimitive()).isFalse(); + assertThat(CelKind.STRUCT.isPrimitive()).isFalse(); + assertThat(CelKind.TIMESTAMP.isPrimitive()).isFalse(); + assertThat(CelKind.TYPE.isPrimitive()).isFalse(); + assertThat(CelKind.TYPE_PARAM.isPrimitive()).isFalse(); + } +} diff --git a/common/src/test/java/dev/cel/common/types/CelProtoMessageTypesTest.java b/common/src/test/java/dev/cel/common/types/CelProtoMessageTypesTest.java new file mode 100644 index 000000000..593dcc17d --- /dev/null +++ b/common/src/test/java/dev/cel/common/types/CelProtoMessageTypesTest.java @@ -0,0 +1,36 @@ +// Copyright 2025 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.types; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.expr.Type; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelProtoMessageTypesTest { + + @Test + public void createMessage_fromDescriptor() { + Type type = CelProtoMessageTypes.createMessage(TestAllTypes.getDescriptor()); + + assertThat(type) + .isEqualTo( + Type.newBuilder().setMessageType(TestAllTypes.getDescriptor().getFullName()).build()); + } +} diff --git a/common/src/test/java/dev/cel/common/types/CelProtoTypesTest.java b/common/src/test/java/dev/cel/common/types/CelProtoTypesTest.java new file mode 100644 index 000000000..bcddd03fd --- /dev/null +++ b/common/src/test/java/dev/cel/common/types/CelProtoTypesTest.java @@ -0,0 +1,122 @@ +// Copyright 2024 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.types; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; + +import dev.cel.expr.Type; +import dev.cel.expr.Type.AbstractType; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelProtoTypesTest { + + @Test + public void isOptionalType_true() { + Type optionalType = CelProtoTypes.createOptionalType(CelProtoTypes.INT64); + + assertThat(CelProtoTypes.isOptionalType(optionalType)).isTrue(); + } + + @Test + public void isOptionalType_false() { + Type notOptionalType = + Type.newBuilder() + .setAbstractType(AbstractType.newBuilder().setName("notOptional").build()) + .build(); + + assertThat(CelProtoTypes.isOptionalType(notOptionalType)).isFalse(); + } + + @Test + public void createOptionalType() { + Type optionalType = CelProtoTypes.createOptionalType(CelProtoTypes.INT64); + + assertThat(optionalType.hasAbstractType()).isTrue(); + assertThat(optionalType.getAbstractType().getName()).isEqualTo("optional_type"); + assertThat(optionalType.getAbstractType().getParameterTypesCount()).isEqualTo(1); + assertThat(optionalType.getAbstractType().getParameterTypes(0)).isEqualTo(CelProtoTypes.INT64); + } + + private enum TestCases { + UNSPECIFIED(UnspecifiedType.create(), Type.getDefaultInstance()), + STRING(SimpleType.STRING, CelProtoTypes.STRING), + INT(NullableType.create(SimpleType.INT), CelProtoTypes.createWrapper(CelProtoTypes.INT64)), + UINT(NullableType.create(SimpleType.UINT), CelProtoTypes.createWrapper(CelProtoTypes.UINT64)), + DOUBLE( + NullableType.create(SimpleType.DOUBLE), CelProtoTypes.createWrapper(CelProtoTypes.DOUBLE)), + BOOL(NullableType.create(SimpleType.BOOL), CelProtoTypes.createWrapper(CelProtoTypes.BOOL)), + BYTES(SimpleType.BYTES, CelProtoTypes.BYTES), + ANY(SimpleType.ANY, CelProtoTypes.ANY), + LIST( + ListType.create(), + Type.newBuilder().setListType(Type.ListType.getDefaultInstance()).build()), + DYN(ListType.create(SimpleType.DYN), CelProtoTypes.createList(CelProtoTypes.DYN)), + ENUM(EnumType.create("CustomEnum", ImmutableMap.of()), CelProtoTypes.INT64), + STRUCT_TYPE_REF( + StructTypeReference.create("MyCustomStruct"), + CelProtoTypes.createMessage("MyCustomStruct")), + OPAQUE( + OpaqueType.create("vector", SimpleType.UINT), + Type.newBuilder() + .setAbstractType( + AbstractType.newBuilder().setName("vector").addParameterTypes(CelProtoTypes.UINT64)) + .build()), + TYPE_PARAM(TypeParamType.create("T"), CelProtoTypes.createTypeParam("T")), + FUNCTION( + CelTypes.createFunctionType( + SimpleType.INT, ImmutableList.of(SimpleType.STRING, SimpleType.UINT)), + Type.newBuilder() + .setFunction( + Type.FunctionType.newBuilder() + .setResultType(CelProtoTypes.INT64) + .addAllArgTypes(ImmutableList.of(CelProtoTypes.STRING, CelProtoTypes.UINT64))) + .build()), + OPTIONAL( + OptionalType.create(SimpleType.INT), CelProtoTypes.createOptionalType(CelProtoTypes.INT64)), + TYPE( + TypeType.create(MapType.create(SimpleType.STRING, SimpleType.STRING)), + CelProtoTypes.create(CelProtoTypes.createMap(CelProtoTypes.STRING, CelProtoTypes.STRING))); + + private final CelType celType; + private final Type type; + + TestCases(CelType celType, Type type) { + this.celType = celType; + this.type = type; + } + } + + @Test + public void celTypeToType(@TestParameter TestCases testCase) { + assertThat(CelProtoTypes.celTypeToType(testCase.celType)).isEqualTo(testCase.type); + } + + @Test + public void typeToCelType(@TestParameter TestCases testCase) { + if (testCase.celType instanceof EnumType) { + // (b/178627883) Strongly typed enum is not supported yet + return; + } + + assertThat(CelProtoTypes.typeToCelType(testCase.type)).isEqualTo(testCase.celType); + } +} diff --git a/common/src/test/java/dev/cel/common/types/CelTypesTest.java b/common/src/test/java/dev/cel/common/types/CelTypesTest.java new file mode 100644 index 000000000..ae6e0808c --- /dev/null +++ b/common/src/test/java/dev/cel/common/types/CelTypesTest.java @@ -0,0 +1,97 @@ +// Copyright 2022 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.types; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.expr.Type; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelTypesTest { + + @Test + public void isWellKnownType_true() { + assertThat(CelTypes.isWellKnownType(CelTypes.ANY_MESSAGE)).isTrue(); + } + + @Test + public void isWellKnownType_false() { + assertThat(CelTypes.isWellKnownType("CustomType")).isFalse(); + } + + private enum FormatTestCases { + UNSPECIFIED(UnspecifiedType.create(), ""), + STRING(SimpleType.STRING, "string"), + INT(NullableType.create(SimpleType.INT), "wrapper(int)"), + UINT(NullableType.create(SimpleType.UINT), "wrapper(uint)"), + DOUBLE(NullableType.create(SimpleType.DOUBLE), "wrapper(double)"), + BOOL(NullableType.create(SimpleType.BOOL), "wrapper(bool)"), + NULL_TYPE(SimpleType.NULL_TYPE, "null"), + BYTES(SimpleType.BYTES, "bytes"), + ANY(SimpleType.ANY, "any"), + LIST_DYN(ListType.create(SimpleType.DYN), "list(dyn)"), + ENUM(EnumType.create("CustomEnum", ImmutableMap.of()), "int"), + STRUCT_TYPE_REF(StructTypeReference.create("MyCustomStruct"), "MyCustomStruct"), + OPAQUE(OpaqueType.create("vector", SimpleType.UINT), "vector(uint)"), + TYPE_PARAM(TypeParamType.create("T"), "T"), + FUNCTION( + CelTypes.createFunctionType( + SimpleType.INT, ImmutableList.of(SimpleType.STRING, SimpleType.UINT)), + "(string, uint) -> int"), + OPTIONAL(OptionalType.create(SimpleType.INT), "optional_type(int)"), + MAP(MapType.create(SimpleType.INT, SimpleType.STRING), "map(int, string)"), + TYPE( + TypeType.create(MapType.create(SimpleType.STRING, SimpleType.STRING)), + "type(map(string, string))"), + TIMESTAMP(SimpleType.TIMESTAMP, "google.protobuf.Timestamp"), + DURATION(SimpleType.DURATION, "google.protobuf.Duration"), + ERROR(SimpleType.ERROR, "*error*"); + + private final CelType celType; + private final String formattedString; + + FormatTestCases(CelType celType, String formattedString) { + this.celType = celType; + this.formattedString = formattedString; + } + } + + @Test + public void format_withCelType(@TestParameter FormatTestCases testCase) { + assertThat(CelTypes.format(testCase.celType)).isEqualTo(testCase.formattedString); + } + + @Test + public void format_withType(@TestParameter FormatTestCases testCase) { + Type type = CelProtoTypes.celTypeToType(testCase.celType); + + assertThat(CelProtoTypes.format(type)).isEqualTo(testCase.formattedString); + } + + @Test + public void formatFunction_isInstanceFunction() { + String formattedString = + CelTypes.formatFunction( + SimpleType.INT, ImmutableList.of(SimpleType.STRING, SimpleType.UINT), true, false); + + assertThat(formattedString).isEqualTo("string.(uint) -> int"); + } +} diff --git a/common/src/test/java/dev/cel/common/types/EnumTypeTest.java b/common/src/test/java/dev/cel/common/types/EnumTypeTest.java new file mode 100644 index 000000000..3fdc47148 --- /dev/null +++ b/common/src/test/java/dev/cel/common/types/EnumTypeTest.java @@ -0,0 +1,48 @@ +// Copyright 2022 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.types; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class EnumTypeTest { + + private EnumType enumType; + + @Before + public void setUp() { + ImmutableMap enumItems = + ImmutableMap.of("NOT_SPECIFIED", 0, "INT_TYPE", 1, "STRING_TYPE", 2); + enumType = EnumType.create("MyCustomEnum", enumItems); + } + + @Test + public void findNumberByName() { + assertThat(enumType.findNameByNumber(1)).hasValue("INT_TYPE"); + assertThat(enumType.findNameByNumber(42)).isEmpty(); + } + + @Test + public void findNameByNumber() { + assertThat(enumType.findNumberByName("STRING_TYPE")).hasValue(2); + assertThat(enumType.findNumberByName("DOUBLE_TYPE")).isEmpty(); + } +} diff --git a/common/src/test/java/dev/cel/common/types/OptionalTypeTest.java b/common/src/test/java/dev/cel/common/types/OptionalTypeTest.java new file mode 100644 index 000000000..9af8f4abb --- /dev/null +++ b/common/src/test/java/dev/cel/common/types/OptionalTypeTest.java @@ -0,0 +1,34 @@ +// Copyright 2023 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.types; + +import static com.google.common.truth.Truth.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class OptionalTypeTest { + + @Test + public void createOptionalType_success() { + OptionalType optionalType = OptionalType.create(SimpleType.STRING); + + assertThat(optionalType.name()).isEqualTo("optional_type"); + assertThat(optionalType.kind()).isEqualTo(CelKind.OPAQUE); + assertThat(optionalType.parameters()).containsExactly(SimpleType.STRING); + } +} diff --git a/common/src/test/java/dev/cel/common/types/ProtoMessageTypeProviderTest.java b/common/src/test/java/dev/cel/common/types/ProtoMessageTypeProviderTest.java new file mode 100644 index 000000000..c9f9d9e21 --- /dev/null +++ b/common/src/test/java/dev/cel/common/types/ProtoMessageTypeProviderTest.java @@ -0,0 +1,278 @@ +// Copyright 2022 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.types; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import dev.cel.common.types.CelTypeProvider.CombinedCelTypeProvider; +import dev.cel.common.types.StructType.Field; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import dev.cel.expr.conformance.proto2.TestAllTypesExtensions; +import dev.cel.testing.testdata.SingleFile; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class ProtoMessageTypeProviderTest { + + private final ProtoMessageTypeProvider emptyProvider = new ProtoMessageTypeProvider(); + + private final ProtoMessageTypeProvider proto3Provider = + new ProtoMessageTypeProvider( + ImmutableList.of(dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor())); + + private final ProtoMessageTypeProvider proto2Provider = + new ProtoMessageTypeProvider( + ImmutableSet.of( + dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor().getFile(), + TestAllTypes.getDescriptor().getFile(), + TestAllTypesExtensions.getDescriptor())); + + @Test + public void types_emptyTypeSet() { + assertThat(emptyProvider.types()).isEmpty(); + } + + @Test + public void findType_emptyTypeSet() { + assertThat(emptyProvider.findType("any")).isEmpty(); + } + + @Test + public void types_allGlobalAndNestedDeclarations() { + assertThat(proto3Provider.types().stream().map(CelType::name).collect(toImmutableList())) + .containsAtLeast( + "cel.expr.conformance.proto3.GlobalEnum", + "cel.expr.conformance.proto3.TestAllTypes", + "cel.expr.conformance.proto3.TestAllTypes.NestedMessage", + "cel.expr.conformance.proto3.TestAllTypes.NestedEnum", + "cel.expr.conformance.proto3.NestedTestAllTypes"); + } + + @Test + public void findType_globalEnumWithAllNamesAndNumbers() { + Optional celType = proto3Provider.findType("cel.expr.conformance.proto3.GlobalEnum"); + assertThat(celType).isPresent(); + assertThat(celType.get()).isInstanceOf(EnumType.class); + EnumType enumType = (EnumType) celType.get(); + assertThat(enumType.name()).isEqualTo("cel.expr.conformance.proto3.GlobalEnum"); + assertThat(enumType.findNameByNumber(0)).hasValue("GOO"); + assertThat(enumType.findNameByNumber(1)).hasValue("GAR"); + assertThat(enumType.findNameByNumber(2)).hasValue("GAZ"); + assertThat(enumType.findNameByNumber(3)).isEmpty(); + } + + @Test + public void findType_nestedEnumWithAllNamesAndNumbers() { + Optional celType = + proto3Provider.findType("cel.expr.conformance.proto3.TestAllTypes.NestedEnum"); + assertThat(celType).isPresent(); + assertThat(celType.get()).isInstanceOf(EnumType.class); + EnumType enumType = (EnumType) celType.get(); + assertThat(enumType.name()).isEqualTo("cel.expr.conformance.proto3.TestAllTypes.NestedEnum"); + assertThat(enumType.findNumberByName("FOO")).hasValue(0); + assertThat(enumType.findNumberByName("BAR")).hasValue(1); + assertThat(enumType.findNumberByName("BAZ")).hasValue(2); + assertThat(enumType.findNumberByName("MISSING")).isEmpty(); + } + + @Test + public void findType_globalMessageTypeNoExtensions() { + Optional celType = + proto3Provider.findType("cel.expr.conformance.proto3.NestedTestAllTypes"); + assertThat(celType).isPresent(); + assertThat(celType.get()).isInstanceOf(ProtoMessageType.class); + ProtoMessageType protoType = (ProtoMessageType) celType.get(); + assertThat(protoType.name()).isEqualTo("cel.expr.conformance.proto3.NestedTestAllTypes"); + assertThat(protoType.findField("payload")).isPresent(); + assertThat(protoType.findField("child")).isPresent(); + assertThat(protoType.findField("missing")).isEmpty(); + assertThat(protoType.fields()).hasSize(2); + assertThat(protoType.findExtension("dev.cel.testing.testdata.proto3.any")).isEmpty(); + } + + @Test + public void findType_globalMessageWithExtensions() { + Optional celType = proto2Provider.findType("cel.expr.conformance.proto2.TestAllTypes"); + assertThat(celType).isPresent(); + assertThat(celType.get()).isInstanceOf(ProtoMessageType.class); + ProtoMessageType protoType = (ProtoMessageType) celType.get(); + assertThat(protoType.name()).isEqualTo("cel.expr.conformance.proto2.TestAllTypes"); + assertThat(protoType.findField("single_int32")).isPresent(); + assertThat(protoType.findField("single_uint64")).isPresent(); + assertThat(protoType.findField("oneof_type")).isPresent(); + assertThat(protoType.findField("nestedgroup")).isPresent(); + assertThat(protoType.findField("nested_enum_ext")).isEmpty(); + + assertThat(protoType.findExtension("cel.expr.conformance.proto2.nested_ext")).isPresent(); + assertThat(protoType.findExtension("cel.expr.conformance.proto2.int32_ext")).isPresent(); + assertThat(protoType.findExtension("cel.expr.conformance.proto2.test_all_types_ext")) + .isPresent(); + assertThat(protoType.findExtension("cel.expr.conformance.proto2.nested_enum_ext")).isPresent(); + assertThat(protoType.findExtension("cel.expr.conformance.proto2.repeated_test_all_types")) + .isPresent(); + + assertThat(protoType.findExtension("cel.expr.conformance.proto2.TestAllTypes.int32_ext")) + .isEmpty(); + + Optional holderType = + proto2Provider.findType("cel.expr.conformance.proto2.TestRequired"); + assertThat(holderType).isPresent(); + ProtoMessageType stringHolderType = (ProtoMessageType) holderType.get(); + assertThat(stringHolderType.findExtension("cel.expr.conformance.proto2.nested_enum_ext")) + .isEmpty(); + } + + @Test + public void findType_scopedMessageWithExtensions() { + Optional celType = proto2Provider.findType("cel.expr.conformance.proto2.TestAllTypes"); + assertThat(celType).isPresent(); + assertThat(celType.get()).isInstanceOf(ProtoMessageType.class); + ProtoMessageType protoType = (ProtoMessageType) celType.get(); + + assertThat( + protoType.findExtension( + "cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext")) + .isPresent(); + assertThat( + protoType.findExtension( + "cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext")) + .isPresent(); + assertThat( + protoType.findExtension( + "cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types")) + .isPresent(); + + assertThat( + protoType.findExtension( + "cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext")) + .isPresent(); + } + + @Test + public void findType_withRepeatedEnumField() { + Optional celType = proto3Provider.findType("cel.expr.conformance.proto3.TestAllTypes"); + assertThat(celType).isPresent(); + assertThat(celType.get()).isInstanceOf(ProtoMessageType.class); + ProtoMessageType protoType = (ProtoMessageType) celType.get(); + assertThat(protoType.name()).isEqualTo("cel.expr.conformance.proto3.TestAllTypes"); + assertThat(protoType.findField("repeated_nested_enum")).isPresent(); + + CelType fieldType = protoType.findField("repeated_nested_enum").get().type(); + assertThat(fieldType.kind()).isEqualTo(CelKind.LIST); + assertThat(fieldType.parameters()).hasSize(1); + CelType elemType = fieldType.parameters().get(0); + assertThat(elemType.name()).isEqualTo("cel.expr.conformance.proto3.TestAllTypes.NestedEnum"); + assertThat(elemType.kind()).isEqualTo(CelKind.INT); + assertThat(elemType).isInstanceOf(EnumType.class); + assertThat(proto3Provider.findType("cel.expr.conformance.proto3.TestAllTypes.NestedEnum")) + .hasValue(elemType); + } + + @Test + public void findType_withOneofField() { + Optional celType = proto3Provider.findType("cel.expr.conformance.proto3.TestAllTypes"); + ProtoMessageType protoType = (ProtoMessageType) celType.get(); + assertThat(protoType.name()).isEqualTo("cel.expr.conformance.proto3.TestAllTypes"); + assertThat(protoType.findField("single_nested_message").map(f -> f.type().name())) + .hasValue("cel.expr.conformance.proto3.TestAllTypes.NestedMessage"); + } + + @Test + public void findType_withMapField() { + Optional celType = proto3Provider.findType("cel.expr.conformance.proto3.TestAllTypes"); + ProtoMessageType protoType = (ProtoMessageType) celType.get(); + CelType fieldType = protoType.findField("map_int64_nested_type").get().type(); + + assertThat(fieldType.kind()).isEqualTo(CelKind.MAP); + assertThat(fieldType.parameters()).hasSize(2); + CelType keyType = fieldType.parameters().get(0); + CelType valueType = fieldType.parameters().get(1); + assertThat(keyType.name()).isEqualTo("int"); + assertThat(keyType.kind()).isEqualTo(CelKind.INT); + assertThat(valueType.name()).isEqualTo("cel.expr.conformance.proto3.NestedTestAllTypes"); + assertThat(valueType.kind()).isEqualTo(CelKind.STRUCT); + } + + @Test + public void findType_withWellKnownTypes() { + Optional celType = proto3Provider.findType("cel.expr.conformance.proto3.TestAllTypes"); + ProtoMessageType protoType = (ProtoMessageType) celType.get(); + assertThat(protoType.findField("single_any").map(f -> f.type())).hasValue(SimpleType.ANY); + assertThat(protoType.findField("single_duration").map(f -> f.type())) + .hasValue(SimpleType.DURATION); + assertThat(protoType.findField("single_timestamp").map(f -> f.type())) + .hasValue(SimpleType.TIMESTAMP); + assertThat(protoType.findField("single_value").map(f -> f.type())).hasValue(SimpleType.DYN); + assertThat(protoType.findField("list_value").map(f -> f.type())) + .hasValue(ListType.create(SimpleType.DYN)); + assertThat(protoType.findField("single_struct").map(f -> f.type())) + .hasValue(MapType.create(SimpleType.STRING, SimpleType.DYN)); + assertThat(protoType.findField("single_bool_wrapper").map(f -> f.type())) + .hasValue(NullableType.create(SimpleType.BOOL)); + assertThat(protoType.findField("single_bytes_wrapper").map(f -> f.type())) + .hasValue(NullableType.create(SimpleType.BYTES)); + assertThat(protoType.findField("single_int32_wrapper").map(f -> f.type())) + .hasValue(NullableType.create(SimpleType.INT)); + assertThat(protoType.findField("single_int64_wrapper").map(f -> f.type())) + .hasValue(NullableType.create(SimpleType.INT)); + assertThat(protoType.findField("single_double_wrapper").map(f -> f.type())) + .hasValue(NullableType.create(SimpleType.DOUBLE)); + assertThat(protoType.findField("single_float_wrapper").map(f -> f.type())) + .hasValue(NullableType.create(SimpleType.DOUBLE)); + assertThat(protoType.findField("single_string_wrapper").map(f -> f.type())) + .hasValue(NullableType.create(SimpleType.STRING)); + assertThat(protoType.findField("single_uint32_wrapper").map(f -> f.type())) + .hasValue(NullableType.create(SimpleType.UINT)); + assertThat(protoType.findField("single_uint64_wrapper").map(f -> f.type())) + .hasValue(NullableType.create(SimpleType.UINT)); + } + + @Test + public void types_combinedEmptyProviderIsEmpty() { + CombinedCelTypeProvider combined = new CombinedCelTypeProvider(emptyProvider, emptyProvider); + assertThat(combined.types()).isEmpty(); + } + + @Test + public void types_combinedDuplicateProviderIsSameAsFirst() { + CombinedCelTypeProvider combined = new CombinedCelTypeProvider(proto3Provider, proto3Provider); + assertThat(combined.types()).hasSize(proto3Provider.types().size()); + } + + @Test + public void findField_withJsonNameOption() { + ProtoMessageTypeProvider typeProvider = + ProtoMessageTypeProvider.newBuilder() + .addFileDescriptors(SingleFile.getDescriptor().getFile()) + .setAllowJsonFieldNames(true) + .build(); + + ProtoMessageType msgType = + (ProtoMessageType) typeProvider.findType(SingleFile.getDescriptor().getFullName()).get(); + + // Note that these are the same fields, with json_name option set + Optional snakeCasedField = msgType.findField("int64_camel_case_json_name"); + Optional jsonNameField = msgType.findField("int64CamelCaseJsonName"); + + assertThat(snakeCasedField).isEmpty(); + assertThat(jsonNameField).isPresent(); + } +} diff --git a/common/src/test/java/dev/cel/common/types/ProtoMessageTypeTest.java b/common/src/test/java/dev/cel/common/types/ProtoMessageTypeTest.java new file mode 100644 index 000000000..d6e90b1b4 --- /dev/null +++ b/common/src/test/java/dev/cel/common/types/ProtoMessageTypeTest.java @@ -0,0 +1,78 @@ +// Copyright 2022 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.types; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class ProtoMessageTypeTest { + + private static final ImmutableMap FIELD_MAP = + ImmutableMap.of( + "bool_value", NullableType.create(SimpleType.BOOL), + "int_value", NullableType.create(SimpleType.INT), + "string_value", NullableType.create(SimpleType.STRING), + "map_value", MapType.create(SimpleType.UINT, TypeType.create(SimpleType.DYN))); + + private static final ImmutableMap EXTENSION_MAP = + ImmutableMap.of("my.package.int_extension", SimpleType.INT); + + private ProtoMessageType testMessage; + + @Before + public void setUp() { + testMessage = + new ProtoMessageType( + "my.package.TestMessage", + FIELD_MAP.keySet(), + (field) -> Optional.ofNullable(FIELD_MAP.get(field)), + (extension) -> Optional.ofNullable(EXTENSION_MAP.get(extension)), + (unused) -> false); + } + + @Test + public void findField() { + for (String fieldName : FIELD_MAP.keySet()) { + assertThat(testMessage.findField(fieldName)) + .hasValue(StructType.Field.of(fieldName, FIELD_MAP.get(fieldName))); + } + } + + @Test + public void withVisibleFields() { + ProtoMessageType maskedMessage = testMessage.withVisibleFields(ImmutableSet.of("bool_value")); + assertThat(maskedMessage.findField("int_value")).isEmpty(); + assertThat(maskedMessage.findField("bool_value")).isPresent(); + assertThat(maskedMessage.fields()).hasSize(1); + assertThat(testMessage.fields()).hasSize(4); + } + + @Test + public void findExtension() { + for (String extName : EXTENSION_MAP.keySet()) { + assertThat(testMessage.findExtension(extName)) + .hasValue( + ProtoMessageType.Extension.of(extName, EXTENSION_MAP.get(extName), testMessage)); + } + } +} diff --git a/common/src/test/java/dev/cel/common/values/BUILD.bazel b/common/src/test/java/dev/cel/common/values/BUILD.bazel new file mode 100644 index 000000000..76c761567 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/BUILD.bazel @@ -0,0 +1,55 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//bundle:cel", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:options", + "//common/internal:cel_descriptor_pools", + "//common/internal:cel_lite_descriptor_pool", + "//common/internal:default_lite_descriptor_pool", + "//common/internal:default_message_factory", + "//common/internal:dynamic_proto", + "//common/internal:proto_message_factory", + "//common/types", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_byte_string", + "//common/values:cel_value_provider", + "//common/values:combined_cel_value_converter", + "//common/values:combined_cel_value_provider", + "//common/values:proto_message_lite_value", + "//common/values:proto_message_lite_value_provider", + "//common/values:proto_message_value", + "//common/values:proto_message_value_provider", + "//testing/protos:test_all_types_cel_java_proto3", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_guava_guava_testlib", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/common/src/test/java/dev/cel/common/values/CelByteStringTest.java b/common/src/test/java/dev/cel/common/values/CelByteStringTest.java new file mode 100644 index 000000000..e59212bf2 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/CelByteStringTest.java @@ -0,0 +1,88 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.testing.ClassSanityTester; +import com.google.common.testing.EqualsTester; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelByteStringTest { + + @Test + public void emptyBytes() { + CelByteString byteString = CelByteString.of(new byte[0]); + + assertThat(byteString).isEqualTo(CelByteString.EMPTY); + assertThat(byteString.isEmpty()).isTrue(); + assertThat(byteString.toByteArray()).isEqualTo(new byte[0]); + } + + @Test + public void equalityTest() { + new EqualsTester() + .addEqualityGroup(CelByteString.of(new byte[0]), CelByteString.EMPTY) + .addEqualityGroup(CelByteString.of(new byte[] {0xa}), CelByteString.of(new byte[] {0xa})) + .addEqualityGroup( + CelByteString.of(new byte[] {0x1, 0x5, 0xc}), + CelByteString.of(new byte[] {0x1, 0x5, 0xc})) + .addEqualityGroup(CelByteString.of(new byte[] {0xf})) + .testEquals(); + } + + @Test + public void sanityTest() throws Exception { + new ClassSanityTester() + .setDefault(CelByteString.class, CelByteString.of(new byte[] {0x1, 0x5, 0xc})) + .setDistinctValues( + CelByteString.class, + CelByteString.of(new byte[] {0x1, 0x5, 0xc}), + CelByteString.of(new byte[] {0x2, 0x6, 0xc})) + .forAllPublicStaticMethods(CelByteString.class) + .thatReturn(CelByteString.class) + .testEquals() + .testNulls(); + } + + @Test + public void hashCode_smokeTest() { + assertThat(CelByteString.of(new byte[0]).hashCode()).isEqualTo(1000002); + assertThat(CelByteString.of(new byte[] {0x1}).hashCode()).isEqualTo(1000035); + assertThat(CelByteString.of(new byte[] {0x1, 0x5}).hashCode()).isEqualTo(999846); + assertThat(CelByteString.of(new byte[] {0x1, 0x5, 0xc}).hashCode()).isEqualTo(998020); + } + + @Test + public void byteString_isImmutable() { + byte[] bytes = {0x1, 0xa, 0x3}; + CelByteString byteString = CelByteString.of(bytes); + + bytes[0] = 0x2; + byte[] newByteArray = byteString.toByteArray(); + assertThat(newByteArray).isNotEqualTo(bytes); + bytes[0] = 0x1; + assertThat(newByteArray).isEqualTo(bytes); + } + + @Test + public void nullBytes_throws() { + assertThrows(NullPointerException.class, () -> CelByteString.of(null)); + } +} diff --git a/common/src/test/java/dev/cel/common/values/CelValueConverterTest.java b/common/src/test/java/dev/cel/common/values/CelValueConverterTest.java new file mode 100644 index 000000000..ccb8e605f --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/CelValueConverterTest.java @@ -0,0 +1,53 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; + +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelValueConverterTest { + private static final CelValueConverter CEL_VALUE_CONVERTER = new CelValueConverter() {}; + + @Test + @SuppressWarnings("unchecked") // Test only + public void toRuntimeValue_optionalValue() { + OptionalValue optionalValue = + (OptionalValue) CEL_VALUE_CONVERTER.toRuntimeValue(Optional.of("test")); + + assertThat(optionalValue).isEqualTo(OptionalValue.create("test")); + } + + @Test + @SuppressWarnings("unchecked") // Test only + public void unwrap_optionalValue() { + Optional result = + (Optional) CEL_VALUE_CONVERTER.maybeUnwrap(OptionalValue.create(2L)); + + assertThat(result).isEqualTo(Optional.of(2L)); + } + + @Test + @SuppressWarnings("unchecked") // Test only + public void unwrap_emptyOptionalValue() { + Optional result = (Optional) CEL_VALUE_CONVERTER.maybeUnwrap(OptionalValue.EMPTY); + + assertThat(result).isEqualTo(Optional.empty()); + } +} diff --git a/common/src/test/java/dev/cel/common/values/CombinedCelValueConverterTest.java b/common/src/test/java/dev/cel/common/values/CombinedCelValueConverterTest.java new file mode 100644 index 000000000..8574587bc --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/CombinedCelValueConverterTest.java @@ -0,0 +1,112 @@ +// 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.values; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import java.util.Map; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CombinedCelValueConverterTest { + + @Test + public void toRuntimeValue_delegatesToUnderlyingConverters() { + CustomConverter converter1 = new CustomConverter("target1", "replacement1"); + CustomConverter converter2 = new CustomConverter("target2", "replacement2"); + CelValueConverter combined = + CombinedCelValueConverter.combine(ImmutableList.of(converter1, converter2)); + + assertThat(combined.toRuntimeValue("target1")).isEqualTo("replacement1"); + assertThat(combined.toRuntimeValue("target2")).isEqualTo("replacement2"); + assertThat(combined.toRuntimeValue("unhandled")).isEqualTo("unhandled"); + } + + @Test + public void maybeUnwrap_delegatesToUnderlyingConverters() { + CustomConverter converter1 = new CustomConverter("target1", "replacement1"); + CustomConverter converter2 = new CustomConverter("target2", "replacement2"); + CelValueConverter combined = + CombinedCelValueConverter.combine(ImmutableList.of(converter1, converter2)); + + assertThat(combined.maybeUnwrap("replacement1")).isEqualTo("target1"); + assertThat(combined.maybeUnwrap("replacement2")).isEqualTo("target2"); + assertThat(combined.maybeUnwrap("unhandled")).isEqualTo("unhandled"); + } + + @Test + public void combinedCelValueProvider_returnsCombinedConverter() { + CustomConverter converter1 = new CustomConverter("target1", "replacement1"); + CustomConverter converter2 = new CustomConverter("target2", "replacement2"); + CustomProvider provider1 = new CustomProvider(converter1); + CustomProvider provider2 = new CustomProvider(converter2); + + CombinedCelValueProvider combinedProvider = + CombinedCelValueProvider.combine(provider1, provider2); + CelValueConverter combinedConverter = combinedProvider.celValueConverter(); + + assertThat(combinedConverter).isInstanceOf(CombinedCelValueConverter.class); + assertThat(combinedConverter.toRuntimeValue("target1")).isEqualTo("replacement1"); + assertThat(combinedConverter.toRuntimeValue("target2")).isEqualTo("replacement2"); + } + + private static class CustomConverter extends CelValueConverter { + private final String target; + private final String replacement; + + private CustomConverter(String target, String replacement) { + this.target = target; + this.replacement = replacement; + } + + @Override + public Object toRuntimeValue(Object value) { + if (value.equals(target)) { + return replacement; + } + return value; + } + + @Override + public Object maybeUnwrap(Object value) { + if (value.equals(replacement)) { + return target; + } + return value; + } + } + + private static class CustomProvider implements CelValueProvider { + private final CelValueConverter converter; + + private CustomProvider(CelValueConverter converter) { + this.converter = converter; + } + + @Override + public Optional newValue(String structType, Map fields) { + return Optional.empty(); + } + + @Override + public CelValueConverter celValueConverter() { + return converter; + } + } +} diff --git a/common/src/test/java/dev/cel/common/values/ErrorValueTest.java b/common/src/test/java/dev/cel/common/values/ErrorValueTest.java new file mode 100644 index 000000000..a6a4edb66 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/ErrorValueTest.java @@ -0,0 +1,47 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.common.types.SimpleType; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class ErrorValueTest { + @Test + public void errorValue_construct() { + IllegalArgumentException exception = new IllegalArgumentException("test"); + ErrorValue opaqueValue = ErrorValue.create(0L, exception); + + assertThat(opaqueValue.value()).isEqualTo(exception); + assertThat(opaqueValue.isZeroValue()).isFalse(); + } + + @Test + public void create_nullValue_throws() { + assertThrows(NullPointerException.class, () -> ErrorValue.create(0L, null)); + } + + @Test + public void celTypeTest() { + ErrorValue value = ErrorValue.create(0L, new IllegalArgumentException("test")); + + assertThat(value.celType()).isEqualTo(SimpleType.ERROR); + } +} diff --git a/common/src/test/java/dev/cel/common/values/NullValueTest.java b/common/src/test/java/dev/cel/common/values/NullValueTest.java new file mode 100644 index 000000000..a5bafe837 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/NullValueTest.java @@ -0,0 +1,39 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.types.SimpleType; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class NullValueTest { + + @Test + public void nullValueTest() { + assertThat(NullValue.NULL_VALUE.value()).isEqualTo(NullValue.NULL_VALUE); + assertThat(NullValue.NULL_VALUE.isZeroValue()).isTrue(); + } + + @Test + public void celTypeTest() { + NullValue value = NullValue.NULL_VALUE; + + assertThat(value.celType()).isEqualTo(SimpleType.NULL_TYPE); + } +} diff --git a/common/src/test/java/dev/cel/common/values/OpaqueValueTest.java b/common/src/test/java/dev/cel/common/values/OpaqueValueTest.java new file mode 100644 index 000000000..326572842 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/OpaqueValueTest.java @@ -0,0 +1,223 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.Immutable; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.OpaqueType; +import java.util.Map; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class OpaqueValueTest { + @Test + public void opaqueValue_construct() { + OpaqueValue opaqueValue = OpaqueValue.create("opaque_type_name", "test"); + + assertThat(opaqueValue.value()).isEqualTo("test"); + assertThat(opaqueValue.isZeroValue()).isFalse(); + assertThat(opaqueValue.celType()).isEqualTo(OpaqueType.create("opaque_type_name")); + } + + @Test + public void create_nullValue_throws() { + assertThrows(NullPointerException.class, () -> OpaqueValue.create("opaque_type_name", null)); + } + + private static final OpaqueType CUSTOM_OPAQUE_TYPE = OpaqueType.create("custom_opaque_type"); + + private static final CelTypeProvider CUSTOM_OPAQUE_TYPE_PROVIDER = + new CelTypeProvider() { + @Override + public ImmutableList types() { + return ImmutableList.of(CUSTOM_OPAQUE_TYPE); + } + + @Override + public Optional findType(String typeName) { + return typeName.equals(CUSTOM_OPAQUE_TYPE.name()) + ? Optional.of(CUSTOM_OPAQUE_TYPE) + : Optional.empty(); + } + }; + + private static final CelValueProvider CUSTOM_OPAQUE_VALUE_PROVIDER = + new CelValueProvider() { + @Override + public Optional newValue(String structType, Map fields) { + return Optional.empty(); + } + + @Override + public CelValueConverter celValueConverter() { + return new CelValueConverter() { + @Override + public Object toRuntimeValue(Object value) { + if (value instanceof CustomOpaqueObject) { + CustomOpaqueObject customOpaqueObject = (CustomOpaqueObject) value; + return new CelCustomOpaqueValue(customOpaqueObject); + } + return super.toRuntimeValue(value); + } + }; + } + }; + + private static final CelValueProvider WRAPPED_CUSTOM_OPAQUE_VALUE_PROVIDER = + new CelValueProvider() { + @Override + public Optional newValue(String structType, Map fields) { + return Optional.empty(); + } + + @Override + public CelValueConverter celValueConverter() { + return new CelValueConverter() { + @Override + public Object toRuntimeValue(Object value) { + if (value instanceof CustomOpaqueObject) { + CustomOpaqueObject customOpaqueObject = (CustomOpaqueObject) value; + return OpaqueValue.create(CUSTOM_OPAQUE_TYPE.name(), customOpaqueObject); + } + return super.toRuntimeValue(value); + } + }; + } + }; + + @Immutable + private static class CustomOpaqueObject { + private final String value; + + CustomOpaqueObject(String value) { + this.value = value; + } + + String getValue() { + return value; + } + } + + @Immutable + private static class CelCustomOpaqueValue extends OpaqueValue { + private final CustomOpaqueObject obj; + + CelCustomOpaqueValue(CustomOpaqueObject obj) { + this.obj = obj; + } + + @Override + public CustomOpaqueObject value() { + return obj; + } + + @Override + public OpaqueType celType() { + return CUSTOM_OPAQUE_TYPE; + } + } + + @Test + public void evaluate_customOpaqueValue_asVariable() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .addVar("opaque_var", CUSTOM_OPAQUE_TYPE) + .setTypeProvider(CUSTOM_OPAQUE_TYPE_PROVIDER) + .setValueProvider(CUSTOM_OPAQUE_VALUE_PROVIDER) + .build(); + CelAbstractSyntaxTree ast = cel.compile("opaque_var").getAst(); + + CustomOpaqueObject rawValue = new CustomOpaqueObject("hello"); + Object result = cel.createProgram(ast).eval(ImmutableMap.of("opaque_var", rawValue)); + + assertThat(result).isInstanceOf(CustomOpaqueObject.class); + assertThat(((CustomOpaqueObject) result).getValue()).isEqualTo("hello"); + } + + @Test + public void evaluate_typeOfCustomOpaqueValue() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .addVar("opaque_var", CUSTOM_OPAQUE_TYPE) + .setTypeProvider(CUSTOM_OPAQUE_TYPE_PROVIDER) + .setValueProvider(CUSTOM_OPAQUE_VALUE_PROVIDER) + .build(); + CelAbstractSyntaxTree ast = cel.compile("type(opaque_var) == custom_opaque_type").getAst(); + + CustomOpaqueObject rawValue = new CustomOpaqueObject("hello"); + Object result = cel.createProgram(ast).eval(ImmutableMap.of("opaque_var", rawValue)); + + assertThat(result).isEqualTo(true); + } + + @Test + public void evaluate_typeOfCustomOpaqueValue_wrapped() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .addVar("opaque_var", CUSTOM_OPAQUE_TYPE) + .setTypeProvider(CUSTOM_OPAQUE_TYPE_PROVIDER) + .setValueProvider(WRAPPED_CUSTOM_OPAQUE_VALUE_PROVIDER) + .build(); + CelAbstractSyntaxTree ast = cel.compile("type(opaque_var) == custom_opaque_type").getAst(); + + CustomOpaqueObject rawValue = new CustomOpaqueObject("hello"); + Object result = cel.createProgram(ast).eval(ImmutableMap.of("opaque_var", rawValue)); + + assertThat(result).isEqualTo(true); + } + + @Immutable + private static class SelfReturningOpaqueObject extends OpaqueValue { + SelfReturningOpaqueObject() {} + + @Override + public Object value() { + return this; + } + + @Override + public OpaqueType celType() { + return CUSTOM_OPAQUE_TYPE; + } + } + + @Test + public void evaluate_selfReturningOpaqueValue_noConverter() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .addVar("opaque_var", CUSTOM_OPAQUE_TYPE) + .setTypeProvider(CUSTOM_OPAQUE_TYPE_PROVIDER) + .build(); + CelAbstractSyntaxTree ast = cel.compile("type(opaque_var) == custom_opaque_type").getAst(); + + SelfReturningOpaqueObject rawValue = new SelfReturningOpaqueObject(); + Object result = cel.createProgram(ast).eval(ImmutableMap.of("opaque_var", rawValue)); + + assertThat(result).isEqualTo(true); + } +} + diff --git a/common/src/test/java/dev/cel/common/values/OptionalValueTest.java b/common/src/test/java/dev/cel/common/values/OptionalValueTest.java new file mode 100644 index 000000000..f00954e3d --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/OptionalValueTest.java @@ -0,0 +1,180 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.types.CelType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import java.util.NoSuchElementException; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class OptionalValueTest { + + @Test + public void emptyOptional() { + OptionalValue optionalValue = OptionalValue.EMPTY; + + assertThat(optionalValue.isZeroValue()).isTrue(); + NoSuchElementException exception = + assertThrows(NoSuchElementException.class, optionalValue::value); + assertThat(exception).hasMessageThat().isEqualTo("No value present"); + } + + @Test + public void optionalValue_selectEmpty() { + OptionalValue optionalValue = OptionalValue.EMPTY.select("bogus"); + + assertThat(optionalValue).isEqualTo(OptionalValue.EMPTY); + assertThat(optionalValue.isZeroValue()).isTrue(); + } + + @Test + public void optionalValue_construct() { + OptionalValue optionalValue = OptionalValue.create(1L); + + assertThat(optionalValue.value()).isEqualTo(1L); + assertThat(optionalValue.isZeroValue()).isFalse(); + } + + @Test + public void optSelectField_map_success() { + Long one = 1L; + String hello = "hello"; + ImmutableMap mapValue = ImmutableMap.of(one, hello); + OptionalValue, Long> optionalValueContainingMap = + OptionalValue.create(mapValue); + + assertThat(optionalValueContainingMap.select(one)).isEqualTo(OptionalValue.create(hello)); + } + + @Test + public void optSelectField_map_returnsEmpty() { + Long one = 1L; + String hello = "hello"; + ImmutableMap mapValue = ImmutableMap.of(one, hello); + OptionalValue, Object> optionalValueContainingMap = + OptionalValue.create(mapValue); + + assertThat(optionalValueContainingMap.select(NullValue.NULL_VALUE)) + .isEqualTo(OptionalValue.EMPTY); + } + + @Test + public void optSelectField_struct_success() { + CelCustomStruct celCustomStruct = new CelCustomStruct(5L); + OptionalValue optionalValueContainingStruct = + OptionalValue.create(celCustomStruct); + + assertThat(optionalValueContainingStruct.select("data")).isEqualTo(OptionalValue.create(5L)); + } + + @Test + public void optSelectField_struct_returnsEmpty() { + CelCustomStruct celCustomStruct = new CelCustomStruct(5L); + OptionalValue optionalValueContainingStruct = + OptionalValue.create(celCustomStruct); + + assertThat(optionalValueContainingStruct.select("bogus")).isEqualTo(OptionalValue.EMPTY); + } + + @Test + @TestParameters("{key: 1, expectedResult: true}") + @TestParameters("{key: 100, expectedResult: false}") + public void findField_map_success(long key, boolean expectedResult) { + Long one = 1L; + String hello = "hello"; + ImmutableMap mapValue = ImmutableMap.of(one, hello); + OptionalValue, Long> optionalValueContainingMap = + OptionalValue.create(mapValue); + + assertThat(optionalValueContainingMap.find(key).isPresent()).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{field: 'data', expectedResult: true}") + @TestParameters("{field: 'bogus', expectedResult: false}") + public void findField_struct_success(String field, boolean expectedResult) { + CelCustomStruct celCustomStruct = new CelCustomStruct(5L); + OptionalValue optionalValueContainingStruct = + OptionalValue.create(celCustomStruct); + + assertThat(optionalValueContainingStruct.find(field).isPresent()).isEqualTo(expectedResult); + } + + @Test + public void findField_onEmptyOptional() { + assertThat(OptionalValue.EMPTY.find("bogus")).isEmpty(); + } + + @Test + public void create_nullValue_throws() { + assertThrows(NullPointerException.class, () -> OptionalValue.create(null)); + } + + @Test + public void celTypeTest() { + OptionalValue value = OptionalValue.EMPTY; + + assertThat(value.celType()).isEqualTo(OptionalType.create(SimpleType.DYN)); + } + + @SuppressWarnings("Immutable") // Test only + private static class CelCustomStruct extends StructValue { + private final long data; + + @Override + public Long value() { + return data; + } + + @Override + public boolean isZeroValue() { + return data == 0; + } + + @Override + public CelType celType() { + return StructTypeReference.create("customStruct"); + } + + @Override + public Long select(String field) { + return find(field).get(); + } + + @Override + public Optional find(String field) { + if (field.equals("data")) { + return Optional.of(value()); + } + + return Optional.empty(); + } + + private CelCustomStruct(long data) { + this.data = data; + } + } +} diff --git a/common/src/test/java/dev/cel/common/values/ProtoCelValueConverterTest.java b/common/src/test/java/dev/cel/common/values/ProtoCelValueConverterTest.java new file mode 100644 index 000000000..17c012db7 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/ProtoCelValueConverterTest.java @@ -0,0 +1,45 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.CelOptions; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class ProtoCelValueConverterTest { + + private static final ProtoCelValueConverter PROTO_CEL_VALUE_CONVERTER = + ProtoCelValueConverter.newInstance( + DefaultDescriptorPool.INSTANCE, + DynamicProto.create(DefaultMessageFactory.INSTANCE), + CelOptions.DEFAULT); + + @Test + public void unwrap_nullValue() { + NullValue nullValue = (NullValue) PROTO_CEL_VALUE_CONVERTER.maybeUnwrap(NullValue.NULL_VALUE); + + // Note: No conversion is attempted. We're using dev.cel.common.values.NullValue.NULL_VALUE as + // the + // sentinel type for CEL's `null`. + assertThat(nullValue).isEqualTo(NullValue.NULL_VALUE); + } +} diff --git a/common/src/test/java/dev/cel/common/values/ProtoLiteCelValueConverterTest.java b/common/src/test/java/dev/cel/common/values/ProtoLiteCelValueConverterTest.java new file mode 100644 index 000000000..3b66171e4 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/ProtoLiteCelValueConverterTest.java @@ -0,0 +1,329 @@ +// Copyright 2025 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.values; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableListMultimap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Multimap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.ExtensionRegistryLite; +import com.google.protobuf.FieldMask; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.MessageLite; +import com.google.protobuf.StringValue; +import com.google.protobuf.TextFormat; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.internal.CelLiteDescriptorPool; +import dev.cel.common.internal.DefaultLiteDescriptorPool; +import dev.cel.common.values.ProtoLiteCelValueConverter.MessageFields; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypesCelDescriptor; +import java.time.Instant; +import java.util.LinkedHashMap; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class ProtoLiteCelValueConverterTest { + private static final CelLiteDescriptorPool DESCRIPTOR_POOL = + DefaultLiteDescriptorPool.newInstance( + ImmutableSet.of(TestAllTypesCelDescriptor.getDescriptor())); + + private static final ProtoLiteCelValueConverter PROTO_LITE_CEL_VALUE_CONVERTER = + ProtoLiteCelValueConverter.newInstance(DESCRIPTOR_POOL); + + @Test + public void + fromProtoMessageToCelValue_withTestMessage_convertsToProtoMessageLiteValueFromProtoMessage() { + ProtoMessageLiteValue protoMessageLiteValue = + (ProtoMessageLiteValue) + PROTO_LITE_CEL_VALUE_CONVERTER.toRuntimeValue(TestAllTypes.getDefaultInstance()); + + assertThat(protoMessageLiteValue.value()).isEqualTo(TestAllTypes.getDefaultInstance()); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum WellKnownProtoTestCase { + BOOL(BoolValue.of(true), true), + BYTES(BytesValue.of(ByteString.copyFromUtf8("test")), CelByteString.copyFromUtf8("test")), + FLOAT(FloatValue.of(1.0f), 1.0d), + DOUBLE(DoubleValue.of(1.0), 1.0d), + INT32(Int32Value.of(1), 1L), + INT64(Int64Value.of(1L), 1L), + STRING(StringValue.of("test"), "test"), + + DURATION( + Duration.newBuilder().setSeconds(10).setNanos(50).build(), + java.time.Duration.ofSeconds(10, 50)), + TIMESTAMP( + Timestamp.newBuilder().setSeconds(1678886400L).setNanos(123000000).build(), + Instant.ofEpochSecond(1678886400L, 123000000)), + UINT32(UInt32Value.of(1), UnsignedLong.valueOf(1)), + UINT64(UInt64Value.of(1L), UnsignedLong.valueOf(1L)), + ; + + private final MessageLite msg; + private final Object value; + + WellKnownProtoTestCase(MessageLite msg, Object value) { + this.msg = msg; + this.value = value; + } + } + + @Test + public void fromProtoMessageToCelValue_withWellKnownProto_convertsToPrimitivesFromProtoMessage( + @TestParameter WellKnownProtoTestCase testCase) { + Object adaptedValue = PROTO_LITE_CEL_VALUE_CONVERTER.toRuntimeValue(testCase.msg); + + assertThat(adaptedValue).isEqualTo(testCase.value); + } + + @Test + public void fromProtoMessageToCelValue_fieldMask_returnsProtoMessageLiteValue() { + FieldMask fieldMask = FieldMask.newBuilder().addPaths("foo").addPaths("bar").build(); + + Object adaptedValue = PROTO_LITE_CEL_VALUE_CONVERTER.toRuntimeValue(fieldMask); + + assertThat(adaptedValue).isInstanceOf(ProtoMessageLiteValue.class); + assertThat(((ProtoMessageLiteValue) adaptedValue).select("paths")) + .isEqualTo(ImmutableList.of("foo", "bar")); + } + + /** Test cases for repeated_int64: 1L,2L,3L */ + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum RepeatedFieldBytesTestCase { + PACKED(new byte[] {(byte) 0x82, 0x2, 0x3, 0x1, 0x2, 0x3}), + NON_PACKED(new byte[] {(byte) 0x80, 0x2, 0x1, (byte) 0x80, 0x2, 0x2, (byte) 0x80, 0x2, 0x3}), + // 1L is not packed, but 2L and 3L are + MIXED(new byte[] {(byte) 0x80, 0x2, 0x1, (byte) 0x82, 0x2, 0x2, 0x2, 0x3}); + + private final byte[] bytes; + + RepeatedFieldBytesTestCase(byte[] bytes) { + this.bytes = bytes; + } + } + + @Test + public void readAllFields_repeatedFields_packedBytesCombinations( + @TestParameter RepeatedFieldBytesTestCase testCase) throws Exception { + MessageFields fields = + PROTO_LITE_CEL_VALUE_CONVERTER.readAllFields( + testCase.bytes, "cel.expr.conformance.proto3.TestAllTypes"); + + assertThat(fields.values()).containsExactly("repeated_int64", ImmutableList.of(1L, 2L, 3L)); + } + + /** + * Unknown test with the following hypothetical fields: + * + * 
{@code
+   * message TestAllTypes {
+   *   int64 single_int64_unknown = 2500;
+   *   fixed32 single_fixed32_unknown = 2501;
+   *   fixed64 single_fixed64_unknown = 2502;
+   *   string single_string_unknown = 2503;
+   *   repeated int64 repeated_int64_unknown = 2504;
+   *   map map_string_int64_unknown = 2505;
+   * }
+   * }
+ */ + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum UnknownFieldsTestCase { + INT64(new byte[] {-96, -100, 1, 1}, "2500: 1", ImmutableListMultimap.of(2500, 1L)), + FIXED32( + new byte[] {-83, -100, 1, 2, 0, 0, 0}, + "2501: 0x00000002", + ImmutableListMultimap.of(2501, 2)), + FIXED64( + new byte[] {-79, -100, 1, 3, 0, 0, 0, 0, 0, 0, 0}, + "2502: 0x0000000000000003", + ImmutableListMultimap.of(2502, 3L)), + STRING( + new byte[] {-70, -100, 1, 11, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100}, + "2503: \"Hello world\"", + ImmutableListMultimap.of(2503, ByteString.copyFromUtf8("Hello world"))), + REPEATED_INT64( + new byte[] {-62, -100, 1, 2, 4, 5}, + "2504: \"\\004\\005\"", + ImmutableListMultimap.of(2504, ByteString.copyFrom(new byte[] {4, 5}))), + MAP_STRING_INT64( + new byte[] { + -54, -100, 1, 7, 10, 3, 102, 111, 111, 16, 4, -54, -100, 1, 7, 10, 3, 98, 97, 114, 16, 5 + }, + "2505: {\n" + + " 1: \"foo\"\n" + + " 2: 4\n" + + "}\n" + + "2505: {\n" + + " 1: \"bar\"\n" + + " 2: 5\n" + + "}", + ImmutableListMultimap.of( + 2505, + ByteString.copyFromUtf8("\n\003foo\020\004"), + 2505, + ByteString.copyFromUtf8("\n\003bar\020\005"))); + + private final byte[] bytes; + private final String formattedOutput; + private final Multimap unknownMap; + + UnknownFieldsTestCase( + byte[] bytes, String formattedOutput, Multimap unknownMap) { + this.bytes = bytes; + this.formattedOutput = formattedOutput; + this.unknownMap = unknownMap; + } + } + + @Test + public void unknowns_repeatedEncodedBytes_allRecordsKeptWithKeysSorted() throws Exception { + // 2500: 2 + // 2504: \"\\004\\005\"" + // 2501: 0x00000002 + // 2500: 1 + byte[] bytes = + new byte[] { + -96, -100, 1, 2, // keep + -62, -100, 1, 2, 4, 5, // keep + -83, -100, 1, 2, 0, 0, 0, // keep + -96, -100, 1, 1 // keep + }; + + MessageFields messageFields = + PROTO_LITE_CEL_VALUE_CONVERTER.readAllFields( + bytes, "cel.expr.conformance.proto3.TestAllTypes"); + + assertThat(messageFields.values()).isEmpty(); + assertThat(messageFields.unknowns()) + .containsExactly( + 2500, 2L, 2500, 1L, 2501, 2, 2504, ByteString.copyFrom(new byte[] {0x04, 0x05})) + .inOrder(); + } + + @Test + public void readAllFields_unknownFields(@TestParameter UnknownFieldsTestCase testCase) + throws Exception { + TestAllTypes parsedMsg = + TestAllTypes.parseFrom(testCase.bytes, ExtensionRegistryLite.getEmptyRegistry()); + + MessageFields messageFields = + PROTO_LITE_CEL_VALUE_CONVERTER.readAllFields( + testCase.bytes, "cel.expr.conformance.proto3.TestAllTypes"); + + assertThat(messageFields.values()).isEmpty(); + assertThat(messageFields.unknowns()).containsExactlyEntriesIn(testCase.unknownMap).inOrder(); + assertThat(TextFormat.printer().printToString(parsedMsg).trim()) + .isEqualTo(testCase.formattedOutput); + } + + /** + * Tests the following message: + * + * 
{@code
+   * TestAllTypes.newBuilder()
+   *     // Unknowns
+   *     .setSingleInt64Unknown(1L)
+   *     .setSingleFixed32Unknown(2)
+   *     .setSingleFixed64Unknown(3L)
+   *     .setSingleStringUnknown("Hello world")
+   *     .addAllRepeatedInt64Unknown(ImmutableList.of(4L, 5L))
+   *     .putMapStringInt64Unknown("foo", 4L)
+   *     .putMapStringInt64Unknown("bar", 5L)
+   *     // Known values
+   *     .putMapBoolDouble(true, 1.5d)
+   *     .putMapBoolDouble(false, 2.5d)
+   *     .build();
+   * }
+ */ + @Test + @SuppressWarnings("unchecked") + public void readAllFields_unknownFieldsWithValues() throws Exception { + byte[] unknownMessageBytes = { + -70, 4, 11, 8, 1, 17, 0, 0, 0, 0, 0, 0, -8, 63, -70, 4, 11, 8, 0, 17, 0, 0, 0, 0, 0, 0, 4, 64, + -96, -100, 1, 1, -83, -100, 1, 2, 0, 0, 0, -79, -100, 1, 3, 0, 0, 0, 0, 0, 0, 0, -70, -100, 1, + 11, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, -62, -100, 1, 2, 4, 5, -54, -100, 1, + 7, 10, 3, 102, 111, 111, 16, 4, -54, -100, 1, 7, 10, 3, 98, 97, 114, 16, 5 + }; + TestAllTypes parsedMsg = + TestAllTypes.parseFrom(unknownMessageBytes, ExtensionRegistryLite.getEmptyRegistry()); + + MessageFields fields = + PROTO_LITE_CEL_VALUE_CONVERTER.readAllFields( + unknownMessageBytes, "cel.expr.conformance.proto3.TestAllTypes"); + + assertThat(TextFormat.printer().printToString(parsedMsg)) + .isEqualTo( + "map_bool_double {\n" + + " key: false\n" + + " value: 2.5\n" + + "}\n" + + "map_bool_double {\n" + + " key: true\n" + + " value: 1.5\n" + + "}\n" + + "2500: 1\n" + + "2501: 0x00000002\n" + + "2502: 0x0000000000000003\n" + + "2503: \"Hello world\"\n" + + "2504: \"\\004\\005\"\n" + + "2505: {\n" + + " 1: \"foo\"\n" + + " 2: 4\n" + + "}\n" + + "2505: {\n" + + " 1: \"bar\"\n" + + " 2: 5\n" + + "}\n"); + assertThat(fields.values()).containsKey("map_bool_double"); + LinkedHashMap mapBoolDoubleValues = + (LinkedHashMap) fields.values().get("map_bool_double"); + assertThat(mapBoolDoubleValues).containsExactly(true, 1.5d, false, 2.5d).inOrder(); + Multimap unknownValues = fields.unknowns(); + assertThat(unknownValues) + .containsExactly( + 2500, + 1L, + 2501, + 2, + 2502, + 3L, + 2503, + ByteString.copyFromUtf8("Hello world"), + 2504, + ByteString.copyFrom(new byte[] {0x04, 0x05}), + 2505, + ByteString.copyFromUtf8("\n\003foo\020\004"), + 2505, + ByteString.copyFromUtf8("\n\003bar\020\005")) + .inOrder(); + } +} diff --git a/common/src/test/java/dev/cel/common/values/ProtoMessageLiteValueProviderTest.java b/common/src/test/java/dev/cel/common/values/ProtoMessageLiteValueProviderTest.java new file mode 100644 index 000000000..bbe116c80 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/ProtoMessageLiteValueProviderTest.java @@ -0,0 +1,54 @@ +// Copyright 2025 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.values; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.types.StructTypeReference; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypesCelDescriptor; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class ProtoMessageLiteValueProviderTest { + private static final ProtoMessageLiteValueProvider VALUE_PROVIDER = + ProtoMessageLiteValueProvider.newInstance(TestAllTypesCelDescriptor.getDescriptor()); + + @Test + public void newValue_unknownType_returnsEmpty() { + assertThat(VALUE_PROVIDER.newValue("unknownType", ImmutableMap.of())).isEmpty(); + } + + @Test + public void newValue_emptyFields_success() { + Optional value = + VALUE_PROVIDER.newValue("cel.expr.conformance.proto3.TestAllTypes", ImmutableMap.of()); + ProtoMessageLiteValue protoMessageLiteValue = (ProtoMessageLiteValue) value.get(); + + assertThat(protoMessageLiteValue.value()).isEqualTo(TestAllTypes.getDefaultInstance()); + assertThat(protoMessageLiteValue.isZeroValue()).isTrue(); + assertThat(protoMessageLiteValue.celType()) + .isEqualTo(StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes")); + } + + @Test + public void getProtoLiteCelValueConverter() { + assertThat(VALUE_PROVIDER.protoCelValueConverter()).isNotNull(); + } +} diff --git a/common/src/test/java/dev/cel/common/values/ProtoMessageLiteValueTest.java b/common/src/test/java/dev/cel/common/values/ProtoMessageLiteValueTest.java new file mode 100644 index 000000000..dbfb55cf9 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/ProtoMessageLiteValueTest.java @@ -0,0 +1,256 @@ +// Copyright 2025 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.values; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Any; +import com.google.protobuf.ByteString; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.internal.CelLiteDescriptorPool; +import dev.cel.common.internal.DefaultLiteDescriptorPool; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedEnum; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedMessage; +import dev.cel.expr.conformance.proto3.TestAllTypesCelDescriptor; +import java.time.Duration; +import java.time.Instant; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class ProtoMessageLiteValueTest { + private static final CelLiteDescriptorPool DESCRIPTOR_POOL = + DefaultLiteDescriptorPool.newInstance( + ImmutableSet.of(TestAllTypesCelDescriptor.getDescriptor())); + + private static final ProtoLiteCelValueConverter PROTO_LITE_CEL_VALUE_CONVERTER = + ProtoLiteCelValueConverter.newInstance(DESCRIPTOR_POOL); + + @Test + public void create_withEmptyMessage() { + ProtoMessageLiteValue messageLiteValue = + ProtoMessageLiteValue.create( + TestAllTypes.getDefaultInstance(), + "cel.expr.conformance.proto3.TestAllTypes", + PROTO_LITE_CEL_VALUE_CONVERTER); + + assertThat(messageLiteValue.value()).isEqualTo(TestAllTypes.getDefaultInstance()); + assertThat(messageLiteValue.isZeroValue()).isTrue(); + } + + @Test + public void create_withPopulatedMessage() { + ProtoMessageLiteValue messageLiteValue = + ProtoMessageLiteValue.create( + TestAllTypes.newBuilder().setSingleInt64(1L).build(), + "cel.expr.conformance.proto3.TestAllTypes", + PROTO_LITE_CEL_VALUE_CONVERTER); + + assertThat(messageLiteValue.value()) + .isEqualTo(TestAllTypes.newBuilder().setSingleInt64(1L).build()); + assertThat(messageLiteValue.isZeroValue()).isFalse(); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum SelectFieldTestCase { + BOOL("single_bool", true), + INT32("single_int32", 4L), + INT64("single_int64", 5L), + SINT32("single_sint32", 1L), + SINT64("single_sint64", 2L), + UINT32("single_uint32", UnsignedLong.valueOf(1L)), + UINT64("single_uint64", UnsignedLong.MAX_VALUE), + FLOAT("single_float", 1.5d), + DOUBLE("single_double", 2.5d), + FIXED32("single_fixed32", 20), + SFIXED32("single_sfixed32", 30), + FIXED64("single_fixed64", 40), + SFIXED64("single_sfixed64", 50), + STRING("single_string", "test"), + BYTES("single_bytes", CelByteString.of(new byte[] {0x01})), + DURATION("single_duration", Duration.ofSeconds(100)), + TIMESTAMP("single_timestamp", Instant.ofEpochSecond(100)), + INT32_WRAPPER("single_int32_wrapper", 5L), + INT64_WRAPPER("single_int64_wrapper", 10L), + UINT32_WRAPPER("single_uint32_wrapper", UnsignedLong.valueOf(1L)), + UINT64_WRAPPER("single_uint64_wrapper", UnsignedLong.MAX_VALUE), + FLOAT_WRAPPER("single_float_wrapper", 7.5d), + DOUBLE_WRAPPER("single_double_wrapper", 8.5d), + STRING_WRAPPER("single_string_wrapper", "hello"), + BYTES_WRAPPER("single_bytes_wrapper", CelByteString.of(new byte[] {0x02})), + REPEATED_INT64("repeated_int64", ImmutableList.of(5L, 6L)), + REPEATED_UINT64( + "repeated_uint64", ImmutableList.of(UnsignedLong.valueOf(7L), UnsignedLong.valueOf(8L))), + REPEATED_FLOAT("repeated_float", ImmutableList.of(1.5d, 2.5d)), + REPEATED_DOUBLE("repeated_double", ImmutableList.of(3.5d, 4.5d)), + + REPEATED_STRING("repeated_string", ImmutableList.of("foo", "bar")), + + MAP_INT64_INT64("map_int64_int64", ImmutableMap.of(1L, 2L, 3L, 4L)), + + MAP_UINT32_UINT64( + "map_uint32_uint64", + ImmutableMap.of( + UnsignedLong.valueOf(5L), + UnsignedLong.valueOf(6L), + UnsignedLong.valueOf(7L), + UnsignedLong.valueOf(8L))), + + MAP_STRING_STRING("map_string_string", ImmutableMap.of("a", "b")), + + NESTED_ENUM("standalone_enum", 1L); + + private final String fieldName; + private final Object value; + + SelectFieldTestCase(String fieldName, Object value) { + this.fieldName = fieldName; + this.value = value; + } + } + + @Test + public void selectField_success(@TestParameter SelectFieldTestCase testCase) { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder() + .setSingleBool(true) + .setSingleInt32(4) + .setSingleInt64(5L) + .setSingleSint32(1) + .setSingleSint64(2L) + .setSingleUint32(1) + .setSingleUint64(UnsignedLong.MAX_VALUE.longValue()) + .setSingleFixed32(20) + .setSingleSfixed32(30) + .setSingleFixed64(40) + .setSingleSfixed64(50) + .setSingleFloat(1.5f) + .setSingleDouble(2.5d) + .setSingleString("test") + .setSingleBytes(ByteString.copyFrom(new byte[] {0x01})) + .setSingleAny( + Any.pack(DynamicMessage.newBuilder(com.google.protobuf.BoolValue.of(true)).build())) + .setSingleDuration(com.google.protobuf.Duration.newBuilder().setSeconds(100)) + .setSingleTimestamp(Timestamp.newBuilder().setSeconds(100)) + .setSingleInt32Wrapper(Int32Value.of(5)) + .setSingleInt64Wrapper(Int64Value.of(10L)) + .setSingleUint32Wrapper(UInt32Value.of(1)) + .setSingleUint64Wrapper(UInt64Value.of(UnsignedLong.MAX_VALUE.longValue())) + .setSingleStringWrapper(com.google.protobuf.StringValue.of("hello")) + .setSingleFloatWrapper(FloatValue.of(7.5f)) + .setSingleDoubleWrapper(com.google.protobuf.DoubleValue.of(8.5d)) + .setSingleBytesWrapper( + com.google.protobuf.BytesValue.of(ByteString.copyFrom(new byte[] {0x02}))) + .addRepeatedInt64(5L) + .addRepeatedInt64(6L) + .addRepeatedUint64(7L) + .addRepeatedUint64(8L) + .addRepeatedFloat(1.5f) + .addRepeatedFloat(2.5f) + .addRepeatedDouble(3.5d) + .addRepeatedDouble(4.5d) + .addRepeatedString("foo") + .addRepeatedString("bar") + .putMapStringString("a", "b") + .putMapInt64Int64(1L, 2L) + .putMapInt64Int64(3L, 4L) + .putMapUint32Uint64(5, 6L) + .putMapUint32Uint64(7, 8L) + .setStandaloneMessage(NestedMessage.getDefaultInstance()) + .setStandaloneEnum(NestedEnum.BAR) + .build(); + ProtoMessageLiteValue protoMessageValue = + ProtoMessageLiteValue.create( + testAllTypes, + "cel.expr.conformance.proto3.TestAllTypes", + PROTO_LITE_CEL_VALUE_CONVERTER); + + Object selectedValue = protoMessageValue.select(testCase.fieldName); + + assertThat(selectedValue).isEqualTo(testCase.value); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum DefaultValueTestCase { + BOOL("single_bool", false), + INT32("single_int32", 0L), + INT64("single_int64", 0L), + SINT32("single_sint32", 0L), + SINT64("single_sint64", 0L), + UINT32("single_uint32", UnsignedLong.ZERO), + UINT64("single_uint64", UnsignedLong.ZERO), + FIXED32("single_fixed32", 0), + SFIXED32("single_sfixed32", 0), + FIXED64("single_fixed64", 0), + SFIXED64("single_sfixed64", 0), + FLOAT("single_float", 0d), + DOUBLE("single_double", 0d), + STRING("single_string", ""), + BYTES("single_bytes", CelByteString.EMPTY), + DURATION("single_duration", Duration.ZERO), + TIMESTAMP("single_timestamp", Instant.EPOCH), + INT32_WRAPPER("single_int32_wrapper", NullValue.NULL_VALUE), + INT64_WRAPPER("single_int64_wrapper", NullValue.NULL_VALUE), + UINT32_WRAPPER("single_uint32_wrapper", NullValue.NULL_VALUE), + UINT64_WRAPPER("single_uint64_wrapper", NullValue.NULL_VALUE), + FLOAT_WRAPPER("single_float_wrapper", NullValue.NULL_VALUE), + DOUBLE_WRAPPER("single_double_wrapper", NullValue.NULL_VALUE), + STRING_WRAPPER("single_string_wrapper", NullValue.NULL_VALUE), + BYTES_WRAPPER("single_bytes_wrapper", NullValue.NULL_VALUE), + REPEATED_INT64("repeated_int64", ImmutableList.of()), + MAP_INT64_INT64("map_int64_int64", ImmutableMap.of()), + NESTED_ENUM("standalone_enum", 0L), + NESTED_MESSAGE( + "single_nested_message", + ProtoMessageLiteValue.create( + NestedMessage.getDefaultInstance(), + "cel.expr.conformance.proto3.TestAllTypes.NestedMessage", + PROTO_LITE_CEL_VALUE_CONVERTER)); + + private final String fieldName; + private final Object value; + + DefaultValueTestCase(String fieldName, Object value) { + this.fieldName = fieldName; + this.value = value; + } + } + + @Test + public void selectField_defaultValue(@TestParameter DefaultValueTestCase testCase) { + ProtoMessageLiteValue protoMessageValue = + ProtoMessageLiteValue.create( + TestAllTypes.getDefaultInstance(), + "cel.expr.conformance.proto3.TestAllTypes", + PROTO_LITE_CEL_VALUE_CONVERTER); + + Object selectedValue = protoMessageValue.select(testCase.fieldName); + + assertThat(selectedValue).isEqualTo(testCase.value); + } +} diff --git a/common/src/test/java/dev/cel/common/values/ProtoMessageValueProviderTest.java b/common/src/test/java/dev/cel/common/values/ProtoMessageValueProviderTest.java new file mode 100644 index 000000000..ed8fc7b2a --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/ProtoMessageValueProviderTest.java @@ -0,0 +1,229 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.CelDescriptorPool; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.internal.ProtoMessageFactory; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import dev.cel.expr.conformance.proto2.TestAllTypesExtensions; +import java.time.Duration; +import java.time.Instant; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class ProtoMessageValueProviderTest { + + private static final CelDescriptorPool DESCRIPTOR_POOL = + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + ImmutableList.of( + TestAllTypes.getDescriptor().getFile(), TestAllTypesExtensions.getDescriptor()))); + private static final ProtoMessageFactory MESSAGE_FACTORY = + DefaultMessageFactory.create(DESCRIPTOR_POOL); + private static final DynamicProto DYNAMIC_PROTO = DynamicProto.create(MESSAGE_FACTORY); + + @Test + public void newValue_createEmptyProtoMessage() { + ProtoMessageValueProvider protoMessageValueProvider = + ProtoMessageValueProvider.newInstance(CelOptions.DEFAULT, DYNAMIC_PROTO); + + ProtoMessageValue protoMessageValue = + (ProtoMessageValue) + protoMessageValueProvider + .newValue(TestAllTypes.getDescriptor().getFullName(), ImmutableMap.of()) + .get(); + + assertThat(protoMessageValue.isZeroValue()).isTrue(); + } + + @Test + public void newValue_createProtoMessage_fieldsPopulated() { + ProtoMessageValueProvider protoMessageValueProvider = + ProtoMessageValueProvider.newInstance(CelOptions.current().build(), DYNAMIC_PROTO); + + ProtoMessageValue protoMessageValue = + (ProtoMessageValue) + protoMessageValueProvider + .newValue( + TestAllTypes.getDescriptor().getFullName(), + ImmutableMap.of( + "single_int32", + 1, + "single_int64", + 2, + "single_uint32", + 3, + "single_uint64", + 4, + "single_double", + 5.5d, + "single_bool", + true, + "single_string", + "hello", + "single_timestamp", + Instant.ofEpochSecond(50), + "single_duration", + Duration.ofSeconds(100))) + .get(); + + assertThat(protoMessageValue.isZeroValue()).isFalse(); + assertThat(protoMessageValue.select("single_int32")).isEqualTo(1L); + assertThat(protoMessageValue.select("single_int64")).isEqualTo(2L); + assertThat(protoMessageValue.select("single_uint32")).isEqualTo(UnsignedLong.valueOf(3L)); + assertThat(protoMessageValue.select("single_uint64")).isEqualTo(UnsignedLong.valueOf(4L)); + assertThat(protoMessageValue.select("single_double")).isEqualTo(5.5d); + assertThat(protoMessageValue.select("single_bool")).isEqualTo(true); + assertThat(protoMessageValue.select("single_string")).isEqualTo("hello"); + assertThat(protoMessageValue.select("single_timestamp")).isEqualTo(Instant.ofEpochSecond(50)); + assertThat(protoMessageValue.select("single_duration")).isEqualTo(Duration.ofSeconds(100)); + } + + @Test + public void newValue_createProtoMessage_unsignedLongFieldsPopulated() { + ProtoMessageValueProvider protoMessageValueProvider = + ProtoMessageValueProvider.newInstance(CelOptions.DEFAULT, DYNAMIC_PROTO); + + ProtoMessageValue protoMessageValue = + (ProtoMessageValue) + protoMessageValueProvider + .newValue( + TestAllTypes.getDescriptor().getFullName(), + ImmutableMap.of( + "single_uint32", 3, "single_uint64", UnsignedLong.MAX_VALUE.longValue())) + .get(); + + assertThat(protoMessageValue.isZeroValue()).isFalse(); + assertThat(protoMessageValue.select("single_uint32")).isEqualTo(UnsignedLong.valueOf(3L)); + assertThat(protoMessageValue.select("single_uint64")).isEqualTo(UnsignedLong.MAX_VALUE); + } + + @Test + public void newValue_createProtoMessage_wrappersPopulated() { + ProtoMessageValueProvider protoMessageValueProvider = + ProtoMessageValueProvider.newInstance(CelOptions.DEFAULT, DYNAMIC_PROTO); + + ProtoMessageValue protoMessageValue = + (ProtoMessageValue) + protoMessageValueProvider + .newValue( + TestAllTypes.getDescriptor().getFullName(), + ImmutableMap.of( + "single_int32_wrapper", + 1, + "single_int64_wrapper", + 2, + "single_uint32_wrapper", + 3, + "single_uint64_wrapper", + 4, + "single_double_wrapper", + 5.5d, + "single_bool_wrapper", + true, + "single_string_wrapper", + "hello")) + .get(); + + assertThat(protoMessageValue.isZeroValue()).isFalse(); + assertThat(protoMessageValue.select("single_int32_wrapper")).isEqualTo(1L); + assertThat(protoMessageValue.select("single_int32_wrapper")).isEqualTo(1L); + assertThat(protoMessageValue.select("single_int64_wrapper")).isEqualTo(2L); + assertThat(protoMessageValue.select("single_uint32_wrapper")) + .isEqualTo(UnsignedLong.valueOf(3L)); + assertThat(protoMessageValue.select("single_uint64_wrapper")) + .isEqualTo(UnsignedLong.valueOf(4L)); + assertThat(protoMessageValue.select("single_double_wrapper")).isEqualTo(5.5d); + assertThat(protoMessageValue.select("single_bool_wrapper")).isEqualTo(true); + assertThat(protoMessageValue.select("single_string_wrapper")).isEqualTo("hello"); + } + + @Test + public void newValue_createProtoMessage_extensionFieldsPopulated() { + ProtoMessageValueProvider protoMessageValueProvider = + ProtoMessageValueProvider.newInstance(CelOptions.DEFAULT, DYNAMIC_PROTO); + + ProtoMessageValue protoMessageValue = + (ProtoMessageValue) + protoMessageValueProvider + .newValue( + TestAllTypes.getDescriptor().getFullName(), + ImmutableMap.of("cel.expr.conformance.proto2.int32_ext", 1)) + .get(); + + assertThat(protoMessageValue.isZeroValue()).isFalse(); + assertThat(protoMessageValue.select("cel.expr.conformance.proto2.int32_ext")).isEqualTo(1); + } + + @Test + public void newValue_invalidMessageName_returnsEmpty() { + ProtoMessageValueProvider protoMessageValueProvider = + ProtoMessageValueProvider.newInstance(CelOptions.DEFAULT, DYNAMIC_PROTO); + + assertThat(protoMessageValueProvider.newValue("bogus", ImmutableMap.of())).isEmpty(); + } + + @Test + public void newValue_invalidField_throws() { + ProtoMessageValueProvider protoMessageValueProvider = + ProtoMessageValueProvider.newInstance(CelOptions.DEFAULT, DYNAMIC_PROTO); + + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> + protoMessageValueProvider.newValue( + TestAllTypes.getDescriptor().getFullName(), ImmutableMap.of("bogus", 1))); + + assertThat(e) + .hasMessageThat() + .isEqualTo( + "field 'bogus' is not declared in message" + + " 'cel.expr.conformance.proto2.TestAllTypes'"); + } + + @Test + public void newValue_onCombinedProvider() { + CelValueProvider celValueProvider = (structType, fields) -> Optional.empty(); + ProtoMessageValueProvider protoMessageValueProvider = + ProtoMessageValueProvider.newInstance(CelOptions.DEFAULT, DYNAMIC_PROTO); + CelValueProvider combinedProvider = + CombinedCelValueProvider.combine(celValueProvider, protoMessageValueProvider); + + ProtoMessageValue protoMessageValue = + (ProtoMessageValue) + combinedProvider + .newValue( + TestAllTypes.getDescriptor().getFullName(), ImmutableMap.of("single_int32", 1)) + .get(); + + assertThat(protoMessageValue.isZeroValue()).isFalse(); + assertThat(protoMessageValue.select("single_int32")).isEqualTo(1L); + } +} diff --git a/common/src/test/java/dev/cel/common/values/ProtoMessageValueTest.java b/common/src/test/java/dev/cel/common/values/ProtoMessageValueTest.java new file mode 100644 index 000000000..b5c29129b --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/ProtoMessageValueTest.java @@ -0,0 +1,460 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Any; +import com.google.protobuf.ByteString; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.FieldMask; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.CelDescriptorPool; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.types.StructTypeReference; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import dev.cel.expr.conformance.proto2.TestAllTypes.NestedEnum; +import dev.cel.expr.conformance.proto2.TestAllTypes.NestedMessage; +import dev.cel.expr.conformance.proto2.TestAllTypesExtensions; +import java.time.Duration; +import java.time.Instant; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class ProtoMessageValueTest { + + private static final ProtoCelValueConverter PROTO_CEL_VALUE_CONVERTER = + ProtoCelValueConverter.newInstance( + DefaultDescriptorPool.INSTANCE, + DynamicProto.create(DefaultMessageFactory.INSTANCE), + CelOptions.DEFAULT); + + @Test + public void emptyProtoMessage() { + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + TestAllTypes.getDefaultInstance(), + DefaultDescriptorPool.INSTANCE, + PROTO_CEL_VALUE_CONVERTER, + /* enableJsonFieldNames= */ false); + + assertThat(protoMessageValue.value()).isEqualTo(TestAllTypes.getDefaultInstance()); + assertThat(protoMessageValue.isZeroValue()).isTrue(); + } + + @Test + public void constructProtoMessage() { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder().setSingleBool(true).setSingleInt64(5L).build(); + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.value()).isEqualTo(testAllTypes); + assertThat(protoMessageValue.isZeroValue()).isFalse(); + } + + @Test + public void findField_fieldIsSet_fieldExists() { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder() + .setSingleBool(true) + .setSingleInt64(5L) + .addRepeatedInt64(5L) + .build(); + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.find("single_bool")).isPresent(); + assertThat(protoMessageValue.find("single_int64")).isPresent(); + assertThat(protoMessageValue.find("repeated_int64")).isPresent(); + } + + @Test + public void findField_fieldIsUnset_fieldDoesNotExist() { + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + TestAllTypes.getDefaultInstance(), + DefaultDescriptorPool.INSTANCE, + PROTO_CEL_VALUE_CONVERTER, + /* enableJsonFieldNames= */ false); + + assertThat(protoMessageValue.find("single_int32")).isEmpty(); + assertThat(protoMessageValue.find("single_uint64")).isEmpty(); + assertThat(protoMessageValue.find("repeated_int32")).isEmpty(); + } + + @Test + public void findField_fieldIsUndeclared_throwsException() { + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + TestAllTypes.getDefaultInstance(), + DefaultDescriptorPool.INSTANCE, + PROTO_CEL_VALUE_CONVERTER, + /* enableJsonFieldNames= */ false); + + IllegalArgumentException exception = + assertThrows(IllegalArgumentException.class, () -> protoMessageValue.select("bogus")); + assertThat(exception) + .hasMessageThat() + .isEqualTo( + "field 'bogus' is not declared in message" + + " 'cel.expr.conformance.proto2.TestAllTypes'"); + } + + @Test + public void findField_extensionField_success() { + CelDescriptorPool descriptorPool = + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + ImmutableList.of(TestAllTypesExtensions.getDescriptor()))); + TestAllTypes proto2Message = + TestAllTypes.newBuilder().setExtension(TestAllTypesExtensions.int32Ext, 1).build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create(proto2Message, descriptorPool, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.find("cel.expr.conformance.proto2.int32_ext")).isPresent(); + } + + @Test + public void findField_extensionField_throwsWhenDescriptorMissing() { + TestAllTypes proto2Message = + TestAllTypes.newBuilder().setExtension(TestAllTypesExtensions.int32Ext, 1).build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + proto2Message, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + IllegalArgumentException exception = + assertThrows( + IllegalArgumentException.class, + () -> protoMessageValue.select("cel.expr.conformance.proto2.int32_ext")); + assertThat(exception) + .hasMessageThat() + .isEqualTo( + "field 'cel.expr.conformance.proto2.int32_ext' is not declared in message" + + " 'cel.expr.conformance.proto2.TestAllTypes'"); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum SelectFieldTestCase { + // Primitives + BOOL("single_bool", true), + INT32("single_int32", 4L), + INT64("single_int64", 5L), + UINT32("single_uint32", UnsignedLong.valueOf(1L)), + UINT64("single_uint64", UnsignedLong.MAX_VALUE), + FLOAT("single_float", 1.5d), + DOUBLE("single_double", 2.5d), + STRING("single_string", "test"), + BYTES("single_bytes", CelByteString.of(new byte[] {0x01})), + // Well known types + ANY("single_any", true), + DURATION("single_duration", Duration.ofSeconds(100)), + TIMESTAMP("single_timestamp", Instant.ofEpochSecond(100)), + INT32_WRAPPER("single_int32_wrapper", 5L), + INT64_WRAPPER("single_int64_wrapper", 10L), + UINT32_WRAPPER("single_uint32_wrapper", UnsignedLong.valueOf(1L)), + UINT64_WRAPPER("single_uint64_wrapper", UnsignedLong.MAX_VALUE), + FLOAT_WRAPPER("single_float_wrapper", 7.5d), + DOUBLE_WRAPPER("single_double_wrapper", 8.5d), + STRING_WRAPPER("single_string_wrapper", "hello"), + BYTES_WRAPPER("single_bytes_wrapper", CelByteString.of(new byte[] {0x02})), + REPEATED_INT64("repeated_int64", ImmutableList.of(5L)), + MAP_STRING_STRING("map_string_string", ImmutableMap.of("a", "b")), + NESTED_MESSAGE( + "standalone_message", + ProtoMessageValue.create( + NestedMessage.getDefaultInstance(), + DefaultDescriptorPool.INSTANCE, + PROTO_CEL_VALUE_CONVERTER, + /* enableJsonFieldNames= */ false)), + NESTED_ENUM("standalone_enum", 1L); + + private final String fieldName; + private final Object value; + + SelectFieldTestCase(String fieldName, Object value) { + this.fieldName = fieldName; + this.value = value; + } + } + + @Test + public void selectField_success(@TestParameter SelectFieldTestCase testCase) { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder() + .setSingleBool(true) + .setSingleInt32(4) + .setSingleInt64(5L) + .setSingleUint32(1) + .setSingleUint64(UnsignedLong.MAX_VALUE.longValue()) + .setSingleFloat(1.5f) + .setSingleDouble(2.5d) + .setSingleString("test") + .setSingleBytes(ByteString.copyFrom(new byte[] {0x01})) + .setSingleAny( + Any.pack(DynamicMessage.newBuilder(com.google.protobuf.BoolValue.of(true)).build())) + .setSingleDuration(com.google.protobuf.Duration.newBuilder().setSeconds(100)) + .setSingleTimestamp(Timestamp.newBuilder().setSeconds(100)) + .setSingleInt32Wrapper(Int32Value.of(5)) + .setSingleInt64Wrapper(Int64Value.of(10L)) + .setSingleUint32Wrapper(UInt32Value.of(1)) + .setSingleUint64Wrapper(UInt64Value.of(UnsignedLong.MAX_VALUE.longValue())) + .setSingleStringWrapper(com.google.protobuf.StringValue.of("hello")) + .setSingleFloatWrapper(FloatValue.of(7.5f)) + .setSingleDoubleWrapper(com.google.protobuf.DoubleValue.of(8.5d)) + .setSingleBytesWrapper( + com.google.protobuf.BytesValue.of(ByteString.copyFrom(new byte[] {0x02}))) + .addRepeatedInt64(5L) + .putMapStringString("a", "b") + .setStandaloneMessage(NestedMessage.getDefaultInstance()) + .setStandaloneEnum(NestedEnum.BAR) + .build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.select(testCase.fieldName)).isEqualTo(testCase.value); + } + + @Test + public void selectField_dynamicMessage_success() { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder().setSingleInt32Wrapper(Int32Value.of(5)).build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + DynamicMessage.newBuilder(testAllTypes).build(), + DefaultDescriptorPool.INSTANCE, + PROTO_CEL_VALUE_CONVERTER, + /* enableJsonFieldNames= */ false); + + assertThat(protoMessageValue.select("single_int32_wrapper")).isEqualTo(5); + } + + @Test + @TestParameters("{nanos: 1000000001}") + @TestParameters("{nanos: -1000000001}") + public void selectField_timestampNanosOutOfRange_success(int nanos) { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder() + .setSingleTimestamp(Timestamp.newBuilder().setNanos(nanos)) + .build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.select("single_timestamp")) + .isEqualTo(Instant.ofEpochSecond(0, nanos)); + } + + @Test + @TestParameters("{seconds: 0, nanos: 1000000001}") + @TestParameters("{seconds: 0, nanos: -1000000001}") + @TestParameters("{seconds: -10, nanos: 1000000001}") + @TestParameters("{seconds: 10, nanos: -1000000001}") + public void selectField_durationOutOfRange_success(int seconds, int nanos) { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder() + .setSingleDuration( + com.google.protobuf.Duration.newBuilder().setSeconds(seconds).setNanos(nanos)) + .build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.select("single_duration")) + .isEqualTo(Duration.ofSeconds(seconds, nanos)); + } + + @Test + public void selectField_fieldMask_returnsProtoMessageValue() { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder() + .setFieldMask(FieldMask.newBuilder().addPaths("foo").addPaths("bar")) + .build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + Object selected = protoMessageValue.select("field_mask"); + assertThat(selected).isInstanceOf(ProtoMessageValue.class); + assertThat(((ProtoMessageValue) selected).select("paths")) + .isEqualTo(ImmutableList.of("foo", "bar")); + } + + @Test + public void selectField_fixed32_returnsUnsignedLong() { + TestAllTypes testAllTypes = TestAllTypes.newBuilder().setSingleFixed32(1).build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.select("single_fixed32")).isEqualTo(UnsignedLong.valueOf(1L)); + } + + @Test + public void selectField_fixed64_returnsUnsignedLong() { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder().setSingleFixed64(UnsignedLong.MAX_VALUE.longValue()).build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.select("single_fixed64")).isEqualTo(UnsignedLong.MAX_VALUE); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum SelectFieldJsonValueTestCase { + NULL(Value.newBuilder().build(), NullValue.NULL_VALUE), + BOOL(Value.newBuilder().setBoolValue(true).build(), true), + DOUBLE(Value.newBuilder().setNumberValue(4.5d).build(), 4.5d), + STRING(Value.newBuilder().setStringValue("test").build(), "test"), + STRUCT( + Value.newBuilder() + .setStructValue( + Struct.newBuilder() + .putFields("a", Value.newBuilder().setBoolValue(false).build()) + .build()) + .build(), + ImmutableMap.of("a", false)), + LIST( + Value.newBuilder() + .setListValue( + com.google.protobuf.ListValue.newBuilder() + .addValues(Value.newBuilder().setStringValue("test").build()) + .build()) + .build(), + ImmutableList.of("test")); + + private final Value jsonValue; + private final Object value; + + SelectFieldJsonValueTestCase(Value jsonValue, Object value) { + this.jsonValue = jsonValue; + this.value = value; + } + } + + @Test + public void selectField_jsonValue(@TestParameter SelectFieldJsonValueTestCase testCase) { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder().setSingleValue(testCase.jsonValue).build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.select("single_value")).isEqualTo(testCase.value); + } + + @Test + public void selectField_jsonStruct() { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder() + .setSingleStruct( + Struct.newBuilder() + .putFields("a", Value.newBuilder().setBoolValue(false).build()) + .build()) + .build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.select("single_struct")).isEqualTo(ImmutableMap.of("a", false)); + } + + @Test + public void selectField_jsonList() { + TestAllTypes testAllTypes = + TestAllTypes.newBuilder() + .setListValue( + com.google.protobuf.ListValue.newBuilder() + .addValues(Value.newBuilder().setBoolValue(false).build()) + .build()) + .build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, false); + + assertThat(protoMessageValue.select("list_value")).isEqualTo(ImmutableList.of(false)); + } + + @Test + public void selectField_wrapperFieldUnset_returnsNull() { + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + TestAllTypes.getDefaultInstance(), + DefaultDescriptorPool.INSTANCE, + PROTO_CEL_VALUE_CONVERTER, + /* enableJsonFieldNames= */ false); + + assertThat(protoMessageValue.select("single_int64_wrapper")).isEqualTo(NullValue.NULL_VALUE); + } + + @Test + public void celTypeTest() { + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + TestAllTypes.getDefaultInstance(), + DefaultDescriptorPool.INSTANCE, + PROTO_CEL_VALUE_CONVERTER, + /* enableJsonFieldNames= */ false); + + assertThat(protoMessageValue.celType()) + .isEqualTo(StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + } + + @Test + public void findField_jsonName_success() { + TestAllTypes testAllTypes = TestAllTypes.newBuilder().setSingleInt32(42).build(); + + ProtoMessageValue protoMessageValue = + ProtoMessageValue.create( + testAllTypes, DefaultDescriptorPool.INSTANCE, PROTO_CEL_VALUE_CONVERTER, true); + + assertThat(protoMessageValue.find("singleInt32")).isPresent(); + } +} diff --git a/common/src/test/java/dev/cel/common/values/StructValueTest.java b/common/src/test/java/dev/cel/common/values/StructValueTest.java new file mode 100644 index 000000000..978222869 --- /dev/null +++ b/common/src/test/java/dev/cel/common/values/StructValueTest.java @@ -0,0 +1,291 @@ +// Copyright 2023 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.values; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructType; +import java.util.Map; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class StructValueTest { + private static final StructType CUSTOM_STRUCT_TYPE = + StructType.create( + "custom_struct", + ImmutableSet.of("data"), + fieldName -> fieldName.equals("data") ? Optional.of(SimpleType.INT) : Optional.empty()); + private static final CelTypeProvider CUSTOM_STRUCT_TYPE_PROVIDER = + new CelTypeProvider() { + @Override + public ImmutableList types() { + return ImmutableList.of(CUSTOM_STRUCT_TYPE); + } + + @Override + public Optional findType(String typeName) { + return typeName.equals(CUSTOM_STRUCT_TYPE.name()) + ? Optional.of(CUSTOM_STRUCT_TYPE) + : Optional.empty(); + } + }; + + private static final CelValueProvider CUSTOM_STRUCT_VALUE_PROVIDER = + new CelValueProvider() { + @Override + public Optional newValue(String structType, Map fields) { + if (structType.equals(CUSTOM_STRUCT_TYPE.name())) { + return Optional.of(new CelCustomStructValue(fields)); + } + return Optional.empty(); + } + + @Override + public CelValueConverter celValueConverter() { + return new CelValueConverter() { + @Override + public Object toRuntimeValue(Object value) { + if (value instanceof CustomPojo) { + return new CelCustomStructValue((CustomPojo) value); + } + return super.toRuntimeValue(value); + } + }; + } + }; + + @Test + public void emptyStruct() { + CelCustomStructValue celCustomStruct = new CelCustomStructValue(0); + + assertThat(celCustomStruct.value().getData()).isEqualTo(0L); + assertThat(celCustomStruct.isZeroValue()).isTrue(); + } + + @Test + public void constructStruct() { + CelCustomStructValue celCustomStruct = new CelCustomStructValue(5); + + assertThat(celCustomStruct.value().getData()).isEqualTo(5L); + assertThat(celCustomStruct.isZeroValue()).isFalse(); + } + + @Test + public void selectField_success() { + CelCustomStructValue celCustomStruct = new CelCustomStructValue(5); + + assertThat(celCustomStruct.select("data")).isEqualTo(5L); + } + + @Test + public void selectField_nonExistentField_throws() { + CelCustomStructValue celCustomStruct = new CelCustomStructValue(5); + + assertThrows(IllegalArgumentException.class, () -> celCustomStruct.select("bogus")); + } + + @Test + @TestParameters("{fieldName: 'data', expectedResult: true}") + @TestParameters("{fieldName: 'bogus', expectedResult: false}") + public void findField_success(String fieldName, boolean expectedResult) { + CelCustomStructValue celCustomStruct = new CelCustomStructValue(5); + + assertThat(celCustomStruct.find(fieldName).isPresent()).isEqualTo(expectedResult); + } + + @Test + public void celTypeTest() { + CelCustomStructValue value = new CelCustomStructValue(0); + + assertThat(value.celType()).isEqualTo(CUSTOM_STRUCT_TYPE); + } + + @Test + public void evaluate_typeOfCustomStruct() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .addVar("a", CUSTOM_STRUCT_TYPE) + .setTypeProvider(CUSTOM_STRUCT_TYPE_PROVIDER) + .setValueProvider(CUSTOM_STRUCT_VALUE_PROVIDER) + .build(); + CelAbstractSyntaxTree ast = cel.compile("type(a) == custom_struct").getAst(); + + Object result = cel.createProgram(ast).eval(ImmutableMap.of("a", new CelCustomStructValue(20))); + + assertThat(result).isEqualTo(true); + } + + @Test + public void evaluate_usingCustomClass_createNewStruct() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .setTypeProvider(CUSTOM_STRUCT_TYPE_PROVIDER) + .setValueProvider(CUSTOM_STRUCT_VALUE_PROVIDER) + .build(); + CelAbstractSyntaxTree ast = cel.compile("custom_struct{data: 50}").getAst(); + + CustomPojo result = (CustomPojo) cel.createProgram(ast).eval(); + + assertThat(result.getData()).isEqualTo(50); + } + + @Test + public void evaluate_usingCustomClass_asVariable() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .addVar("a", CUSTOM_STRUCT_TYPE) + .setTypeProvider(CUSTOM_STRUCT_TYPE_PROVIDER) + .setValueProvider(CUSTOM_STRUCT_VALUE_PROVIDER) + .build(); + CelAbstractSyntaxTree ast = cel.compile("a").getAst(); + + CustomPojo result = + (CustomPojo) + cel.createProgram(ast).eval(ImmutableMap.of("a", new CelCustomStructValue(10))); + + assertThat(result.getData()).isEqualTo(10); + } + + @Test + public void evaluate_usingCustomClass_asVariableSelectField() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .addVar("a", CUSTOM_STRUCT_TYPE) + .setTypeProvider(CUSTOM_STRUCT_TYPE_PROVIDER) + .setValueProvider(CUSTOM_STRUCT_VALUE_PROVIDER) + .build(); + CelAbstractSyntaxTree ast = cel.compile("a.data").getAst(); + + assertThat(cel.createProgram(ast).eval(ImmutableMap.of("a", new CelCustomStructValue(20)))) + .isEqualTo(20L); + } + + @Test + public void evaluate_usingCustomClass_selectField() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .setTypeProvider(CUSTOM_STRUCT_TYPE_PROVIDER) + .setValueProvider(CUSTOM_STRUCT_VALUE_PROVIDER) + .build(); + CelAbstractSyntaxTree ast = cel.compile("custom_struct{data: 5}.data").getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(5L); + } + + @Test + public void evaluate_usingMultipleProviders_selectFieldFromCustomClass() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .setTypeProvider(CUSTOM_STRUCT_TYPE_PROVIDER) + .setValueProvider( + CombinedCelValueProvider.combine( + ProtoMessageValueProvider.newInstance( + CelOptions.DEFAULT, DynamicProto.create(unused -> Optional.empty())), + CUSTOM_STRUCT_VALUE_PROVIDER)) + .build(); + CelAbstractSyntaxTree ast = cel.compile("custom_struct{data: 5}.data").getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(5L); + } + + // TODO: Bring back evaluate_usingMultipleProviders_selectFieldFromProtobufMessage + // once planner is exposed from factory + + private static class CustomPojo { + private final long data; + + CustomPojo(long data) { + this.data = data; + } + + long getData() { + return data; + } + } + + @SuppressWarnings("Immutable") // Test only + private static class CelCustomStructValue extends StructValue { + + private final CustomPojo pojo; + + @Override + public CustomPojo value() { + return pojo; + } + + @Override + public boolean isZeroValue() { + return pojo.getData() == 0; + } + + @Override + public CelType celType() { + return CUSTOM_STRUCT_TYPE; + } + + @Override + public Object select(String field) { + return find(field) + .orElseThrow(() -> new IllegalArgumentException("Invalid field name: " + field)); + } + + @Override + public Optional find(String field) { + if (field.equals("data")) { + return Optional.of(pojo.getData()); + } + + return Optional.empty(); + } + + private CelCustomStructValue(Map fields) { + this((long) fields.get("data")); + } + + private CelCustomStructValue(long data) { + this.pojo = new CustomPojo(data); + } + + private CelCustomStructValue(CustomPojo pojo) { + this.pojo = pojo; + } + } +} diff --git a/common/src/test/resources/BUILD.bazel b/common/src/test/resources/BUILD.bazel new file mode 100644 index 000000000..68b07702e --- /dev/null +++ b/common/src/test/resources/BUILD.bazel @@ -0,0 +1,46 @@ +load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library") +load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//common/src/test/java/dev/cel/common/internal:__pkg__", + ], +) + +filegroup( + name = "resources", + srcs = [ + "value.fds", + "value.textproto", + ], +) + +proto_library( + name = "default_instance_message_test_protos", + srcs = [ + "enum_conflicting_name.proto", + "message_conflicting_name.proto", + "proto_java_api_version_1.proto", + "proto_without_java_opts.proto", + ], +) + +java_proto_library( + name = "default_instance_message_test_protos_java_proto", + deps = [":default_instance_message_test_protos"], +) + +proto_library( + name = "service_conflicting_name_proto", + srcs = [ + "service_conflicting_name.proto", + ], +) + +java_proto_library( + name = "service_conflicting_name_java_proto", + deps = [":service_conflicting_name_proto"], +) diff --git a/common/src/test/resources/enum_conflicting_name.proto b/common/src/test/resources/enum_conflicting_name.proto new file mode 100644 index 000000000..e95e323c0 --- /dev/null +++ b/common/src/test/resources/enum_conflicting_name.proto @@ -0,0 +1,26 @@ +// Copyright 2022 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. + +// Test proto3 message with missing java_option flags and conflicting java class +// name. + +syntax = "proto3"; + +package dev.cel.common.testdata; + +message MessageInEnumConflictingName {} + +enum EnumConflictingName { + TEST_UNKNOWN = 0; +} \ No newline at end of file diff --git a/common/src/test/resources/message_conflicting_name.proto b/common/src/test/resources/message_conflicting_name.proto new file mode 100644 index 000000000..b4d8963e8 --- /dev/null +++ b/common/src/test/resources/message_conflicting_name.proto @@ -0,0 +1,32 @@ +// Copyright 2022 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. + +// Test proto3 message with missing java_option flags and conflicting java class +// name. + +syntax = "proto3"; + +package dev.cel.common.testdata; + +// Conflicting class name. message_conflicting_name file name is +// converted into this pascal cased message name. In this case, "OuterClass" is +// prepended in the generated class: +// ProtoConflictingNameOuterClass.ProtoConflictingName +message MessageConflictingName { + message NestedMessage {} +} + +// This message doesn't conflict but because there's another message with a +// conflicting name, "OuterClass" is prepended anyways. +message MessageInConflictingNameClass {} \ No newline at end of file diff --git a/common/src/test/resources/proto_java_api_version_1.proto b/common/src/test/resources/proto_java_api_version_1.proto new file mode 100644 index 000000000..a27c3c4e6 --- /dev/null +++ b/common/src/test/resources/proto_java_api_version_1.proto @@ -0,0 +1,21 @@ +// Copyright 2022 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. + +syntax = "proto2"; + +package dev.cel.common.testdata; + +option java_package = "dev.cel.common.testdata"; + +message Proto2JavaVersion1Message {} \ No newline at end of file diff --git a/common/src/test/resources/proto_without_java_opts.proto b/common/src/test/resources/proto_without_java_opts.proto new file mode 100644 index 000000000..3769fe114 --- /dev/null +++ b/common/src/test/resources/proto_without_java_opts.proto @@ -0,0 +1,25 @@ +// Copyright 2022 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. + +// Test proto3 message with missing java_option flags. Proto compiler has +// varying behavior for generating java class depending on what java options are +// set. + +syntax = "proto3"; + +package dev.cel.common.testdata; + +message MessageWithoutJavaOpts { + message NestedMessage {} +} diff --git a/common/src/test/resources/service_conflicting_name.proto b/common/src/test/resources/service_conflicting_name.proto new file mode 100644 index 000000000..995c9d563 --- /dev/null +++ b/common/src/test/resources/service_conflicting_name.proto @@ -0,0 +1,29 @@ +// Copyright 2022 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. + +// Test proto3 message with missing java_option flags and conflicting java class +// name. + +syntax = "proto3"; + +package dev.cel.common.testdata; + +// Service name that conflicts with the file name +service ServiceConflictingName { + // Stub method + rpc StubMethod(StubRequest) returns (StubResponse) {} +} + +message StubRequest {} +message StubResponse {} diff --git a/common/src/test/resources/value.fds b/common/src/test/resources/value.fds new file mode 100644 index 000000000..4dd2f466b --- /dev/null +++ b/common/src/test/resources/value.fds @@ -0,0 +1,305 @@ +file { + name: "google/protobuf/any.proto" + package: "google.protobuf" + message_type { + name: "Any" + field { + name: "type_url" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + options { + ctype: STRING_PIECE + } + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_BYTES + options { + ctype: CORD + } + } + } + options { + java_package: "com.google.protobuf" + java_outer_classname: "AnyProto" + java_multiple_files: true + go_package: "google.golang.org/protobuf/types/known/anypb" + objc_class_prefix: "GPB" + csharp_namespace: "Google.Protobuf.WellKnownTypes" + } + syntax: "proto3" +} +file { + name: "google/protobuf/struct.proto" + package: "google.protobuf" + message_type { + name: "Struct" + field { + name: "fields" + number: 1 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".google.protobuf.Struct.FieldsEntry" + } + nested_type { + name: "FieldsEntry" + field { + name: "key" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Value" + } + options { + map_entry: true + } + } + } + message_type { + name: "Value" + field { + name: "null_value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_ENUM + type_name: ".google.protobuf.NullValue" + oneof_index: 0 + } + field { + name: "number_value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_DOUBLE + oneof_index: 0 + } + field { + name: "string_value" + number: 3 + label: LABEL_OPTIONAL + type: TYPE_STRING + oneof_index: 0 + } + field { + name: "bool_value" + number: 4 + label: LABEL_OPTIONAL + type: TYPE_BOOL + oneof_index: 0 + } + field { + name: "struct_value" + number: 5 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Struct" + oneof_index: 0 + } + field { + name: "list_value" + number: 6 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.ListValue" + oneof_index: 0 + } + oneof_decl { + name: "kind" + } + } + message_type { + name: "ListValue" + field { + name: "values" + number: 1 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".google.protobuf.Value" + } + } + enum_type { + name: "NullValue" + value { + name: "NULL_VALUE" + number: 0 + } + } + options { + java_package: "com.google.protobuf" + java_outer_classname: "StructProto" + java_multiple_files: true + go_package: "google.golang.org/protobuf/types/known/structpb" + cc_enable_arenas: true + objc_class_prefix: "GPB" + csharp_namespace: "Google.Protobuf.WellKnownTypes" + } + syntax: "proto3" +} +file { + name: "google/api/expr/value.proto" + package: "google.api.expr" + dependency: "google/protobuf/any.proto" + dependency: "google/protobuf/struct.proto" + message_type { + name: "Value" + field { + name: "null_value" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_ENUM + type_name: ".google.protobuf.NullValue" + oneof_index: 0 + } + field { + name: "bool_value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_BOOL + oneof_index: 0 + } + field { + name: "int64_value" + number: 3 + label: LABEL_OPTIONAL + type: TYPE_INT64 + oneof_index: 0 + } + field { + name: "uint64_value" + number: 4 + label: LABEL_OPTIONAL + type: TYPE_UINT64 + oneof_index: 0 + } + field { + name: "double_value" + number: 5 + label: LABEL_OPTIONAL + type: TYPE_DOUBLE + oneof_index: 0 + } + field { + name: "string_value" + number: 6 + label: LABEL_OPTIONAL + type: TYPE_STRING + oneof_index: 0 + } + field { + name: "bytes_value" + number: 7 + label: LABEL_OPTIONAL + type: TYPE_BYTES + oneof_index: 0 + } + field { + name: "enum_value" + number: 9 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.api.expr.EnumValue" + oneof_index: 0 + } + field { + name: "object_value" + number: 10 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.protobuf.Any" + oneof_index: 0 + } + field { + name: "map_value" + number: 11 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.api.expr.MapValue" + oneof_index: 0 + } + field { + name: "list_value" + number: 12 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.api.expr.ListValue" + oneof_index: 0 + } + field { + name: "type_value" + number: 15 + label: LABEL_OPTIONAL + type: TYPE_STRING + oneof_index: 0 + } + oneof_decl { + name: "kind" + } + } + message_type { + name: "EnumValue" + field { + name: "type" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_STRING + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_INT32 + } + } + message_type { + name: "ListValue" + field { + name: "values" + number: 1 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".google.api.expr.Value" + } + } + message_type { + name: "MapValue" + field { + name: "entries" + number: 1 + label: LABEL_REPEATED + type: TYPE_MESSAGE + type_name: ".google.api.expr.MapValue.Entry" + } + nested_type { + name: "Entry" + field { + name: "key" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.api.expr.Value" + } + field { + name: "value" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".google.api.expr.Value" + } + } + } + options { + java_package: "com.google.api.expr" + java_outer_classname: "ValueProto" + java_multiple_files: true + cc_enable_arenas: true + } + syntax: "proto3" +} diff --git a/common/src/test/resources/value.textproto b/common/src/test/resources/value.textproto new file mode 100644 index 000000000..eb08aeefa --- /dev/null +++ b/common/src/test/resources/value.textproto @@ -0,0 +1,4 @@ +# proto-file: google/protobuf/any.proto +# proto-message: Any +type_url: "type.googleapis.com/google.api.expr.Value" +value: "b\026\n\a2\005Hello\n\a2\005World\n\002\030*" diff --git a/common/testing/BUILD.bazel b/common/testing/BUILD.bazel new file mode 100644 index 000000000..fdc3a1106 --- /dev/null +++ b/common/testing/BUILD.bazel @@ -0,0 +1,12 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//:internal"], +) + +java_library( + name = "testing", + exports = ["//common/src/main/java/dev/cel/common/testing"], +) diff --git a/common/types/BUILD.bazel b/common/types/BUILD.bazel new file mode 100644 index 000000000..df249ddbc --- /dev/null +++ b/common/types/BUILD.bazel @@ -0,0 +1,88 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "types", + exports = ["//common/src/main/java/dev/cel/common/types"], +) + +java_library( + name = "cel_internal_types", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common/types:cel_internal_types"], +) + +java_library( + name = "json", + visibility = [ + "//:internal", + ], + exports = ["//common/src/main/java/dev/cel/common/types:json"], +) + +java_library( + name = "type_providers", + exports = ["//common/src/main/java/dev/cel/common/types:type_providers"], +) + +java_library( + name = "message_type_provider", + exports = ["//common/src/main/java/dev/cel/common/types:message_type_provider"], +) + +java_library( + name = "cel_types", + exports = ["//common/src/main/java/dev/cel/common/types:cel_types"], +) + +java_library( + name = "cel_proto_types", + exports = ["//common/src/main/java/dev/cel/common/types:cel_proto_types"], +) + +java_library( + name = "cel_proto_message_types", + exports = ["//common/src/main/java/dev/cel/common/types:cel_proto_message_types"], +) + +java_library( + name = "default_type_provider", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common/types:default_type_provider"], +) + +java_library( + name = "cel_v1alpha1_types", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common/types:cel_v1alpha1_types"], +) + +cel_android_library( + name = "cel_types_android", + exports = ["//common/src/main/java/dev/cel/common/types:cel_types_android"], +) + +cel_android_library( + name = "types_android", + exports = ["//common/src/main/java/dev/cel/common/types:types_android"], +) + +cel_android_library( + name = "type_providers_android", + exports = ["//common/src/main/java/dev/cel/common/types:type_providers_android"], +) + +cel_android_library( + name = "cel_proto_types_android", + exports = ["//common/src/main/java/dev/cel/common/types:cel_proto_types_android"], +) + +cel_android_library( + name = "default_type_provider_android", + exports = ["//common/src/main/java/dev/cel/common/types:default_type_provider_android"], +) diff --git a/common/values/BUILD.bazel b/common/values/BUILD.bazel new file mode 100644 index 000000000..9853289a9 --- /dev/null +++ b/common/values/BUILD.bazel @@ -0,0 +1,128 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "cel_value", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common/values:cel_value"], +) + +cel_android_library( + name = "cel_value_android", + exports = ["//common/src/main/java/dev/cel/common/values:cel_value_android"], +) + +java_library( + name = "cel_value_provider", + exports = ["//common/src/main/java/dev/cel/common/values:cel_value_provider"], +) + +cel_android_library( + name = "cel_value_provider_android", + exports = ["//common/src/main/java/dev/cel/common/values:cel_value_provider_android"], +) + +java_library( + name = "combined_cel_value_provider", + exports = ["//common/src/main/java/dev/cel/common/values:combined_cel_value_provider"], +) + +cel_android_library( + name = "combined_cel_value_provider_android", + exports = ["//common/src/main/java/dev/cel/common/values:combined_cel_value_provider_android"], +) + +java_library( + name = "combined_cel_value_converter", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common/values:combined_cel_value_converter"], +) + +cel_android_library( + name = "combined_cel_value_converter_android", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common/values:combined_cel_value_converter_android"], +) + +java_library( + name = "values", + exports = ["//common/src/main/java/dev/cel/common/values"], +) + +cel_android_library( + name = "values_android", + exports = ["//common/src/main/java/dev/cel/common/values:values_android"], +) + +java_library( + name = "mutable_map_value", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common/values:mutable_map_value"], +) + +cel_android_library( + name = "mutable_map_value_android", + visibility = ["//:internal"], + exports = ["//common/src/main/java/dev/cel/common/values:mutable_map_value_android"], +) + +java_library( + name = "base_proto_cel_value_converter", + exports = ["//common/src/main/java/dev/cel/common/values:base_proto_cel_value_converter"], +) + +cel_android_library( + name = "base_proto_cel_value_converter_android", + exports = ["//common/src/main/java/dev/cel/common/values:base_proto_cel_value_converter_android"], +) + +java_library( + name = "proto_message_value_provider", + exports = ["//common/src/main/java/dev/cel/common/values:proto_message_value_provider"], +) + +java_library( + name = "cel_byte_string", + # used_by_android + exports = ["//common/src/main/java/dev/cel/common/values:cel_byte_string"], +) + +java_library( + name = "proto_message_value", + exports = ["//common/src/main/java/dev/cel/common/values:proto_message_value"], +) + +java_library( + name = "proto_message_lite_value", + exports = ["//common/src/main/java/dev/cel/common/values:proto_message_lite_value"], +) + +cel_android_library( + name = "proto_message_lite_value_android", + exports = ["//common/src/main/java/dev/cel/common/values:proto_message_lite_value_android"], +) + +java_library( + name = "proto_message_lite_value_provider", + exports = ["//common/src/main/java/dev/cel/common/values:proto_message_lite_value_provider"], +) + +cel_android_library( + name = "proto_message_lite_value_provider_android", + exports = ["//common/src/main/java/dev/cel/common/values:proto_message_lite_value_provider_android"], +) + +java_library( + name = "base_proto_message_value_provider", + exports = ["//common/src/main/java/dev/cel/common/values:base_proto_message_value_provider"], +) + +cel_android_library( + name = "base_proto_message_value_provider_android", + exports = ["//common/src/main/java/dev/cel/common/values:base_proto_message_value_provider_android"], +) diff --git a/compiler/BUILD.bazel b/compiler/BUILD.bazel new file mode 100644 index 000000000..5bb7d7129 --- /dev/null +++ b/compiler/BUILD.bazel @@ -0,0 +1,16 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "compiler", + exports = ["//compiler/src/main/java/dev/cel/compiler"], +) + +java_library( + name = "compiler_builder", + exports = ["//compiler/src/main/java/dev/cel/compiler:compiler_builder"], +) diff --git a/compiler/src/main/java/dev/cel/compiler/BUILD.bazel b/compiler/src/main/java/dev/cel/compiler/BUILD.bazel new file mode 100644 index 000000000..6a9a80709 --- /dev/null +++ b/compiler/src/main/java/dev/cel/compiler/BUILD.bazel @@ -0,0 +1,78 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//compiler:__pkg__", + "//publish:__pkg__", + ], +) + +# keep sorted +COMPILER_SOURCES = [ + "CelCompilerFactory.java", + "CelCompilerImpl.java", +] + +# keep sorted +COMPILER_BUILDER_SOURCES = [ + "CelCompiler.java", + "CelCompilerBuilder.java", + "CelCompilerLibrary.java", +] + +java_library( + name = "compiler", + srcs = COMPILER_SOURCES, + tags = [ + ], + deps = [ + ":compiler_builder", + "//checker", + "//checker:checker_builder", + "//checker:checker_legacy_environment", + "//checker:proto_type_mask", + "//checker:standard_decl", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common/annotations", + "//common/internal:env_visitor", + "//common/types:cel_proto_types", + "//common/types:type_providers", + "//parser", + "//parser:macro", + "//parser:parser_builder", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "compiler_builder", + srcs = COMPILER_BUILDER_SOURCES, + tags = [ + ], + deps = [ + "//:auto_value", + "//checker:checker_builder", + "//checker:checker_legacy_environment", + "//checker:proto_type_mask", + "//checker:standard_decl", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common/types:type_providers", + "//parser:macro", + "//parser:parser_builder", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_protobuf_protobuf_java", + ], +) diff --git a/compiler/src/main/java/dev/cel/compiler/CelCompiler.java b/compiler/src/main/java/dev/cel/compiler/CelCompiler.java new file mode 100644 index 000000000..602646ab4 --- /dev/null +++ b/compiler/src/main/java/dev/cel/compiler/CelCompiler.java @@ -0,0 +1,62 @@ +// Copyright 2022 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.compiler; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.checker.CelChecker; +import dev.cel.common.CelValidationResult; +import dev.cel.parser.CelParser; + +/** + * CelCompiler bundles up the common concerns for parsing and type-checking exposes additional + * methods for performing both operations in a single pass. + */ +@Immutable +public interface CelCompiler extends CelParser, CelChecker { + + /** + * Compile the input {@code expression} and return a {@code CelValidationResult}. + * + *

Compile will {@code parse}, then {@code check} the {@code expression} to validate the syntax + * and type-agreement of the expression. + */ + default CelValidationResult compile(String expression) { + return compile(expression, ""); + } + + /** + * Compile the input {@code expression} and return a {@code CelValidationResult}. + * + *

The {@code description} may be used to help tailor error messages for the location where the + * {@code expression} originates, e.g. a file name or form UI element. + * + *

Compile will {@code parse}, then {@code check} the {@code expression} to validate the syntax + * and type-agreement of the expression. + */ + default CelValidationResult compile(String expression, String description) { + CelValidationResult result = parse(expression, description); + if (result.hasError()) { + return result; + } + + try { + return check(result.getAst()); + } catch (Exception ex) { + throw new IllegalStateException("this method must only be called when !hasError()", ex); + } + } + + CelCompilerBuilder toCompilerBuilder(); +} diff --git a/compiler/src/main/java/dev/cel/compiler/CelCompilerBuilder.java b/compiler/src/main/java/dev/cel/compiler/CelCompilerBuilder.java new file mode 100644 index 000000000..6dd2ee12e --- /dev/null +++ b/compiler/src/main/java/dev/cel/compiler/CelCompilerBuilder.java @@ -0,0 +1,226 @@ +// Copyright 2022 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.compiler; + +import dev.cel.expr.Decl; +import dev.cel.expr.Type; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import dev.cel.checker.CelStandardDeclarations; +import dev.cel.checker.ProtoTypeMask; +import dev.cel.checker.TypeProvider; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelVarDecl; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelStandardMacro; + +/** Interface for building an instance of CelCompiler */ +public interface CelCompilerBuilder { + /** Sets the macro set for the parser, replacing the macros from any prior call. */ + @CanIgnoreReturnValue + CelCompilerBuilder setStandardMacros(CelStandardMacro... macros); + + /** Sets the macro set for the parser, replacing the macros from any prior call. */ + @CanIgnoreReturnValue + CelCompilerBuilder setStandardMacros(Iterable macros); + + /** + * Registers the given macros, replacing any previous macros with the same key. + * + *

Use this to register a set of user-defined custom macro implementation for the parser. For + * registering macros defined as part of CEL standard library, use {@link #setStandardMacros} + * instead. + * + *

Custom macros should not use the same function names as the ones found in {@link + * CelStandardMacro} (ex: has, all, exists, etc.). Build method will throw if both standard macros + * and custom macros are set with the same name. + */ + @CanIgnoreReturnValue + CelCompilerBuilder addMacros(CelMacro... macros); + + /** + * Registers the given macros, replacing any previous macros with the same key. + * + *

Use this to register a set of user-defined custom macro implementation for the parser. For + * registering macros defined as part of CEL standard library, use {@link #setStandardMacros} + * instead. + * + *

Custom macros should not use the same function names as the ones found in {@link + * CelStandardMacro} (ex: has, all, exists, etc.). Build method will throw if both standard macros + * and custom macros are set with the same name. + */ + @CanIgnoreReturnValue + CelCompilerBuilder addMacros(Iterable macros); + + /** Set the {@code CelOptions} used to enable fixes and features for this CEL instances. */ + @CanIgnoreReturnValue + CelCompilerBuilder setOptions(CelOptions options); + + /** + * Set the {@link CelContainer} to use as the namespace for resolving CEL expression variables and + * functions. + */ + @CanIgnoreReturnValue + CelCompilerBuilder setContainer(CelContainer container); + + /** Retrieves the currently configured {@link CelContainer} in the builder. */ + CelContainer container(); + + /** Add a variable declaration with a given {@code name} and proto based {@link Type}. */ + @CanIgnoreReturnValue + CelCompilerBuilder addVar(String name, Type type); + + /** Add a variable declaration with a given {@code name} and {@link CelType}. */ + @CanIgnoreReturnValue + CelCompilerBuilder addVar(String name, CelType type); + + /** Add variable and function {@code declarations} to the CEL environment. */ + @CanIgnoreReturnValue + CelCompilerBuilder addDeclarations(Decl... declarations); + + /** Add variable and function {@code declarations} to the CEL environment. */ + @CanIgnoreReturnValue + CelCompilerBuilder addDeclarations(Iterable declarations); + + /** Add function declaration {@code CelFunctionDecl} to the CEL environment */ + @CanIgnoreReturnValue + CelCompilerBuilder addFunctionDeclarations(CelFunctionDecl... celFunctionDecls); + + /** Add function declaration {@code CelFunctionDecl} to the CEL environment */ + @CanIgnoreReturnValue + CelCompilerBuilder addFunctionDeclarations(Iterable celFunctionDecls); + + /** Add variable declaration {@code CelVarDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelCompilerBuilder addVarDeclarations(CelVarDecl... varDecl); + + /** Add variable declaration {@code CelVarDecl} to the CEL environment. */ + @CanIgnoreReturnValue + CelCompilerBuilder addVarDeclarations(Iterable varDecl); + + /** + * Add one or more {@link ProtoTypeMask} values. The {@code ProtoTypeMask} values will be used to + * compute a set of {@code Decl} values using a protobuf message's fields as the names and types + * of the variables if {@link ProtoTypeMask#fieldsAreVariableDeclarations} is {@code true}. + * + *

Note, this feature may not work with custom {@code TypeProvider} implementations out of the + * box, as it requires the implementation of {@code TypeProvider#lookupFieldNames} to return the + * set of all fields declared on the protobuf type. + */ + @CanIgnoreReturnValue + CelCompilerBuilder addProtoTypeMasks(ProtoTypeMask... typeMasks); + + /** + * Add one or more {@link ProtoTypeMask} values. The {@code ProtoTypeMask} values will be used to + * compute a set of {@code Decl} values using a protobuf message's fields as the names and types + * of the variables if {@link ProtoTypeMask#fieldsAreVariableDeclarations} is {@code true}. + * + *

Note, this feature may not work with custom {@code TypeProvider} implementations out of the + * box, as it requires the implementation of {@code TypeProvider#lookupFieldNames} to return the + * set of all fields declared on the protobuf type. + */ + @CanIgnoreReturnValue + CelCompilerBuilder addProtoTypeMasks(Iterable typeMasks); + + /** Set the expected {@code resultType} for the type-checked expression. */ + @CanIgnoreReturnValue + CelCompilerBuilder setResultType(CelType resultType); + + /** + * Set the expected {@code resultType} in proto format described in checked.proto for the + * type-checked expression. + */ + @CanIgnoreReturnValue + CelCompilerBuilder setProtoResultType(Type resultType); + + /** + * Set the {@code typeProvider} for use with type-checking expressions. + * + * @deprecated Use {@link #setTypeProvider(CelTypeProvider)} instead. + */ + @CanIgnoreReturnValue + @Deprecated + CelCompilerBuilder setTypeProvider(TypeProvider typeProvider); + + /** Set the {@code celTypeProvider} for use with type-checking expressions. */ + @CanIgnoreReturnValue + CelCompilerBuilder setTypeProvider(CelTypeProvider celTypeProvider); + + /** + * Add message {@link Descriptor}s to the use for type-checking and object creation at + * interpretation time. + */ + @CanIgnoreReturnValue + CelCompilerBuilder addMessageTypes(Descriptor... descriptors); + + /** + * Add message {@link Descriptor}s to the use for type-checking and object creation at + * interpretation time. + */ + @CanIgnoreReturnValue + CelCompilerBuilder addMessageTypes(Iterable descriptors); + + /** + * Add {@link FileDescriptor}s to the use for type-checking, and for object creation at + * interpretation time. + */ + @CanIgnoreReturnValue + CelCompilerBuilder addFileTypes(FileDescriptor... fileDescriptors); + + /** + * Add {@link FileDescriptor}s to the use for type-checking, and for object creation at + * interpretation time. + */ + @CanIgnoreReturnValue + CelCompilerBuilder addFileTypes(Iterable fileDescriptors); + + /** + * Add all of the {@link FileDescriptor}s in a {@code FileDescriptorSet} to the use for + * type-checking, and for object creation at interpretation time. + */ + @CanIgnoreReturnValue + CelCompilerBuilder addFileTypes(FileDescriptorSet fileDescriptorSet); + + /** Enable or disable the standard CEL library functions and variables */ + @CanIgnoreReturnValue + CelCompilerBuilder setStandardEnvironmentEnabled(boolean value); + + /** + * Override the standard declarations for the type-checker. This can be used to subset the + * standard environment to only expose the desired declarations to the type-checker. {@link + * #setStandardEnvironmentEnabled(boolean)} must be set to false for this to take effect. + */ + @CanIgnoreReturnValue + CelCompilerBuilder setStandardDeclarations(CelStandardDeclarations standardDeclarations); + + /** Adds one or more libraries for parsing and type-checking. */ + @CanIgnoreReturnValue + CelCompilerBuilder addLibraries(CelCompilerLibrary... libraries); + + /** Adds a collection of libraries for parsing and type-checking. */ + @CanIgnoreReturnValue + CelCompilerBuilder addLibraries(Iterable libraries); + + /** Build a new instance of the {@code CelCompiler}. */ + @CheckReturnValue + CelCompiler build(); +} diff --git a/compiler/src/main/java/dev/cel/compiler/CelCompilerFactory.java b/compiler/src/main/java/dev/cel/compiler/CelCompilerFactory.java new file mode 100644 index 000000000..dbeaeba0d --- /dev/null +++ b/compiler/src/main/java/dev/cel/compiler/CelCompilerFactory.java @@ -0,0 +1,57 @@ +// Copyright 2022 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.compiler; + +import dev.cel.checker.CelChecker; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.checker.CelCheckerLegacyImpl; +import dev.cel.common.CelOptions; +import dev.cel.parser.CelParser; +import dev.cel.parser.CelParserImpl; + +/** Factory class for creating builders for type-checker and compiler instances. */ +public final class CelCompilerFactory { + + /** + * Create a new builder to construct a {@code CelChecker} instance. + * + *

Note, the {@link CelOptions#current} and the standard CEL function declarations are + * configured by default. + */ + public static CelCheckerBuilder standardCelCheckerBuilder() { + return CelCheckerLegacyImpl.newBuilder() + .setOptions(CelOptions.current().build()) + .setStandardEnvironmentEnabled(true); + } + + /** + * Create a new builder to construct a {@link CelCompiler} instance. + * + *

Note, the {@link CelOptions#current} and the standard CEL function declarations are + * configured by default. + */ + public static CelCompilerBuilder standardCelCompilerBuilder() { + return CelCompilerImpl.newBuilder(CelParserImpl.newBuilder(), CelCheckerLegacyImpl.newBuilder()) + .setOptions(CelOptions.current().build()) + .setStandardEnvironmentEnabled(true); + } + + /** Combines a prebuilt {@link CelParser} and {@link CelChecker} into {@link CelCompiler}. */ + public static CelCompiler combine(CelParser celParser, CelChecker celChecker) { + return CelCompilerImpl.combine(celParser, celChecker); + } + + private CelCompilerFactory() {} +} diff --git a/compiler/src/main/java/dev/cel/compiler/CelCompilerImpl.java b/compiler/src/main/java/dev/cel/compiler/CelCompilerImpl.java new file mode 100644 index 000000000..e8804f348 --- /dev/null +++ b/compiler/src/main/java/dev/cel/compiler/CelCompilerImpl.java @@ -0,0 +1,328 @@ +// Copyright 2022 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.compiler; + +import static com.google.common.base.Preconditions.checkNotNull; + +import dev.cel.expr.Decl; +import dev.cel.expr.Type; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import dev.cel.checker.CelChecker; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.checker.CelStandardDeclarations; +import dev.cel.checker.ProtoTypeMask; +import dev.cel.checker.TypeProvider; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelSource; +import dev.cel.common.CelValidationResult; +import dev.cel.common.CelVarDecl; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.EnvVisitable; +import dev.cel.common.internal.EnvVisitor; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelParser; +import dev.cel.parser.CelParserBuilder; +import dev.cel.parser.CelStandardMacro; +import java.util.Arrays; + +/** + * CelCompiler implementation which uses either the legacy or modernized CEL-Java stack to offer a + * stream-lined expression parse/type-check experience, via a single {@code compile} method. + * + *

CEL Library Internals. Do Not Use. Consumers should use factories, such as {@link + * CelCompilerFactory} instead to instantiate a compiler. + */ +@Immutable +@Internal +public final class CelCompilerImpl implements CelCompiler, EnvVisitable { + + private final CelParser parser; + private final CelChecker checker; + + @Override + public CelValidationResult parse(String expression, String description) { + return parser.parse(expression, description); + } + + @Override + public CelValidationResult parse(CelSource source) { + return parser.parse(source); + } + + @Override + public CelValidationResult check(CelAbstractSyntaxTree ast) { + return checker.check(ast); + } + + @Override + public CelTypeProvider getTypeProvider() { + return checker.getTypeProvider(); + } + + @Override + public void accept(EnvVisitor envVisitor) { + if (checker instanceof EnvVisitable) { + ((EnvVisitable) checker).accept(envVisitor); + } + if (parser instanceof EnvVisitable) { + ((EnvVisitable) parser).accept(envVisitor); + } + } + + @Override + public CelCompilerBuilder toCompilerBuilder() { + return newBuilder(toParserBuilder(), toCheckerBuilder()); + } + + @Override + public CelCheckerBuilder toCheckerBuilder() { + return checker.toCheckerBuilder(); + } + + @Override + public CelParserBuilder toParserBuilder() { + return parser.toParserBuilder(); + } + + /** Combines a prebuilt {@link CelParser} and {@link CelChecker} into {@link CelCompilerImpl}. */ + static CelCompilerImpl combine(CelParser parser, CelChecker checker) { + return new CelCompilerImpl(parser, checker); + } + + /** + * Create a new builder for constructing a {@code CelCompiler} instance. + * + *

By default, {@link CelOptions#DEFAULT} are enabled, as is the CEL standard environment. + */ + public static CelCompilerBuilder newBuilder( + CelParserBuilder parserBuilder, CelCheckerBuilder checkerBuilder) { + return new Builder(parserBuilder, checkerBuilder); + } + + /** Builder for {@code CelCompilerImpl} */ + public static final class Builder implements CelCompilerBuilder { + private final CelParserBuilder parserBuilder; + private final CelCheckerBuilder checkerBuilder; + + @Override + public CelCompilerBuilder setOptions(CelOptions options) { + parserBuilder.setOptions(options); + checkerBuilder.setOptions(options); + return this; + } + + @Override + public CelCompilerBuilder setStandardMacros(CelStandardMacro... macros) { + parserBuilder.setStandardMacros(macros); + return this; + } + + @Override + public CelCompilerBuilder setStandardMacros(Iterable macros) { + parserBuilder.setStandardMacros(macros); + return this; + } + + @Override + public CelCompilerBuilder addMacros(CelMacro... macros) { + checkNotNull(macros); + return addMacros(Arrays.asList(macros)); + } + + @Override + public CelCompilerBuilder addMacros(Iterable macros) { + checkNotNull(macros); + parserBuilder.addMacros(macros); + return this; + } + + @Override + public CelCompilerBuilder setContainer(CelContainer container) { + checkerBuilder.setContainer(container); + return this; + } + + @Override + public CelContainer container() { + return checkerBuilder.container(); + } + + @Override + public CelCompilerBuilder addVar(String name, Type type) { + return addVar(name, CelProtoTypes.typeToCelType(type)); + } + + @Override + public CelCompilerBuilder addVar(String name, CelType type) { + return addVarDeclarations(CelVarDecl.newVarDeclaration(name, type)); + } + + @Override + public CelCompilerBuilder addDeclarations(Decl... declarations) { + checkerBuilder.addDeclarations(declarations); + return this; + } + + @Override + public CelCompilerBuilder addDeclarations(Iterable declarations) { + checkerBuilder.addDeclarations(declarations); + return this; + } + + @Override + public CelCompilerBuilder addFunctionDeclarations(CelFunctionDecl... celFunctionDecls) { + checkerBuilder.addFunctionDeclarations(celFunctionDecls); + return this; + } + + @Override + public CelCompilerBuilder addFunctionDeclarations(Iterable celFunctionDecls) { + checkerBuilder.addFunctionDeclarations(celFunctionDecls); + return this; + } + + @Override + public CelCompilerBuilder addVarDeclarations(CelVarDecl... celVarDecls) { + checkerBuilder.addVarDeclarations(celVarDecls); + return this; + } + + @Override + public CelCompilerBuilder addVarDeclarations(Iterable celVarDecls) { + checkerBuilder.addVarDeclarations(celVarDecls); + return this; + } + + @Override + public CelCompilerBuilder addProtoTypeMasks(ProtoTypeMask... typeMasks) { + checkerBuilder.addProtoTypeMasks(typeMasks); + return this; + } + + @Override + public CelCompilerBuilder addProtoTypeMasks(Iterable typeMasks) { + checkerBuilder.addProtoTypeMasks(typeMasks); + return this; + } + + @Override + public CelCompilerBuilder setResultType(CelType resultType) { + checkNotNull(resultType); + return setProtoResultType(CelProtoTypes.celTypeToType(resultType)); + } + + @Override + public CelCompilerBuilder setProtoResultType(Type resultType) { + checkerBuilder.setProtoResultType(resultType); + return this; + } + + @Override + @Deprecated + public CelCompilerBuilder setTypeProvider(TypeProvider typeProvider) { + checkerBuilder.setTypeProvider(typeProvider); + return this; + } + + @Override + public CelCompilerBuilder setTypeProvider(CelTypeProvider celTypeProvider) { + checkerBuilder.setTypeProvider(celTypeProvider); + return this; + } + + @Override + public CelCompilerBuilder addMessageTypes(Descriptor... descriptors) { + checkerBuilder.addMessageTypes(descriptors); + return this; + } + + @Override + public CelCompilerBuilder addMessageTypes(Iterable descriptors) { + checkerBuilder.addMessageTypes(descriptors); + return this; + } + + @Override + public CelCompilerBuilder addFileTypes(FileDescriptor... fileDescriptors) { + checkerBuilder.addFileTypes(fileDescriptors); + return this; + } + + @Override + public CelCompilerBuilder addFileTypes(Iterable fileDescriptors) { + checkerBuilder.addFileTypes(fileDescriptors); + return this; + } + + @Override + public CelCompilerBuilder addFileTypes(FileDescriptorSet fileDescriptorSet) { + checkerBuilder.addFileTypes(fileDescriptorSet); + return this; + } + + @Override + public CelCompilerBuilder setStandardEnvironmentEnabled(boolean value) { + checkerBuilder.setStandardEnvironmentEnabled(value); + return this; + } + + @Override + public CelCompilerBuilder setStandardDeclarations( + CelStandardDeclarations standardDeclarations) { + checkerBuilder.setStandardDeclarations(standardDeclarations); + return this; + } + + @Override + public CelCompilerBuilder addLibraries(CelCompilerLibrary... libraries) { + checkNotNull(libraries); + return this.addLibraries(Arrays.asList(libraries)); + } + + @Override + public CelCompilerBuilder addLibraries(Iterable libraries) { + checkNotNull(libraries); + parserBuilder.addLibraries(libraries); + checkerBuilder.addLibraries(libraries); + return this; + } + + @Override + @CheckReturnValue + public CelCompilerImpl build() { + return new CelCompilerImpl(parserBuilder.build(), checkerBuilder.build()); + } + + private Builder(CelParserBuilder parserBuilder, CelCheckerBuilder checkerBuilder) { + this.parserBuilder = parserBuilder; + this.checkerBuilder = checkerBuilder; + } + } + + private CelCompilerImpl(CelParser parser, CelChecker checker) { + this.parser = parser; + this.checker = checker; + } +} diff --git a/compiler/src/main/java/dev/cel/compiler/CelCompilerLibrary.java b/compiler/src/main/java/dev/cel/compiler/CelCompilerLibrary.java new file mode 100644 index 000000000..b191cbd24 --- /dev/null +++ b/compiler/src/main/java/dev/cel/compiler/CelCompilerLibrary.java @@ -0,0 +1,24 @@ +// Copyright 2022 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.compiler; + +import dev.cel.checker.CelCheckerLibrary; +import dev.cel.parser.CelParserLibrary; + +/** + * CelCompilerLibrary defines the interface to extend functionalities beyond the CEL standard + * functions for {@link CelCompiler}. + */ +public interface CelCompilerLibrary extends CelParserLibrary, CelCheckerLibrary {} diff --git a/compiler/src/main/java/dev/cel/compiler/tools/BUILD.bazel b/compiler/src/main/java/dev/cel/compiler/tools/BUILD.bazel new file mode 100644 index 000000000..92375ec8f --- /dev/null +++ b/compiler/src/main/java/dev/cel/compiler/tools/BUILD.bazel @@ -0,0 +1,33 @@ +load("@rules_java//java:defs.bzl", "java_binary") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//compiler/tools:__pkg__", + ], +) + +java_binary( + name = "cel_compiler_tool", + srcs = ["CelCompilerTool.java"], + main_class = "dev.cel.compiler.tools.CelCompilerTool", + neverlink = 1, + deps = [ + "//bundle:environment", + "//bundle:environment_exception", + "//bundle:environment_yaml_parser", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:options", + "//common:proto_ast", + "//compiler", + "//compiler:compiler_builder", + "//parser:macro", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:info_picocli_picocli", + ], +) diff --git a/compiler/src/main/java/dev/cel/compiler/tools/CelCompilerTool.java b/compiler/src/main/java/dev/cel/compiler/tools/CelCompilerTool.java new file mode 100644 index 000000000..abe780c4a --- /dev/null +++ b/compiler/src/main/java/dev/cel/compiler/tools/CelCompilerTool.java @@ -0,0 +1,166 @@ +// Copyright 2025 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.compiler.tools; + +import dev.cel.expr.CheckedExpr; +import com.google.common.collect.ImmutableSet; +import com.google.common.io.Files; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.ExtensionRegistry; +import dev.cel.bundle.CelEnvironment; +import dev.cel.bundle.CelEnvironmentException; +import dev.cel.bundle.CelEnvironmentYamlParser; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelOptions; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerBuilder; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelStandardMacro; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Locale; +import java.util.concurrent.Callable; +import picocli.CommandLine; +import picocli.CommandLine.Option; + +/** + * CelCompilerTool is a binary that takes a CEL expression in string, compiles it into a + * dev.cel.expr.CheckedExpr protobuf message, then writes the content to a .binary pb file. + */ +final class CelCompilerTool implements Callable { + + @Option( + names = {"--cel_expression"}, + description = "CEL expression") + private String celExpression = ""; + + @Option( + names = {"--environment_path"}, + description = "Path to the CEL environment (in YAML)") + private String celEnvironmentPath = ""; + + @Option( + names = {"--transitive_descriptor_set"}, + description = "Path to the transitive set of descriptors") + private String transitiveDescriptorSetPath = ""; + + @Option( + names = {"--output"}, + description = "Output path for the compiled binarypb") + private String output = ""; + + private static final CelOptions CEL_OPTIONS = CelOptions.DEFAULT; + + private static CelCompiler prepareCompiler( + String celEnvironmentPath, String transitiveDescriptorSetPath) + throws CelEnvironmentException, IOException { + CelCompilerBuilder celCompilerBuilder = + CelCompilerFactory.standardCelCompilerBuilder() + // TODO: Configure the below through YAML + .setOptions(CEL_OPTIONS) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS); + + if (!transitiveDescriptorSetPath.isEmpty()) { + ImmutableSet transitiveFileDescriptors = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet( + load(transitiveDescriptorSetPath)); + celCompilerBuilder.addFileTypes(transitiveFileDescriptors); + } + if (celEnvironmentPath.isEmpty()) { + return celCompilerBuilder.build(); + } + + if (!celEnvironmentPath.toLowerCase(Locale.getDefault()).trim().endsWith(".yaml")) { + throw new IllegalArgumentException( + "Only YAML extension is supported for CEL environments. Got: " + celEnvironmentPath); + } + + CelEnvironmentYamlParser environmentYamlParser = CelEnvironmentYamlParser.newInstance(); + String yamlContent = new String(readFileBytes(celEnvironmentPath), StandardCharsets.UTF_8); + CelEnvironment environment = environmentYamlParser.parse(yamlContent); + + return environment.extend(celCompilerBuilder.build(), CEL_OPTIONS); + } + + private static void writeCheckedExpr(CelAbstractSyntaxTree ast, String filePath) + throws IOException { + CheckedExpr checkedExpr = CelProtoAbstractSyntaxTree.fromCelAst(ast).toCheckedExpr(); + Path path = Paths.get(filePath); + try (FileOutputStream output = new FileOutputStream(path.toFile())) { + checkedExpr.writeTo(output); + } + } + + private static FileDescriptorSet load(String descriptorSetPath) { + try { + byte[] descriptorBytes = readFileBytes(descriptorSetPath); + return FileDescriptorSet.parseFrom(descriptorBytes, ExtensionRegistry.getEmptyRegistry()); + } catch (IOException e) { + throw new IllegalArgumentException( + "Failed to load FileDescriptorSet from path: " + descriptorSetPath, e); + } + } + + private static byte[] readFileBytes(String path) throws IOException { + return Files.toByteArray(new File(path)); + } + + @Override + public Integer call() { + CelCompiler celCompiler; + try { + celCompiler = prepareCompiler(celEnvironmentPath, transitiveDescriptorSetPath); + } catch (Exception e) { + String errorMessage = + String.format( + "Failed to create a CEL compilation environment. Reason: %s", e.getMessage()); + System.err.print(errorMessage); + return -1; + } + + try { + CelAbstractSyntaxTree ast = celCompiler.compile(celExpression).getAst(); + writeCheckedExpr(ast, output); + } catch (Exception e) { + String errorMessage = + String.format( + "\nFailed to compile CEL Expression: [%s].\nReason: %s\n\n", + celExpression, e.getMessage()); + System.err.print(errorMessage); + return -1; + } + + return 0; + } + + public static void main(String[] args) { + CelCompilerTool compilerTool = new CelCompilerTool(); + CommandLine cmd = new CommandLine(compilerTool); + cmd.setTrimQuotes(false); + cmd.parseArgs(args); + + int exitCode = cmd.execute(args); + System.exit(exitCode); + } + + CelCompilerTool() {} +} diff --git a/compiler/src/test/java/dev/cel/compiler/tools/BUILD.bazel b/compiler/src/test/java/dev/cel/compiler/tools/BUILD.bazel new file mode 100644 index 000000000..c388ea3ea --- /dev/null +++ b/compiler/src/test/java/dev/cel/compiler/tools/BUILD.bazel @@ -0,0 +1,36 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*Test.java"]), + deps = [ + "//:java_truth", + "//common:cel_ast", + "//common:options", + "//extensions", + "//extensions:optional_library", + "//runtime", + "//runtime:function_binding", + "//testing/compiled:compiled_expr_utils", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/compiler/src/test/java/dev/cel/compiler/tools/CelCompilerToolTest.java b/compiler/src/test/java/dev/cel/compiler/tools/CelCompilerToolTest.java new file mode 100644 index 000000000..ed3d8b473 --- /dev/null +++ b/compiler/src/test/java/dev/cel/compiler/tools/CelCompilerToolTest.java @@ -0,0 +1,99 @@ +// Copyright 2025 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.compiler.tools; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.testing.compiled.CompiledExprUtils.readCheckedExpr; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.StringValue; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelExtensions; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntimeFactory; +import java.util.List; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelCompilerToolTest { + private static final CelRuntime CEL_RUNTIME = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addFunctionBindings( + CelFunctionBinding.from("wrapper_string_isEmpty", String.class, String::isEmpty)) + .addLibraries( + CelExtensions.encoders(), + CelExtensions.math(CelOptions.DEFAULT), + CelExtensions.lists(), + CelExtensions.strings(), + CelOptionalLibrary.INSTANCE) + .addMessageTypes(TestAllTypes.getDescriptor()) + .build(); + + @Test + public void compiledCheckedExpr_string() throws Exception { + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_hello_world"); + + String result = (String) CEL_RUNTIME.createProgram(ast).eval(); + assertThat(result).isEqualTo("hello world"); + } + + @Test + @SuppressWarnings("unchecked") + public void compiledCheckedExpr_comprehension() throws Exception { + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_comprehension"); + + List result = (List) CEL_RUNTIME.createProgram(ast).eval(); + assertThat(result).containsExactly(2L, 3L, 4L).inOrder(); + } + + @Test + public void compiledCheckedExpr_protoMessage() throws Exception { + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_proto_message"); + + TestAllTypes result = (TestAllTypes) CEL_RUNTIME.createProgram(ast).eval(); + assertThat(result).isEqualTo(TestAllTypes.newBuilder().setSingleInt32(1).build()); + } + + @Test + public void compiledCheckedExpr_extensions() throws Exception { + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_extensions"); + + assertThat(CEL_RUNTIME.createProgram(ast).eval()).isEqualTo(true); + } + + @Test + public void compiledCheckedExpr_extended_env() throws Exception { + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_extended_env"); + + boolean result = + (boolean) + CEL_RUNTIME + .createProgram(ast) + .eval( + ImmutableMap.of( + "msg", + TestAllTypes.newBuilder() + .setSingleStringWrapper(StringValue.of("foo")) + .build())); + + assertThat(result).isTrue(); + } +} diff --git a/compiler/tools/BUILD.bazel b/compiler/tools/BUILD.bazel new file mode 100644 index 000000000..1cf5154e0 --- /dev/null +++ b/compiler/tools/BUILD.bazel @@ -0,0 +1,9 @@ +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//:android_allow_list"], +) + +alias( + name = "cel_compiler_tool", + actual = "//compiler/src/main/java/dev/cel/compiler/tools:cel_compiler_tool", +) diff --git a/compiler/tools/compile_cel.bzl b/compiler/tools/compile_cel.bzl new file mode 100644 index 000000000..a428850f9 --- /dev/null +++ b/compiler/tools/compile_cel.bzl @@ -0,0 +1,71 @@ +# Copyright 2025 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. +"""Rule for compiling CEL expressions at build time. +""" + +load("@rules_proto//proto:defs.bzl", "proto_descriptor_set") + +def compile_cel( + name, + expression, + proto_srcs = [], + environment = None, + output = None): + """Compiles a CEL expression, generating a cel.expr.CheckedExpr proto. This proto is written to a `.binarypb` file. + + Args: + name: str name for the generated artifact + expression: str CEL expression to compile + proto_srcs: (optional) list of str label(s) pointing to a proto_library rule (important: NOT java_proto_library). This must be provided when compiling a CEL expression containing protobuf messages. + environment: (optional) str label or filename pointing to a YAML file that describes a CEL environment. + output: (optional) str file name for the output checked expression. `.binarypb` extension is automatically appended in the filename. + """ + + args = [] + genrule_srcs = [] + + args.append("--cel_expression \"%s\" " % expression) + + if output == None: + output = name + + output = output + ".binarypb" + args.append("--output $(location %s) " % output) + + if len(proto_srcs) > 0: + transitive_descriptor_set_name = "%s_transitive_descriptor_set" % name + proto_descriptor_set( + name = transitive_descriptor_set_name, + deps = proto_srcs, + ) + args.append("--transitive_descriptor_set $(location %s) " % transitive_descriptor_set_name) + genrule_srcs.append(transitive_descriptor_set_name) + + if environment != None: + args.append("--environment_path=$(location {})".format(environment)) + genrule_srcs.append(environment) + + arg_str = " ".join(args) + cmd = ( + "$(location //compiler/tools:cel_compiler_tool) " + + arg_str + ) + + native.genrule( + name = name, + cmd = cmd, + srcs = genrule_srcs, + outs = [output], + tools = ["//compiler/tools:cel_compiler_tool"], + ) diff --git a/conformance/src/test/java/dev/cel/conformance/BUILD.bazel b/conformance/src/test/java/dev/cel/conformance/BUILD.bazel new file mode 100644 index 000000000..e9ed58642 --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/BUILD.bazel @@ -0,0 +1,209 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//conformance/src/test/java/dev/cel/conformance:conformance_test.bzl", "MODE", "conformance_test") + +package(default_applicable_licenses = [ + "//:license", +]) + +exports_files([ + "conformance_test.bzl", + "conformance_test.sh", +]) + +java_library( + name = "run", + testonly = True, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//checker:checker_builder", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common/types:cel_proto_types", + "//compiler", + "//compiler:compiler_builder", + "//extensions", + "//extensions:optional_library", + "//parser:macro", + "//parser:parser_builder", + "//parser:parser_factory", + "//runtime", + "//runtime:runtime_planner_impl", + "//testing:expr_value_utils", + "@cel_spec//proto/cel/expr:expr_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/test:simple_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_truth_extensions_truth_proto_extension", + "@maven//:junit_junit", + ], +) + +MAVEN_JAR_DEPS = [ + "@maven_conformance//:dev_cel_compiler", + "@maven_conformance//:dev_cel_common", + "@maven_conformance//:dev_cel_runtime", + "@maven_conformance//:dev_cel_protobuf", + "@maven_conformance//:dev_cel_cel", +] + +java_library( + name = "run_maven_jar", + testonly = True, + srcs = glob(["*.java"]), + tags = ["conformance_maven"], + deps = MAVEN_JAR_DEPS + [ + "//:java_truth", + "//compiler:compiler_builder", + "//parser:parser_factory", + "//runtime:runtime_planner_impl", + "//testing:expr_value_utils", + "@cel_spec//proto/cel/expr:expr_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/test:simple_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_truth_extensions_truth_proto_extension", + "@maven//:junit_junit", + ], +) + +_ALL_TESTS = [ + "@cel_spec//tests/simple:testdata/basic.textproto", + "@cel_spec//tests/simple:testdata/bindings_ext.textproto", + "@cel_spec//tests/simple:testdata/comparisons.textproto", + "@cel_spec//tests/simple:testdata/conversions.textproto", + "@cel_spec//tests/simple:testdata/dynamic.textproto", + "@cel_spec//tests/simple:testdata/encoders_ext.textproto", + "@cel_spec//tests/simple:testdata/enums.textproto", + "@cel_spec//tests/simple:testdata/fields.textproto", + "@cel_spec//tests/simple:testdata/fp_math.textproto", + "@cel_spec//tests/simple:testdata/integer_math.textproto", + "@cel_spec//tests/simple:testdata/lists.textproto", + "@cel_spec//tests/simple:testdata/logic.textproto", + "@cel_spec//tests/simple:testdata/macros.textproto", + "@cel_spec//tests/simple:testdata/macros2.textproto", + "@cel_spec//tests/simple:testdata/math_ext.textproto", + "@cel_spec//tests/simple:testdata/namespace.textproto", + "@cel_spec//tests/simple:testdata/optionals.textproto", + "@cel_spec//tests/simple:testdata/parse.textproto", + "@cel_spec//tests/simple:testdata/plumbing.textproto", + "@cel_spec//tests/simple:testdata/proto2.textproto", + "@cel_spec//tests/simple:testdata/proto3.textproto", + "@cel_spec//tests/simple:testdata/proto2_ext.textproto", + "@cel_spec//tests/simple:testdata/string.textproto", + "@cel_spec//tests/simple:testdata/string_ext.textproto", + "@cel_spec//tests/simple:testdata/timestamps.textproto", + "@cel_spec//tests/simple:testdata/type_deduction.textproto", + "@cel_spec//tests/simple:testdata/unknowns.textproto", + "@cel_spec//tests/simple:testdata/wrappers.textproto", +] + +_TESTS_TO_SKIP_LEGACY = [ + # Broken test cases which should be supported. + # TODO: Support setting / getting enum values out of the defined enum value range. + "enums/legacy_proto2/select_big,select_neg", + "enums/legacy_proto2/assign_standalone_int_big,assign_standalone_int_neg", + # TODO: Generate errors on enum value assignment overflows for proto3. + "enums/legacy_proto3/assign_standalone_int_too_big,assign_standalone_int_too_neg", + # TODO: Ensure overflow occurs on conversions of double values which might not work properly on all platforms. + "conversions/int/double_int_min_range", + # TODO: Duration and timestamp operations should error on overflow. + "timestamps/timestamp_range/sub_time_duration_over,sub_time_duration_under", + # TODO: Ensure adding negative duration values is appropriately supported. + "timestamps/timestamp_arithmetic/add_time_to_duration_nanos_negative", + + # Skip until fixed. + "fields/qualified_identifier_resolution/map_value_repeat_key_heterogeneous", + # TODO: Add strings.format.quote. + "string_ext/format", + "string_ext/format_errors", + + # Future features for CEL 1.0 + # TODO: Strong typing support for enums, specified but not implemented. + "enums/strong_proto2", + "enums/strong_proto3", + + # com.google.protobuf.TextFormat does not conform to the spec. Unknown enum values are supposed + # to be allowed in proto3. Currently they are rejected. + # "enums/legacy_proto3/select_big", + # "enums/legacy_proto3/select_neg", + # "enums/legacy_proto3/assign_standalone_int_big", + # "enums/legacy_proto3/assign_standalone_int_neg", + + # Type inference edgecases around null(able) assignability. + # These type check, but resolve to a different type. + # list(int), want list(wrapper(int)) + "type_deductions/wrappers/wrapper_promotion", + # list(null), want list(Message) + "type_deductions/legacy_nullable_types/null_assignable_to_message_parameter_candidate", + "type_deductions/legacy_nullable_types/null_assignable_to_abstract_parameter_candidate", + "type_deductions/legacy_nullable_types/null_assignable_to_duration_parameter_candidate", + "type_deductions/legacy_nullable_types/null_assignable_to_timestamp_parameter_candidate", +] + +_TESTS_TO_SKIP_PLANNER = [ + # TODO: Add strings.format. + "string_ext/format", + "string_ext/format_errors", + + # TODO: Check behavior for go/cpp + "basic/functions/unbound_is_runtime_error", + + # TODO: Ensure overflow occurs on conversions of double values which might not work properly on all platforms. + "conversions/int/double_int_min_range", + "enums/legacy_proto3/assign_standalone_int_too_big", + "enums/legacy_proto3/assign_standalone_int_too_neg", + + # TODO: Duration and timestamp operations should error on overflow. + "timestamps/timestamp_range/sub_time_duration_over", + "timestamps/timestamp_range/sub_time_duration_under", + + # Skip until fixed. + "parse/receiver_function_names", + + # Type inference edgecases around null(able) assignability. + # These type check, but resolve to a different type. + # list(int), want list(wrapper(int)) + "type_deductions/wrappers/wrapper_promotion", + # list(null), want list(Message) + "type_deductions/legacy_nullable_types/null_assignable_to_message_parameter_candidate", + "type_deductions/legacy_nullable_types/null_assignable_to_abstract_parameter_candidate", + "type_deductions/legacy_nullable_types/null_assignable_to_duration_parameter_candidate", + "type_deductions/legacy_nullable_types/null_assignable_to_timestamp_parameter_candidate", + + # Future features for CEL 1.0 + # TODO: Strong typing support for enums, specified but not implemented. + "enums/strong_proto2", + "enums/strong_proto3", +] + +conformance_test( + name = "conformance", + data = _ALL_TESTS, + skip_tests = _TESTS_TO_SKIP_LEGACY, +) + +conformance_test( + name = "conformance_maven", + data = _ALL_TESTS, + mode = MODE.MAVEN_TEST, + skip_tests = _TESTS_TO_SKIP_LEGACY, +) + +conformance_test( + name = "conformance_dashboard", + data = _ALL_TESTS, + mode = MODE.DASHBOARD, +) + +conformance_test( + name = "conformance_planner", + data = _ALL_TESTS, + skip_tests = _TESTS_TO_SKIP_PLANNER, + use_planner = True, +) diff --git a/conformance/src/test/java/dev/cel/conformance/ConformanceTest.java b/conformance/src/test/java/dev/cel/conformance/ConformanceTest.java new file mode 100644 index 000000000..db57ccb79 --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/ConformanceTest.java @@ -0,0 +1,265 @@ +// Copyright 2024 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.conformance; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; +import static dev.cel.testing.utils.ExprValueUtils.fromValue; +import static dev.cel.testing.utils.ExprValueUtils.toExprValue; + +import dev.cel.expr.Decl; +import dev.cel.expr.ExprValue; +import dev.cel.expr.MapValue; +import dev.cel.expr.Type; +import dev.cel.expr.Value; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.TypeRegistry; +import dev.cel.checker.CelChecker; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.CelProtoTypes; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.expr.conformance.test.SimpleTest; +import dev.cel.extensions.CelExtensions; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.parser.CelParser; +import dev.cel.parser.CelParserFactory; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntime.Program; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.runtime.CelRuntimeImpl; +import dev.cel.runtime.CelRuntimeLibrary; +import java.util.Map; +import org.junit.runners.model.Statement; + +// Qualifying proto2/proto3 TestAllTypes makes it less clear. +@SuppressWarnings("UnnecessarilyFullyQualified") +public final class ConformanceTest extends Statement { + + private static final CelOptions OPTIONS = + CelOptions.current() + .enableHeterogeneousNumericComparisons(true) + .enableProtoDifferencerEquality(true) + .enableOptionalSyntax(true) + .enableQuotedIdentifierSyntax(true) + .build(); + + private static final ImmutableList CANONICAL_COMPILER_EXTENSIONS = + ImmutableList.of( + CelExtensions.bindings(), + CelExtensions.comprehensions(), + CelExtensions.encoders(OPTIONS), + CelExtensions.math(OPTIONS), + CelExtensions.protos(), + CelExtensions.sets(OPTIONS), + CelExtensions.strings(), + CelOptionalLibrary.INSTANCE); + + private static final ImmutableList CANONICAL_RUNTIME_EXTENSIONS = + ImmutableList.of( + CelExtensions.comprehensions(), + CelExtensions.encoders(OPTIONS), + CelExtensions.math(OPTIONS), + CelExtensions.sets(OPTIONS), + CelExtensions.strings(), + CelOptionalLibrary.INSTANCE); + + static final TypeRegistry CONFORMANCE_TYPE_REGISTRY = + TypeRegistry.newBuilder() + .add(dev.cel.expr.conformance.proto2.TestAllTypes.getDescriptor()) + .add(dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor()) + .build(); + + static final ExtensionRegistry CONFORMANCE_EXTENSION_REGISTRY = + createConformanceExtensionRegistry(); + + private static ExtensionRegistry createConformanceExtensionRegistry() { + ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance(); + dev.cel.expr.conformance.proto2.TestAllTypesExtensions.registerAllExtensions(extensionRegistry); + return extensionRegistry; + } + + private static final CelParser PARSER_WITH_MACROS = + CelParserFactory.standardCelParserBuilder() + .setOptions(OPTIONS) + .addLibraries(CANONICAL_COMPILER_EXTENSIONS) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + + private static final CelParser PARSER_WITHOUT_MACROS = + CelParserFactory.standardCelParserBuilder() + .setOptions(OPTIONS) + .addLibraries(CANONICAL_COMPILER_EXTENSIONS) + .setStandardMacros() + .build(); + + private static CelParser getParser(SimpleTest test) { + return test.getDisableMacros() ? PARSER_WITHOUT_MACROS : PARSER_WITH_MACROS; + } + + private static CelChecker getChecker(SimpleTest test) throws Exception { + ImmutableList.Builder decls = + ImmutableList.builderWithExpectedSize(test.getTypeEnvCount()); + for (dev.cel.expr.Decl decl : test.getTypeEnvList()) { + decls.add(Decl.parseFrom(decl.toByteArray(), CONFORMANCE_EXTENSION_REGISTRY)); + } + return CelCompilerFactory.standardCelCheckerBuilder() + .setOptions(OPTIONS) + .setContainer(CelContainer.ofName(test.getContainer())) + .addDeclarations(decls.build()) + .addFileTypes(dev.cel.expr.conformance.proto2.TestAllTypesExtensions.getDescriptor()) + .addLibraries(CANONICAL_COMPILER_EXTENSIONS) + .addMessageTypes(dev.cel.expr.conformance.proto2.TestAllTypes.getDescriptor()) + .addMessageTypes(dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor()) + .build(); + } + + private static CelRuntime getRuntime(SimpleTest test, boolean usePlanner) { + CelRuntimeBuilder builder = + usePlanner ? CelRuntimeImpl.newBuilder() : CelRuntimeFactory.standardCelRuntimeBuilder(); + + builder + // CEL-Internal-2 + .setOptions(OPTIONS) + .addLibraries(CANONICAL_RUNTIME_EXTENSIONS) + .setExtensionRegistry(CONFORMANCE_EXTENSION_REGISTRY) + .addMessageTypes(dev.cel.expr.conformance.proto2.TestAllTypes.getDescriptor()) + .addMessageTypes(dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor()) + .addFileTypes(dev.cel.expr.conformance.proto2.TestAllTypesExtensions.getDescriptor()); + + if (usePlanner) { + builder.setContainer(CelContainer.ofName(test.getContainer())); + } + + return builder.build(); + } + + private static ImmutableMap getBindings(SimpleTest test) throws Exception { + ImmutableMap.Builder bindings = + ImmutableMap.builderWithExpectedSize(test.getBindingsCount()); + for (Map.Entry entry : test.getBindingsMap().entrySet()) { + bindings.put(entry.getKey(), fromExprValue(entry.getValue())); + } + return bindings.buildOrThrow(); + } + + private static Object fromExprValue(ExprValue value) throws Exception { + switch (value.getKindCase()) { + case VALUE: + return fromValue( + value.getValue(), CONFORMANCE_TYPE_REGISTRY, CONFORMANCE_EXTENSION_REGISTRY); + default: + throw new IllegalArgumentException( + String.format("Unexpected binding value kind: %s", value.getKindCase())); + } + } + + private static SimpleTest defaultTestMatcherToTrueIfUnset(SimpleTest test) { + if (test.getResultMatcherCase() == SimpleTest.ResultMatcherCase.RESULTMATCHER_NOT_SET) { + return test.toBuilder().setValue(Value.newBuilder().setBoolValue(true).build()).build(); + } + return test; + } + + private final String name; + private final SimpleTest test; + private final boolean skip; + private final boolean usePlanner; + + public ConformanceTest(String name, SimpleTest test, boolean skip, boolean usePlanner) { + this.name = Preconditions.checkNotNull(name); + this.test = + Preconditions.checkNotNull( + defaultTestMatcherToTrueIfUnset(Preconditions.checkNotNull(test))); + this.skip = skip; + this.usePlanner = usePlanner; + } + + public String getName() { + return name; + } + + public boolean shouldSkip() { + return skip; + } + + @Override + public void evaluate() throws Throwable { + CelValidationResult response = getParser(test).parse(test.getExpr(), test.getName()); + assertThat(response.hasError()).isFalse(); + if (!test.getDisableCheck()) { + response = getChecker(test).check(response.getAst()); + } + assertThat(response.hasError()).isFalse(); + Type resultType = CelProtoTypes.celTypeToType(response.getAst().getResultType()); + + if (test.getCheckOnly()) { + assertThat(test.hasTypedResult()).isTrue(); + assertThat(resultType).isEqualTo(test.getTypedResult().getDeducedType()); + return; + } + + if (!usePlanner && test.getDisableCheck()) { + // Only planner supports parsed-only evaluation + return; + } + + CelRuntime runtime = getRuntime(test, usePlanner); + ExprValue result = null; + CelEvaluationException error = null; + try { + Program program = runtime.createProgram(response.getAst()); + result = toExprValue(program.eval(getBindings(test)), response.getAst().getResultType()); + } catch (CelEvaluationException e) { + error = e; + } + switch (test.getResultMatcherCase()) { + case VALUE: + assertThat(error).isNull(); + assertThat(result).isNotNull(); + assertThat(result) + .ignoringRepeatedFieldOrderOfFieldDescriptors( + MapValue.getDescriptor().findFieldByName("entries")) + .unpackingAnyUsing(CONFORMANCE_TYPE_REGISTRY, CONFORMANCE_EXTENSION_REGISTRY) + .isEqualTo(ExprValue.newBuilder().setValue(test.getValue()).build()); + break; + case EVAL_ERROR: + assertThat(result).isNull(); + assertThat(error).isNotNull(); + break; + case TYPED_RESULT: + assertThat(error).isNull(); + assertThat(result).isNotNull(); + assertThat(result) + .ignoringRepeatedFieldOrderOfFieldDescriptors( + MapValue.getDescriptor().findFieldByName("entries")) + .unpackingAnyUsing(CONFORMANCE_TYPE_REGISTRY, CONFORMANCE_EXTENSION_REGISTRY) + .isEqualTo(ExprValue.newBuilder().setValue(test.getTypedResult().getResult()).build()); + assertThat(resultType).isEqualTo(test.getTypedResult().getDeducedType()); + break; + default: + throw new IllegalStateException( + String.format("Unexpected matcher kind: %s", test.getResultMatcherCase())); + } + } +} diff --git a/conformance/src/test/java/dev/cel/conformance/ConformanceTestRunner.java b/conformance/src/test/java/dev/cel/conformance/ConformanceTestRunner.java new file mode 100644 index 000000000..4c3631d31 --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/ConformanceTestRunner.java @@ -0,0 +1,132 @@ +// Copyright 2024 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.conformance; + +import static dev.cel.conformance.ConformanceTest.CONFORMANCE_EXTENSION_REGISTRY; + +import com.google.common.base.Preconditions; +import com.google.common.base.Splitter; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSortedMap; +import com.google.protobuf.TextFormat; +import dev.cel.expr.conformance.test.SimpleTest; +import dev.cel.expr.conformance.test.SimpleTestFile; +import dev.cel.expr.conformance.test.SimpleTestSection; +import java.io.BufferedReader; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.List; +import org.junit.runner.Description; +import org.junit.runner.notification.RunNotifier; +import org.junit.runners.ParentRunner; +import org.junit.runners.model.InitializationError; +import org.junit.runners.model.TestClass; + +public final class ConformanceTestRunner extends ParentRunner { + + private static final Splitter SPLITTER = Splitter.on(",").omitEmptyStrings(); + + private final ImmutableSortedMap testFiles; + private final ImmutableList testsToSkip; + private final boolean usePlanner; + + private static ImmutableSortedMap loadTestFiles() { + List testPaths = + SPLITTER.splitToList(System.getProperty("dev.cel.conformance.ConformanceTests.tests")); + try { + TextFormat.Parser parser = + TextFormat.Parser.newBuilder() + .setTypeRegistry(ConformanceTest.CONFORMANCE_TYPE_REGISTRY) + .build(); + ImmutableSortedMap.Builder testFiles = + ImmutableSortedMap.naturalOrder(); + for (String testPath : testPaths) { + SimpleTestFile.Builder fileBuilder = SimpleTestFile.newBuilder(); + try (BufferedReader input = + Files.newBufferedReader(Paths.get(testPath), StandardCharsets.UTF_8)) { + parser.merge(input, CONFORMANCE_EXTENSION_REGISTRY, fileBuilder); + } + SimpleTestFile testFile = fileBuilder.build(); + testFiles.put(testFile.getName(), testFile); + } + return testFiles.buildOrThrow(); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + public ConformanceTestRunner(Class clazz) throws InitializationError { + super(new TestClass(clazz)); + Preconditions.checkArgument(ConformanceTests.class.equals(clazz)); + testFiles = loadTestFiles(); + testsToSkip = + ImmutableList.copyOf( + SPLITTER.splitToList( + System.getProperty("dev.cel.conformance.ConformanceTests.skip_tests"))); + usePlanner = + Boolean.parseBoolean( + System.getProperty("dev.cel.conformance.ConformanceTests.use_planner", "false")); + } + + private boolean shouldSkipTest(String name) { + for (String testToSkip : testsToSkip) { + if (name.startsWith(testToSkip)) { + String consumedName = name.substring(testToSkip.length()); + if (consumedName.isEmpty() || consumedName.startsWith("/")) { + return true; + } + } + } + return false; + } + + @Override + protected List getChildren() { + ArrayList tests = new ArrayList<>(); + for (SimpleTestFile testFile : testFiles.values()) { + for (SimpleTestSection testSection : testFile.getSectionList()) { + for (SimpleTest test : testSection.getTestList()) { + String name = + String.format("%s/%s/%s", testFile.getName(), testSection.getName(), test.getName()); + tests.add(new ConformanceTest(name, test, shouldSkipTest(name), usePlanner)); + } + } + } + return tests; + } + + @Override + protected Description describeChild(ConformanceTest child) { + return Description.createTestDescription( + ConformanceTests.class, child.getName(), ConformanceTest.class.getAnnotations()); + } + + @Override + protected void runChild(ConformanceTest child, RunNotifier notifier) { + Description desc = describeChild(child); + if (isIgnored(child)) { + notifier.fireTestIgnored(desc); + } else { + runLeaf(child, desc, notifier); + } + } + + @Override + protected boolean isIgnored(ConformanceTest child) { + return child.shouldSkip(); + } +} diff --git a/conformance/src/test/java/dev/cel/conformance/ConformanceTests.java b/conformance/src/test/java/dev/cel/conformance/ConformanceTests.java new file mode 100644 index 000000000..58de114ba --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/ConformanceTests.java @@ -0,0 +1,20 @@ +// Copyright 2024 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.conformance; + +import org.junit.runner.RunWith; + +@RunWith(ConformanceTestRunner.class) +public class ConformanceTests {} diff --git a/conformance/src/test/java/dev/cel/conformance/conformance_test.bzl b/conformance/src/test/java/dev/cel/conformance/conformance_test.bzl new file mode 100644 index 000000000..b91ce4a8b --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/conformance_test.bzl @@ -0,0 +1,116 @@ +# Copyright 2024 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. + +""" +This module contains build rules for generating the conformance test targets. +""" + +load("@rules_java//java:defs.bzl", "java_test") +load("@rules_shell//shell:sh_test.bzl", "sh_test") + +# Converts the list of tests to skip from the format used by the original Go test runner to a single +# flag value where each test is separated by a comma. It also performs expansion, for example +# `foo/bar,baz` becomes two entries which are `foo/bar` and `foo/baz`. +def _expand_tests_to_skip(tests_to_skip): + result = [] + for test_to_skip in tests_to_skip: + comma = test_to_skip.find(",") + if comma == -1: + result.append(test_to_skip) + continue + slash = test_to_skip.rfind("/", 0, comma) + if slash == -1: + slash = 0 + else: + slash = slash + 1 + for part in test_to_skip[slash:].split(","): + result.append(test_to_skip[0:slash] + part) + return result + +def _conformance_test_args(data, skip_tests, use_planner): + return [ + "-Ddev.cel.conformance.ConformanceTests.skip_tests={}".format(",".join(_expand_tests_to_skip(skip_tests))), + "-Ddev.cel.conformance.ConformanceTests.tests={}".format(",".join(["$(location {})".format(t) for t in data])), + "-Ddev.cel.conformance.ConformanceTests.use_planner={}".format("true" if use_planner else "false"), + ] + +MODE = struct( + # Standard test execution against HEAD + TEST = "test", + # Executes conformance test against published jar in maven central + MAVEN_TEST = "maven_test", + # Dashboard mode + DASHBOARD = "dashboard", +) + +def conformance_test(name, data, mode = MODE.TEST, skip_tests = [], use_planner = False): + """Executes conformance tests + + Args: + name: unique label for the java_test + data: A list of test data files + mode: An enum that determines the test configuration. + - `MODE.TEST` (default): Runs the conformance tests + - `MODE.DASHBOARD`: Runs the conformance tests for displaying on dashboard. + - `MODE.MAVEN_TEST`: Runs the conformance tests against published JAR in maven central. + skip_tests: A list of strings, where each string is the name of a test file to + exclude from the run. + """ + if mode == MODE.DASHBOARD: + java_test( + name = "_" + name, + jvm_flags = _conformance_test_args(data, skip_tests, use_planner), + data = data, + size = "small", + test_class = "dev.cel.conformance.ConformanceTests", + runtime_deps = ["//conformance/src/test/java/dev/cel/conformance:run"], + tags = [ + "manual", + "notap", + ], + ) + + sh_test( + name = name, + size = "small", + srcs = ["//conformance/src/test/java/dev/cel/conformance:conformance_test.sh"], + args = ["$(location :_" + name + ")"], + data = [":_" + name], + tags = [ + "guitar", + "manual", + "notap", + ], + ) + elif mode == MODE.TEST: + java_test( + name = name, + jvm_flags = _conformance_test_args(data, skip_tests, use_planner), + data = data, + size = "small", + test_class = "dev.cel.conformance.ConformanceTests", + runtime_deps = ["//conformance/src/test/java/dev/cel/conformance:run"], + ) + elif mode == MODE.MAVEN_TEST: + java_test( + name = name, + jvm_flags = _conformance_test_args(data, skip_tests, use_planner), + data = data, + size = "small", + test_class = "dev.cel.conformance.ConformanceTests", + tags = ["conformance_maven"], + runtime_deps = ["//conformance/src/test/java/dev/cel/conformance:run_maven_jar"], + ) + else: + fail("Unknown mode specified: %s." % mode) diff --git a/conformance/src/test/java/dev/cel/conformance/conformance_test.sh b/conformance/src/test/java/dev/cel/conformance/conformance_test.sh new file mode 100755 index 000000000..c00f21c7a --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/conformance_test.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +(exec "$@") +rc = $? +if [ $rc -eq 1 ]; then + rc = 0 +fi +exit $rc diff --git a/conformance/src/test/java/dev/cel/conformance/policy/BUILD.bazel b/conformance/src/test/java/dev/cel/conformance/policy/BUILD.bazel new file mode 100644 index 000000000..e4d80eccf --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/policy/BUILD.bazel @@ -0,0 +1,36 @@ +load("@rules_java//java:defs.bzl", "java_library") +load(":cel_policy_conformance_test.bzl", "cel_policy_conformance_test_java") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, +) + +java_library( + name = "run", + srcs = glob(["*.java"]), + deps = [ + "//:auto_value", + "//:java_truth", + "//bundle:cel", + "//policy:parser_factory", + "//policy:validation_exception", + "//policy/testing:k8s_test_tag_handler", + "//runtime:function_binding", + "//testing/testrunner:cel_expression_source", + "//testing/testrunner:cel_test_context", + "//testing/testrunner:cel_test_suite", + "//testing/testrunner:cel_test_suite_text_proto_parser", + "//testing/testrunner:cel_test_suite_yaml_parser", + "//testing/testrunner:test_runner_library", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:junit_junit", + ], +) + +cel_policy_conformance_test_java( + name = "policy_conformance_tests", + testdata = "@cel_policy//conformance:testdata", +) diff --git a/conformance/src/test/java/dev/cel/conformance/policy/PolicyConformanceTest.java b/conformance/src/test/java/dev/cel/conformance/policy/PolicyConformanceTest.java new file mode 100644 index 000000000..d7851bb72 --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/policy/PolicyConformanceTest.java @@ -0,0 +1,114 @@ +// 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.conformance.policy; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.protobuf.Struct; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.policy.CelPolicyParserFactory; +import dev.cel.policy.CelPolicyValidationException; +import dev.cel.policy.testing.K8sTagHandler; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.testing.testrunner.CelExpressionSource; +import dev.cel.testing.testrunner.CelTestContext; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase; +import dev.cel.testing.testrunner.TestRunnerLibrary; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Locale; +import org.junit.runners.model.Statement; + +/** Statement representing a single CEL policy conformance test case. */ +public final class PolicyConformanceTest extends Statement { + + private static final Cel CEL = + CelFactory.standardCelBuilder() + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "locationCode", + CelFunctionBinding.from( + "locationCode_string", + String.class, + (ip) -> { + switch (ip) { + case "10.0.0.1": + return "us"; + case "10.0.0.2": + return "de"; + default: + return "ir"; + } + }))) + .build(); + + private final String name; + private final CelTestCase testCase; + private final String dirPath; + + public PolicyConformanceTest(String name, CelTestCase testCase, String dirPath) { + this.name = name; + this.testCase = testCase; + this.dirPath = dirPath; + } + + public String getName() { + return name; + } + + @Override + public void evaluate() throws Throwable { + String policyFile = Paths.get(dirPath, "policy.yaml").toString(); + + CelTestContext.Builder contextBuilder = + CelTestContext.newBuilder() + .setCelExpression(CelExpressionSource.fromSource(policyFile)) + .setCel(CEL) + .addFileTypes( + TestAllTypes.getDescriptor().getFile(), + Struct.getDescriptor().getFile()); + + // Scopes the custom Kubernetes tag visitor exclusively to k8s tests to prevent non-standard + // grammar leakage. + if (name.startsWith("k8s/")) { + contextBuilder.setCelPolicyParser( + CelPolicyParserFactory.newYamlParserBuilder().addTagVisitor(new K8sTagHandler()).build()); + } + + Path yamlConfigPath = Paths.get(dirPath, "config.yaml"); + Path textprotoConfigPath = Paths.get(dirPath, "config.textproto"); + + if (Files.exists(yamlConfigPath)) { + contextBuilder.setConfigFile(yamlConfigPath.toString()); + } else if (Files.exists(textprotoConfigPath)) { + contextBuilder.setConfigFile(textprotoConfigPath.toString()); + } + + try { + TestRunnerLibrary.runTest(testCase, contextBuilder.build()); + } catch (CelPolicyValidationException e) { + if (testCase.output().kind() == CelTestCase.Output.Kind.EVAL_ERROR) { + String expectedError = testCase.output().evalError().get(0).toString(); + assertThat(e.getMessage().toLowerCase(Locale.US)) + .contains(expectedError.toLowerCase(Locale.US)); + } else { + throw e; + } + } + } +} diff --git a/conformance/src/test/java/dev/cel/conformance/policy/PolicyConformanceTestRunner.java b/conformance/src/test/java/dev/cel/conformance/policy/PolicyConformanceTestRunner.java new file mode 100644 index 000000000..62812b124 --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/policy/PolicyConformanceTestRunner.java @@ -0,0 +1,219 @@ +// 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.conformance.policy; + +import static java.nio.charset.StandardCharsets.UTF_8; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Splitter; +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.io.Files; +import com.google.protobuf.ListValue; +import com.google.protobuf.Struct; +import com.google.protobuf.TypeRegistry; +import com.google.protobuf.Value; +import dev.cel.testing.testrunner.CelTestSuite; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase; +import dev.cel.testing.testrunner.CelTestSuiteTextProtoParser; +import dev.cel.testing.testrunner.CelTestSuiteYamlParser; +import java.io.File; +import java.util.Arrays; +import java.util.List; +import org.junit.runner.Description; +import org.junit.runner.notification.RunNotifier; +import org.junit.runners.ParentRunner; +import org.junit.runners.model.InitializationError; + +/** Custom JUnit runner for CEL policy conformance tests. */ +public final class PolicyConformanceTestRunner extends ParentRunner { + + private static final Splitter SPLITTER = Splitter.on(",").omitEmptyStrings(); + private static final String TESTS_YAML_FILE_NAME = "tests.yaml"; + private static final String TESTS_TEXTPROTO_FILE_NAME = "tests.textproto"; + private static final String POLICY_YAML_FILE_NAME = "policy.yaml"; + private static final TypeRegistry TYPE_REGISTRY = + TypeRegistry.newBuilder() + .add(Struct.getDescriptor()) + .add(Value.getDescriptor()) + .add(ListValue.getDescriptor()) + .build(); + + private static final String TEST_DIRS_PROP = + System.getProperty("dev.cel.policy.conformance.tests"); + private static final String TESTDATA_DIR = + System.getProperty("dev.cel.policy.conformance.testdata_dir", "testdata"); + private static final String SKIP_TESTS_PROP = + System.getProperty("dev.cel.policy.conformance.skip_tests"); + + private static final ImmutableList TESTS_TO_SKIP = + Strings.isNullOrEmpty(SKIP_TESTS_PROP) + ? ImmutableList.of() + : ImmutableList.copyOf(SPLITTER.splitToList(SKIP_TESTS_PROP)); + + private static final ImmutableList TEST_DIRS = + Strings.isNullOrEmpty(TEST_DIRS_PROP) + ? discoverTestDirs(TESTDATA_DIR) + : ImmutableList.copyOf(SPLITTER.splitToList(TEST_DIRS_PROP)); + + private static ImmutableList discoverTestDirs(String testdataDir) { + File dir = new File(testdataDir); + if (!dir.exists() || !dir.isDirectory()) { + return ImmutableList.of(); + } + File[] topLevelDirs = dir.listFiles(File::isDirectory); + if (topLevelDirs == null) { + return ImmutableList.of(); + } + + ImmutableList.Builder testDirsBuilder = ImmutableList.builder(); + Arrays.sort(topLevelDirs); + for (File topLevelDir : topLevelDirs) { + if (hasTestSuite(topLevelDir)) { + testDirsBuilder.add(topLevelDir.getName()); + continue; + } + + // Check one level deeper to support nested tests like compile_errors/unreachable + File[] subDirs = topLevelDir.listFiles(File::isDirectory); + if (subDirs == null) { + continue; + } + + Arrays.sort(subDirs); + for (File subDir : subDirs) { + if (hasTestSuite(subDir)) { + testDirsBuilder.add(topLevelDir.getName() + "/" + subDir.getName()); + } + } + } + + return testDirsBuilder.build(); + } + + private static boolean hasTestSuite(File dir) { + return (new File(dir, TESTS_YAML_FILE_NAME).exists() + || new File(dir, TESTS_TEXTPROTO_FILE_NAME).exists()) + && new File(dir, POLICY_YAML_FILE_NAME).exists(); + } + + private final ImmutableList tests; + + private ImmutableList loadTests() { + if (TEST_DIRS.isEmpty()) { + return ImmutableList.of(); + } + + ImmutableList.Builder testsBuilder = ImmutableList.builder(); + + for (String dir : TEST_DIRS) { + String fullDirPath = TESTDATA_DIR + "/" + dir; + try { + ImmutableList suites = readTestSuites(fullDirPath); + for (CelTestSuiteContext namedSuite : suites) { + for (CelTestSection section : namedSuite.testSuite().sections()) { + for (CelTestCase testCase : section.tests()) { + String baseName = String.format("%s/%s/%s", dir, section.name(), testCase.name()); + String displayName = baseName + namedSuite.formatSuffix(); + if (!shouldSkipTest(baseName, TESTS_TO_SKIP)) { + testsBuilder.add(new PolicyConformanceTest(displayName, testCase, fullDirPath)); + } + } + } + } + } catch (Exception e) { + throw new RuntimeException("Failed to load test suite in " + fullDirPath, e); + } + } + return testsBuilder.build(); + } + + private static boolean shouldSkipTest(String name, List testsToSkip) { + for (String testToSkip : testsToSkip) { + if (name.startsWith(testToSkip)) { + String consumedName = name.substring(testToSkip.length()); + if (consumedName.isEmpty() || consumedName.startsWith("/")) { + return true; + } + } + } + return false; + } + + private static ImmutableList readTestSuites(String dirPath) + throws Exception { + File dir = new File(dirPath); + File yamlFile = new File(dir, TESTS_YAML_FILE_NAME); + File textprotoFile = new File(dir, TESTS_TEXTPROTO_FILE_NAME); + + boolean bothExist = yamlFile.exists() && textprotoFile.exists(); + ImmutableList.Builder suitesBuilder = ImmutableList.builder(); + + if (yamlFile.exists()) { + suitesBuilder.add( + CelTestSuiteContext.create( + CelTestSuiteYamlParser.newInstance() + .parse(Files.asCharSource(yamlFile, UTF_8).read()), + bothExist ? " (yaml)" : "")); + } + if (textprotoFile.exists()) { + suitesBuilder.add( + CelTestSuiteContext.create( + CelTestSuiteTextProtoParser.newInstance() + .parse(Files.asCharSource(textprotoFile, UTF_8).read(), TYPE_REGISTRY), + bothExist ? " (textproto)" : "")); + } + + ImmutableList suites = suitesBuilder.build(); + if (suites.isEmpty()) { + throw new IllegalArgumentException( + String.format( + "No %s or %s found in %s", TESTS_YAML_FILE_NAME, TESTS_TEXTPROTO_FILE_NAME, dirPath)); + } + return suites; + } + + @Override + protected ImmutableList getChildren() { + return tests; + } + + @Override + protected Description describeChild(PolicyConformanceTest child) { + return Description.createTestDescription(getTestClass().getJavaClass(), child.getName()); + } + + @Override + protected void runChild(PolicyConformanceTest child, RunNotifier notifier) { + runLeaf(child, describeChild(child), notifier); + } + + public PolicyConformanceTestRunner(Class clazz) throws InitializationError { + super(clazz); + this.tests = loadTests(); + } + + @AutoValue + abstract static class CelTestSuiteContext { + abstract CelTestSuite testSuite(); + + abstract String formatSuffix(); + + static CelTestSuiteContext create(CelTestSuite testSuite, String formatSuffix) { + return new AutoValue_PolicyConformanceTestRunner_CelTestSuiteContext(testSuite, formatSuffix); + } + } +} diff --git a/conformance/src/test/java/dev/cel/conformance/policy/PolicyConformanceTests.java b/conformance/src/test/java/dev/cel/conformance/policy/PolicyConformanceTests.java new file mode 100644 index 000000000..46596763e --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/policy/PolicyConformanceTests.java @@ -0,0 +1,21 @@ +// 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.conformance.policy; + +import org.junit.runner.RunWith; + +/** Main test class for CEL policy conformance tests. */ +@RunWith(PolicyConformanceTestRunner.class) +public class PolicyConformanceTests {} diff --git a/conformance/src/test/java/dev/cel/conformance/policy/cel_policy_conformance_test.bzl b/conformance/src/test/java/dev/cel/conformance/policy/cel_policy_conformance_test.bzl new file mode 100644 index 000000000..b53d982bb --- /dev/null +++ b/conformance/src/test/java/dev/cel/conformance/policy/cel_policy_conformance_test.bzl @@ -0,0 +1,54 @@ +# 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. + +"""Macro to run CEL policy conformance tests.""" + +load("@rules_java//java:defs.bzl", "java_test") + +def cel_policy_conformance_test_java( + name, + testdata, + test_cases = [], + skip_tests = [], + **kwargs): + """Macro to run CEL policy conformance tests for Java. + + Args: + name: The name of the test target. + testdata: Testdata filegroup target. + test_cases: (optional) List of test case names (directory names) to run. + skip_tests: (optional) List of test case names (directory names) to skip. + **kwargs: Other standard Bazel target attributes. + """ + + lbl = native.package_relative_label(testdata) + + # Under Bzlmod, external repository runfiles are located in sibling directories + # named after their canonical repository name. + repo_prefix = "../" + lbl.workspace_name + "/" if lbl.workspace_name else "" + testdata_dir = repo_prefix + lbl.package + "/" + lbl.name + + java_test( + name = name, + jvm_flags = [ + "-Ddev.cel.policy.conformance.tests=" + ",".join(test_cases), + "-Ddev.cel.policy.conformance.testdata_dir=" + testdata_dir, + "-Ddev.cel.policy.conformance.skip_tests=" + ",".join(skip_tests), + ], + data = [testdata], + size = "small", + test_class = "dev.cel.conformance.policy.PolicyConformanceTests", + runtime_deps = [Label(":run")], + **kwargs + ) diff --git a/conformance/src/test/java/dev/cel/maven/BUILD.bazel b/conformance/src/test/java/dev/cel/maven/BUILD.bazel new file mode 100644 index 000000000..895339521 --- /dev/null +++ b/conformance/src/test/java/dev/cel/maven/BUILD.bazel @@ -0,0 +1,47 @@ +load("@rules_java//java:defs.bzl", "java_test") + +package(default_applicable_licenses = [ + "//:license", +]) + +# keep sorted +MAVEN_COMPILER_JAR_DEPS = [ + "@maven_conformance//:dev_cel_common", + "@maven_conformance//:dev_cel_compiler", +] + +# keep sorted +MAVEN_RUNTIME_JAR_DEPS = [ + "@maven_conformance//:dev_cel_common", + "@maven_conformance//:dev_cel_protobuf", + "@maven_conformance//:dev_cel_runtime", +] + +java_test( + name = "compiler_artifact_test", + srcs = ["CompilerArtifactTest.java"], + test_class = "dev.cel.maven.CompilerArtifactTest", + deps = + MAVEN_COMPILER_JAR_DEPS + [ + "//:java_truth", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "runtime_artifact_test", + srcs = ["RuntimeArtifactTest.java"], + test_class = "dev.cel.maven.RuntimeArtifactTest", + deps = + MAVEN_RUNTIME_JAR_DEPS + [ + "//:java_truth", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) diff --git a/conformance/src/test/java/dev/cel/maven/CompilerArtifactTest.java b/conformance/src/test/java/dev/cel/maven/CompilerArtifactTest.java new file mode 100644 index 000000000..dcdedb157 --- /dev/null +++ b/conformance/src/test/java/dev/cel/maven/CompilerArtifactTest.java @@ -0,0 +1,106 @@ +// 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.maven; + +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.TestParameterInjector; +import dev.cel.checker.CelChecker; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.parser.CelParser; +import dev.cel.parser.CelParserFactory; +import dev.cel.parser.CelStandardMacro; +import dev.cel.parser.CelUnparser; +import dev.cel.parser.CelUnparserFactory; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CompilerArtifactTest { + + @Test + public void parse() throws Exception { + CelParser parser = CelParserFactory.standardCelParserBuilder().build(); + CelUnparser unparser = CelUnparserFactory.newUnparser(); + + CelAbstractSyntaxTree ast = parser.parse("'Hello World'").getAst(); + + assertThat(ast.getExpr()).isEqualTo(CelExpr.ofConstant(1L, CelConstant.ofValue("Hello World"))); + assertThat(unparser.unparse(ast)).isEqualTo("\"Hello World\""); + } + + @Test + public void typeCheck() throws Exception { + CelParser parser = CelParserFactory.standardCelParserBuilder().build(); + CelChecker checker = CelCompilerFactory.standardCelCheckerBuilder().build(); + + CelAbstractSyntaxTree ast = checker.check(parser.parse("'Hello World'").getAst()).getAst(); + + assertThat(ast.getResultType()).isEqualTo(SimpleType.STRING); + } + + @Test + public void compile() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "getThree", newGlobalOverload("getThree_overload", SimpleType.INT))) + .setOptions(CelOptions.DEFAULT) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setTypeProvider( + ProtoMessageTypeProvider.newBuilder() + .addFileDescriptors(TestAllTypes.getDescriptor().getFile()) + .build()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelUnparser unparser = CelUnparserFactory.newUnparser(); + + CelAbstractSyntaxTree ast = + compiler.compile("msg == TestAllTypes{} && 3 == getThree()").getAst(); + + assertThat(unparser.unparse(ast)) + .isEqualTo("msg == cel.expr.conformance.proto3.TestAllTypes{} && 3 == getThree()"); + assertThat(ast.getResultType()).isEqualTo(SimpleType.BOOL); + } + + @Test + public void compile_error() { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + + CelValidationResult result = compiler.compile("'foo' + 1"); + + assertThat(result.hasError()).isTrue(); + assertThat(assertThrows(CelValidationException.class, result::getAst)) + .hasMessageThat() + .contains("found no matching overload for '_+_' applied to '(string, int)'"); + } +} diff --git a/conformance/src/test/java/dev/cel/maven/RuntimeArtifactTest.java b/conformance/src/test/java/dev/cel/maven/RuntimeArtifactTest.java new file mode 100644 index 000000000..e129b85d3 --- /dev/null +++ b/conformance/src/test/java/dev/cel/maven/RuntimeArtifactTest.java @@ -0,0 +1,413 @@ +// 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.maven; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.expr.CheckedExpr; +import com.google.common.collect.ImmutableList; +import com.google.protobuf.TextFormat; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.runtime.CelStandardFunctions; +import dev.cel.runtime.CelStandardFunctions.StandardFunction; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class RuntimeArtifactTest { + + // Serialized expr: [TestAllTypes{single_int64: 1}.single_int64, 2].exists(x, x == 2) + private static final String CHECKED_EXPR = + "reference_map {\n" + + " key: 2\n" + + " value {\n" + + " name: \"cel.expr.conformance.proto3.TestAllTypes\"\n" + + " }\n" + + "}\n" + + "reference_map {\n" + + " key: 7\n" + + " value {\n" + + " overload_id: \"getThree_overload\"\n" + + " }\n" + + "}\n" + + "reference_map {\n" + + " key: 10\n" + + " value {\n" + + " name: \"x\"\n" + + " }\n" + + "}\n" + + "reference_map {\n" + + " key: 11\n" + + " value {\n" + + " overload_id: \"greater_equals_int64\"\n" + + " }\n" + + "}\n" + + "reference_map {\n" + + " key: 14\n" + + " value {\n" + + " name: \"@result\"\n" + + " }\n" + + "}\n" + + "reference_map {\n" + + " key: 15\n" + + " value {\n" + + " overload_id: \"not_strictly_false\"\n" + + " }\n" + + "}\n" + + "reference_map {\n" + + " key: 16\n" + + " value {\n" + + " name: \"@result\"\n" + + " }\n" + + "}\n" + + "reference_map {\n" + + " key: 17\n" + + " value {\n" + + " overload_id: \"logical_and\"\n" + + " }\n" + + "}\n" + + "reference_map {\n" + + " key: 18\n" + + " value {\n" + + " name: \"@result\"\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 1\n" + + " value {\n" + + " list_type {\n" + + " elem_type {\n" + + " primitive: INT64\n" + + " }\n" + + " }\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 2\n" + + " value {\n" + + " message_type: \"cel.expr.conformance.proto3.TestAllTypes\"\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 4\n" + + " value {\n" + + " primitive: INT64\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 5\n" + + " value {\n" + + " primitive: INT64\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 6\n" + + " value {\n" + + " primitive: INT64\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 7\n" + + " value {\n" + + " primitive: INT64\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 10\n" + + " value {\n" + + " primitive: INT64\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 11\n" + + " value {\n" + + " primitive: BOOL\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 12\n" + + " value {\n" + + " primitive: INT64\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 13\n" + + " value {\n" + + " primitive: BOOL\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 14\n" + + " value {\n" + + " primitive: BOOL\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 15\n" + + " value {\n" + + " primitive: BOOL\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 16\n" + + " value {\n" + + " primitive: BOOL\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 17\n" + + " value {\n" + + " primitive: BOOL\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 18\n" + + " value {\n" + + " primitive: BOOL\n" + + " }\n" + + "}\n" + + "type_map {\n" + + " key: 19\n" + + " value {\n" + + " primitive: BOOL\n" + + " }\n" + + "}\n" + + "expr {\n" + + " id: 19\n" + + " comprehension_expr {\n" + + " iter_var: \"x\"\n" + + " iter_range {\n" + + " id: 1\n" + + " list_expr {\n" + + " elements {\n" + + " id: 5\n" + + " select_expr {\n" + + " operand {\n" + + " id: 2\n" + + " struct_expr {\n" + + " message_name: \"cel.expr.conformance.proto3.TestAllTypes\"\n" + + " entries {\n" + + " id: 3\n" + + " field_key: \"single_int64\"\n" + + " value {\n" + + " id: 4\n" + + " const_expr {\n" + + " int64_value: 1\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " field: \"single_int64\"\n" + + " }\n" + + " }\n" + + " elements {\n" + + " id: 6\n" + + " const_expr {\n" + + " int64_value: 2\n" + + " }\n" + + " }\n" + + " elements {\n" + + " id: 7\n" + + " call_expr {\n" + + " function: \"getThree\"\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " accu_var: \"@result\"\n" + + " accu_init {\n" + + " id: 13\n" + + " const_expr {\n" + + " bool_value: true\n" + + " }\n" + + " }\n" + + " loop_condition {\n" + + " id: 15\n" + + " call_expr {\n" + + " function: \"@not_strictly_false\"\n" + + " args {\n" + + " id: 14\n" + + " ident_expr {\n" + + " name: \"@result\"\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " loop_step {\n" + + " id: 17\n" + + " call_expr {\n" + + " function: \"_&&_\"\n" + + " args {\n" + + " id: 16\n" + + " ident_expr {\n" + + " name: \"@result\"\n" + + " }\n" + + " }\n" + + " args {\n" + + " id: 11\n" + + " call_expr {\n" + + " function: \"_>=_\"\n" + + " args {\n" + + " id: 10\n" + + " ident_expr {\n" + + " name: \"x\"\n" + + " }\n" + + " }\n" + + " args {\n" + + " id: 12\n" + + " const_expr {\n" + + " int64_value: 0\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " result {\n" + + " id: 18\n" + + " ident_expr {\n" + + " name: \"@result\"\n" + + " }\n" + + " }\n" + + " }\n" + + "}\n" + + "source_info {\n" + + " location: \"\"\n" + + " line_offsets: 75\n" + + " positions {\n" + + " key: 1\n" + + " value: 0\n" + + " }\n" + + " positions {\n" + + " key: 2\n" + + " value: 13\n" + + " }\n" + + " positions {\n" + + " key: 3\n" + + " value: 26\n" + + " }\n" + + " positions {\n" + + " key: 4\n" + + " value: 28\n" + + " }\n" + + " positions {\n" + + " key: 5\n" + + " value: 30\n" + + " }\n" + + " positions {\n" + + " key: 6\n" + + " value: 45\n" + + " }\n" + + " positions {\n" + + " key: 7\n" + + " value: 56\n" + + " }\n" + + " positions {\n" + + " key: 9\n" + + " value: 64\n" + + " }\n" + + " positions {\n" + + " key: 10\n" + + " value: 67\n" + + " }\n" + + " positions {\n" + + " key: 11\n" + + " value: 69\n" + + " }\n" + + " positions {\n" + + " key: 12\n" + + " value: 72\n" + + " }\n" + + " positions {\n" + + " key: 13\n" + + " value: 63\n" + + " }\n" + + " positions {\n" + + " key: 14\n" + + " value: 63\n" + + " }\n" + + " positions {\n" + + " key: 15\n" + + " value: 63\n" + + " }\n" + + " positions {\n" + + " key: 16\n" + + " value: 63\n" + + " }\n" + + " positions {\n" + + " key: 17\n" + + " value: 63\n" + + " }\n" + + " positions {\n" + + " key: 18\n" + + " value: 63\n" + + " }\n" + + " positions {\n" + + " key: 19\n" + + " value: 63\n" + + " }\n" + + "}\n"; + + @Test + public void eval() throws Exception { + CelRuntime runtime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setOptions(CelOptions.DEFAULT) + .setStandardEnvironmentEnabled(false) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "getThree", + CelFunctionBinding.from("getThree_overload", ImmutableList.of(), arg -> 3L))) + .setStandardFunctions( + CelStandardFunctions.newBuilder() + .includeFunctions( + StandardFunction.GREATER_EQUALS, + StandardFunction.LOGICAL_NOT, + StandardFunction.NOT_STRICTLY_FALSE) + .build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .build(); + CheckedExpr checkedExpr = TextFormat.parse(CHECKED_EXPR, CheckedExpr.class); + CelAbstractSyntaxTree ast = CelProtoAbstractSyntaxTree.fromCheckedExpr(checkedExpr).getAst(); + + boolean result = (boolean) runtime.createProgram(ast).eval(); + + assertThat(result).isTrue(); + } + + @Test + public void eval_error() throws Exception { + CelRuntime runtime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .build(); + CheckedExpr checkedExpr = TextFormat.parse(CHECKED_EXPR, CheckedExpr.class); + CelAbstractSyntaxTree ast = CelProtoAbstractSyntaxTree.fromCheckedExpr(checkedExpr).getAst(); + + assertThat(assertThrows(CelEvaluationException.class, () -> runtime.createProgram(ast).eval())) + .hasMessageThat() + .contains("No matching overload for function 'getThree'"); + } +} diff --git a/extensions/BUILD.bazel b/extensions/BUILD.bazel new file mode 100644 index 000000000..dea4cd760 --- /dev/null +++ b/extensions/BUILD.bazel @@ -0,0 +1,63 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "extensions", + exports = ["//extensions/src/main/java/dev/cel/extensions"], +) + +java_library( + name = "extension_library", + exports = ["//extensions/src/main/java/dev/cel/extensions:extension_library"], +) + +java_library( + name = "lite_extensions", + visibility = ["//:internal"], + exports = ["//extensions/src/main/java/dev/cel/extensions:lite_extensions"], +) + +cel_android_library( + name = "lite_extensions_android", + exports = ["//extensions/src/main/java/dev/cel/extensions:lite_extensions_android"], +) + +java_library( + name = "strings", + exports = ["//extensions/src/main/java/dev/cel/extensions:strings"], +) + +java_library( + name = "math", + exports = ["//extensions/src/main/java/dev/cel/extensions:math"], +) + +java_library( + name = "optional_library", + exports = ["//extensions/src/main/java/dev/cel/extensions:optional_library"], +) + +java_library( + name = "sets", + exports = ["//extensions/src/main/java/dev/cel/extensions:sets"], +) + +java_library( + name = "sets_function", + exports = ["//extensions/src/main/java/dev/cel/extensions:sets_function"], +) + +java_library( + name = "comprehensions", + exports = ["//extensions/src/main/java/dev/cel/extensions:comprehensions"], +) + +java_library( + name = "native", + exports = ["//extensions/src/main/java/dev/cel/extensions:native"], +) diff --git a/extensions/src/main/java/dev/cel/extensions/BUILD.bazel b/extensions/src/main/java/dev/cel/extensions/BUILD.bazel new file mode 100644 index 000000000..b25fdf16d --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/BUILD.bazel @@ -0,0 +1,346 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//extensions:__pkg__", + "//publish:__pkg__", + ], +) + +java_library( + name = "extension_library", + srcs = ["CelExtensionLibrary.java"], + tags = [ + ], + deps = [ + "//common:compiler_common", + "//parser:macro", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "extensions", + srcs = ["CelExtensions.java"], + tags = [ + ], + deps = [ + ":bindings", + ":comprehensions", + ":encoders", + ":lists", + ":math", + ":native", + ":optional_library", + ":protos", + ":regex", + ":sets", + ":sets_function", + ":strings", + "//common:options", + "//extensions:extension_library", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "lite_extensions", + srcs = ["CelLiteExtensions.java"], + tags = [ + ], + deps = [ + ":sets_function", + ":sets_runtime_impl", + "//common:options", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "lite_extensions_android", + srcs = ["CelLiteExtensions.java"], + tags = [ + ], + deps = [ + ":sets_function", + ":sets_runtime_impl_android", + "//common:options", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "strings", + srcs = ["CelStringExtensions.java"], + tags = [ + ], + deps = [ + "//checker:checker_builder", + "//common:compiler_common", + "//common/internal", + "//common/types", + "//compiler:compiler_builder", + "//extensions:extension_library", + "//runtime", + "//runtime:evaluation_exception_builder", + "//runtime:function_binding", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "protos", + srcs = ["CelProtoExtensions.java"], + deps = [ + "//common:compiler_common", + "//common/ast", + "//common/internal", + "//compiler:compiler_builder", + "//extensions:extension_library", + "//parser:macro", + "//parser:parser_builder", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "math", + srcs = ["CelMathExtensions.java"], + tags = [ + ], + deps = [ + ":extension_library", + "//checker:checker_builder", + "//common:compiler_common", + "//common/ast", + "//common/exceptions:numeric_overflow", + "//common/internal:comparison_functions", + "//common/types", + "//compiler:compiler_builder", + "//parser:macro", + "//parser:parser_builder", + "//runtime", + "//runtime:function_binding", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "bindings", + srcs = ["CelBindingsExtensions.java"], + deps = [ + "//common:compiler_common", + "//common/ast", + "//common/types", + "//compiler:compiler_builder", + "//extensions:extension_library", + "//parser:macro", + "//parser:parser_builder", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "encoders", + srcs = ["CelEncoderExtensions.java"], + deps = [ + "//checker:checker_builder", + "//common:compiler_common", + "//common:options", + "//common/types", + "//common/values:cel_byte_string", + "//compiler:compiler_builder", + "//extensions:extension_library", + "//runtime", + "//runtime:function_binding", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "optional_library", + srcs = ["CelOptionalLibrary.java"], + tags = [ + ], + deps = [ + "//checker:checker_builder", + "//common:compiler_common", + "//common:operator", + "//common:options", + "//common/ast", + "//common/types", + "//common/values", + "//common/values:cel_byte_string", + "//common/values:cel_value", + "//compiler:compiler_builder", + "//extensions:extension_library", + "//parser:macro", + "//parser:parser_builder", + "//runtime", + "//runtime:function_binding", + "//runtime:runtime_equality", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "sets", + srcs = ["CelSetsExtensions.java"], + tags = [ + ], + deps = [ + ":sets_function", + ":sets_runtime_impl", + "//checker:checker_builder", + "//common:compiler_common", + "//common:options", + "//common/internal:default_message_factory", + "//common/internal:dynamic_proto", + "//common/types", + "//compiler:compiler_builder", + "//extensions:extension_library", + "//runtime", + "//runtime:proto_message_runtime_equality", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "sets_function", + srcs = ["SetsFunction.java"], + # used_by_android + tags = [ + ], +) + +java_library( + name = "sets_runtime_impl", + srcs = ["SetsExtensionsRuntimeImpl.java"], + visibility = ["//visibility:private"], + deps = [ + ":sets_function", + "//runtime:function_binding", + "//runtime:lite_runtime", + "//runtime:runtime_equality", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "sets_runtime_impl_android", + srcs = ["SetsExtensionsRuntimeImpl.java"], + visibility = ["//visibility:private"], + deps = [ + ":sets_function", + "//runtime:function_binding_android", + "//runtime:lite_runtime_android", + "//runtime:runtime_equality_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "lists", + srcs = ["CelListsExtensions.java"], + tags = [ + ], + deps = [ + "//checker:checker_builder", + "//common:compiler_common", + "//common:operator", + "//common:options", + "//common/ast", + "//common/internal:comparison_functions", + "//common/types", + "//compiler:compiler_builder", + "//extensions:extension_library", + "//parser:macro", + "//parser:parser_builder", + "//runtime", + "//runtime:function_binding", + "//runtime:runtime_equality", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "regex", + srcs = ["CelRegexExtensions.java"], + deps = [ + "//checker:checker_builder", + "//common:compiler_common", + "//common/types", + "//compiler:compiler_builder", + "//extensions:extension_library", + "//runtime", + "//runtime:function_binding", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_re2j_re2j", + ], +) + +java_library( + name = "comprehensions", + srcs = ["CelComprehensionsExtensions.java"], + deps = [ + "//checker:checker_builder", + "//common:compiler_common", + "//common:operator", + "//common:options", + "//common/ast", + "//common/types", + "//common/values:mutable_map_value", + "//compiler:compiler_builder", + "//extensions:extension_library", + "//parser:macro", + "//parser:parser_builder", + "//runtime", + "//runtime:function_binding", + "//runtime:runtime_equality", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "native", + srcs = ["CelNativeTypesExtensions.java"], + tags = [ + ], + deps = [ + "//checker:checker_builder", + "//common/exceptions:attribute_not_found", + "//common/exceptions:invalid_argument", + "//common/internal:reflection_util", + "//common/types", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_byte_string", + "//common/values:cel_value", + "//common/values:cel_value_provider", + "//compiler:compiler_builder", + "//runtime", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) diff --git a/extensions/src/main/java/dev/cel/extensions/CelBindingsExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelBindingsExtensions.java new file mode 100644 index 000000000..0e6537334 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelBindingsExtensions.java @@ -0,0 +1,135 @@ +// Copyright 2023 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.extensions; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelIssue; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeParamType; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelMacroExprFactory; +import dev.cel.parser.CelParserBuilder; +import java.util.Optional; + +/** Internal implementation of the CEL local binding extensions. */ +@Immutable +public final class CelBindingsExtensions + implements CelCompilerLibrary, CelExtensionLibrary.FeatureSet { + private static final String CEL_NAMESPACE = "cel"; + private static final String UNUSED_ITER_VAR = "#unused"; + + private static final CelExtensionLibrary LIBRARY = + new CelExtensionLibrary() { + private final CelBindingsExtensions version0 = new CelBindingsExtensions(); + + @Override + public String name() { + return "bindings"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0); + } + }; + + static CelExtensionLibrary library() { + return LIBRARY; + } + + @Override + public int version() { + return 0; + } + + @Override + public ImmutableSet functions() { + // TODO: Add bindings for block once decorator support is available. + return ImmutableSet.of( + CelFunctionDecl.newFunctionDeclaration( + "cel.@block", + CelOverloadDecl.newGlobalOverload( + "cel_block_list", + TypeParamType.create("T"), + ListType.create(SimpleType.DYN), + TypeParamType.create("T")))); + } + + @Override + public ImmutableSet macros() { + return ImmutableSet.of(CelMacro.newReceiverMacro("bind", 3, CelBindingsExtensions::expandBind)); + } + + @Override + public void setParserOptions(CelParserBuilder parserBuilder) { + parserBuilder.addMacros(macros()); + } + + /** + * The {@code expandBind} maps a variable name to an initialization expression, allowing the + * variable to be used in the subsequent result expression. + */ + private static Optional expandBind( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(target); + if (!isTargetInNamespace(target)) { + // Return empty to indicate that we're not interested in expanding this macro, and + // that the parser should default to a function call on the receiver. + return Optional.empty(); + } + + checkNotNull(exprFactory); + checkArgument(arguments.size() == 3); + + CelExpr varIdent = checkNotNull(arguments.get(0)); + if (varIdent.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of( + exprFactory.reportError( + CelIssue.formatError( + exprFactory.getSourceLocation(varIdent), + "cel.bind() variable name must be a simple identifier"))); + } + String varName = varIdent.ident().name(); + CelExpr varInit = checkNotNull(arguments.get(1)); + CelExpr resultExpr = checkNotNull(arguments.get(2)); + + return Optional.of( + exprFactory.fold( + UNUSED_ITER_VAR, + exprFactory.newList(), + varName, + varInit, + exprFactory.newBoolLiteral(false), + exprFactory.newIdentifier(varName), + resultExpr)); + } + + private static boolean isTargetInNamespace(CelExpr target) { + return target.exprKind().getKind().equals(CelExpr.ExprKind.Kind.IDENT) + && target.ident().name().equals(CEL_NAMESPACE); + } + + CelBindingsExtensions() {} +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelComprehensionsExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelComprehensionsExtensions.java new file mode 100644 index 000000000..14968099c --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelComprehensionsExtensions.java @@ -0,0 +1,513 @@ +// Copyright 2025 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.extensions; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelIssue; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.types.MapType; +import dev.cel.common.types.TypeParamType; +import dev.cel.common.values.MutableMapValue; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelMacroExprFactory; +import dev.cel.parser.CelParserBuilder; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelInternalRuntimeLibrary; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.RuntimeEquality; +import java.util.Map; +import java.util.Optional; + +/** Internal implementation of CEL two variable comprehensions extensions. */ +public final class CelComprehensionsExtensions + implements CelCompilerLibrary, CelInternalRuntimeLibrary, CelExtensionLibrary.FeatureSet { + + private static final String MAP_INSERT_FUNCTION = "cel.@mapInsert"; + private static final String MAP_INSERT_OVERLOAD_MAP_MAP = "cel_@mapInsert_map_map"; + private static final String MAP_INSERT_OVERLOAD_KEY_VALUE = "cel_@mapInsert_map_key_value"; + private static final TypeParamType TYPE_PARAM_K = TypeParamType.create("K"); + private static final TypeParamType TYPE_PARAM_V = TypeParamType.create("V"); + private static final MapType MAP_KV_TYPE = MapType.create(TYPE_PARAM_K, TYPE_PARAM_V); + + enum Function { + MAP_INSERT( + CelFunctionDecl.newFunctionDeclaration( + MAP_INSERT_FUNCTION, + CelOverloadDecl.newGlobalOverload( + MAP_INSERT_OVERLOAD_MAP_MAP, + "Returns a map that's the result of merging given two maps.", + MAP_KV_TYPE, + MAP_KV_TYPE, + MAP_KV_TYPE), + CelOverloadDecl.newGlobalOverload( + MAP_INSERT_OVERLOAD_KEY_VALUE, + "Adds the given key-value pair to the map.", + MAP_KV_TYPE, + MAP_KV_TYPE, + TYPE_PARAM_K, + TYPE_PARAM_V))); + + private final CelFunctionDecl functionDecl; + + String getFunction() { + return functionDecl.name(); + } + + Function(CelFunctionDecl functionDecl) { + this.functionDecl = functionDecl; + } + } + + private static final CelExtensionLibrary LIBRARY = + new CelExtensionLibrary() { + private final CelComprehensionsExtensions version0 = new CelComprehensionsExtensions(); + + @Override + public String name() { + return "comprehensions"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0); + } + }; + + static CelExtensionLibrary library() { + return LIBRARY; + } + + private final ImmutableSet functions; + + CelComprehensionsExtensions() { + this.functions = ImmutableSet.copyOf(Function.values()); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + functions.forEach(function -> checkerBuilder.addFunctionDeclarations(function.functionDecl)); + } + + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + throw new UnsupportedOperationException("Unsupported"); + } + + @Override + public void setRuntimeOptions( + CelRuntimeBuilder runtimeBuilder, RuntimeEquality runtimeEquality, CelOptions celOptions) { + runtimeBuilder.addFunctionBindings( + CelFunctionBinding.fromOverloads( + MAP_INSERT_FUNCTION, + CelFunctionBinding.from( + MAP_INSERT_OVERLOAD_MAP_MAP, + Map.class, + Map.class, + (map1, map2) -> mapInsertMap(map1, map2, runtimeEquality)), + CelFunctionBinding.from( + MAP_INSERT_OVERLOAD_KEY_VALUE, + ImmutableList.of(Map.class, Object.class, Object.class), + args -> mapInsertKeyValue(args, runtimeEquality)))); + } + + @Override + public int version() { + return 0; + } + + @Override + public ImmutableSet macros() { + return ImmutableSet.of( + CelMacro.newReceiverMacro( + Operator.ALL.getFunction(), 3, CelComprehensionsExtensions::expandAllMacro), + CelMacro.newReceiverMacro( + Operator.EXISTS.getFunction(), 3, CelComprehensionsExtensions::expandExistsMacro), + CelMacro.newReceiverMacro( + Operator.EXISTS_ONE.getFunction(), + 3, + CelComprehensionsExtensions::expandExistsOneMacro), + CelMacro.newReceiverMacro( + Operator.EXISTS_ONE_NEW.getFunction(), + 3, + CelComprehensionsExtensions::expandExistsOneMacro), + CelMacro.newReceiverMacro( + "transformList", 3, CelComprehensionsExtensions::transformListMacro), + CelMacro.newReceiverMacro( + "transformList", 4, CelComprehensionsExtensions::transformListMacro), + CelMacro.newReceiverMacro( + "transformMap", 3, CelComprehensionsExtensions::transformMapMacro), + CelMacro.newReceiverMacro( + "transformMap", 4, CelComprehensionsExtensions::transformMapMacro), + CelMacro.newReceiverMacro( + "transformMapEntry", 3, CelComprehensionsExtensions::transformMapEntryMacro), + CelMacro.newReceiverMacro( + "transformMapEntry", 4, CelComprehensionsExtensions::transformMapEntryMacro)); + } + + @Override + public void setParserOptions(CelParserBuilder parserBuilder) { + parserBuilder.addMacros(macros()); + } + + private static Map mapInsertMap( + Map targetMap, Map mapToMerge, RuntimeEquality equality) { + for (Object key : mapToMerge.keySet()) { + if (equality.findInMap(targetMap, key).isPresent()) { + throw new IllegalArgumentException( + String.format("insert failed: key '%s' already exists", key)); + } + } + + if (targetMap instanceof MutableMapValue) { + MutableMapValue wrapper = (MutableMapValue) targetMap; + wrapper.putAll(mapToMerge); + return wrapper; + } + + return ImmutableMap.builderWithExpectedSize(targetMap.size() + mapToMerge.size()) + .putAll(targetMap) + .putAll(mapToMerge) + .buildOrThrow(); + } + + private static Map mapInsertKeyValue(Object[] args, RuntimeEquality equality) { + Map mapArg = (Map) args[0]; + Object key = args[1]; + Object value = args[2]; + + if (equality.findInMap(mapArg, key).isPresent()) { + throw new IllegalArgumentException( + String.format("insert failed: key '%s' already exists", key)); + } + + if (mapArg instanceof MutableMapValue) { + MutableMapValue mutableMap = (MutableMapValue) mapArg; + mutableMap.put(key, value); + return mutableMap; + } + + ImmutableMap.Builder builder = + ImmutableMap.builderWithExpectedSize(mapArg.size() + 1); + return builder.put(key, value).putAll(mapArg).buildOrThrow(); + } + + private static Optional expandAllMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 3); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = validatedIterationVariable(exprFactory, arguments.get(1)); + if (arg1.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg1); + } + CelExpr arg2 = checkNotNull(arguments.get(2)); + CelExpr accuInit = exprFactory.newBoolLiteral(true); + CelExpr condition = + exprFactory.newGlobalCall( + Operator.NOT_STRICTLY_FALSE.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + CelExpr step = + exprFactory.newGlobalCall( + Operator.LOGICAL_AND.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + arg2); + CelExpr result = exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()); + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + arg1.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + result)); + } + + private static Optional expandExistsMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 3); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = validatedIterationVariable(exprFactory, arguments.get(1)); + if (arg1.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg1); + } + CelExpr arg2 = checkNotNull(arguments.get(2)); + CelExpr accuInit = exprFactory.newBoolLiteral(false); + CelExpr condition = + exprFactory.newGlobalCall( + Operator.NOT_STRICTLY_FALSE.getFunction(), + exprFactory.newGlobalCall( + Operator.LOGICAL_NOT.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()))); + CelExpr step = + exprFactory.newGlobalCall( + Operator.LOGICAL_OR.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + arg2); + CelExpr result = exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()); + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + arg1.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + result)); + } + + private static Optional expandExistsOneMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 3); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = validatedIterationVariable(exprFactory, arguments.get(1)); + if (arg1.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg1); + } + CelExpr arg2 = checkNotNull(arguments.get(2)); + CelExpr accuInit = exprFactory.newIntLiteral(0); + CelExpr condition = exprFactory.newBoolLiteral(true); + CelExpr step = + exprFactory.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + arg2, + exprFactory.newGlobalCall( + Operator.ADD.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + exprFactory.newIntLiteral(1)), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + CelExpr result = + exprFactory.newGlobalCall( + Operator.EQUALS.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + exprFactory.newIntLiteral(1)); + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + arg1.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + result)); + } + + private static Optional transformListMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 3 || arguments.size() == 4); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = validatedIterationVariable(exprFactory, arguments.get(1)); + if (arg1.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg1); + } + CelExpr transform; + CelExpr filter = null; + if (arguments.size() == 4) { + filter = checkNotNull(arguments.get(2)); + transform = checkNotNull(arguments.get(3)); + } else { + transform = checkNotNull(arguments.get(2)); + } + CelExpr accuInit = exprFactory.newList(); + CelExpr condition = exprFactory.newBoolLiteral(true); + CelExpr step = + exprFactory.newGlobalCall( + Operator.ADD.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + exprFactory.newList(transform)); + if (filter != null) { + step = + exprFactory.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + filter, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + } + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + arg1.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()))); + } + + private static Optional transformMapMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 3 || arguments.size() == 4); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = validatedIterationVariable(exprFactory, arguments.get(1)); + if (arg1.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg1); + } + CelExpr transform; + CelExpr filter = null; + if (arguments.size() == 4) { + filter = checkNotNull(arguments.get(2)); + transform = checkNotNull(arguments.get(3)); + } else { + transform = checkNotNull(arguments.get(2)); + } + CelExpr accuInit = exprFactory.newMap(); + CelExpr condition = exprFactory.newBoolLiteral(true); + CelExpr step = + exprFactory.newGlobalCall( + MAP_INSERT_FUNCTION, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + arg0, + transform); + if (filter != null) { + step = + exprFactory.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + filter, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + } + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + arg1.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()))); + } + + private static Optional transformMapEntryMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 3 || arguments.size() == 4); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = validatedIterationVariable(exprFactory, arguments.get(1)); + if (arg1.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg1); + } + CelExpr transform; + CelExpr filter = null; + if (arguments.size() == 4) { + filter = checkNotNull(arguments.get(2)); + transform = checkNotNull(arguments.get(3)); + } else { + transform = checkNotNull(arguments.get(2)); + } + CelExpr accuInit = exprFactory.newMap(); + CelExpr condition = exprFactory.newBoolLiteral(true); + CelExpr step = + exprFactory.newGlobalCall( + MAP_INSERT_FUNCTION, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + transform); + if (filter != null) { + step = + exprFactory.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + filter, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + } + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + arg1.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()))); + } + + private static CelExpr validatedIterationVariable( + CelMacroExprFactory exprFactory, CelExpr argument) { + CelExpr arg = checkNotNull(argument); + if (!isSimpleIdentifier(arg)) { + return reportArgumentError(exprFactory, arg); + } else if (arg.exprKind().ident().name().equals("__result__")) { + return reportAccumulatorOverwriteError(exprFactory, arg); + } else { + return arg; + } + } + + private static boolean isSimpleIdentifier(CelExpr expr) { + return expr.getKind() == CelExpr.ExprKind.Kind.IDENT + && !expr.ident().name().isEmpty() + && !expr.ident().name().startsWith("."); + } + + private static CelExpr reportArgumentError(CelMacroExprFactory exprFactory, CelExpr argument) { + return exprFactory.reportError( + CelIssue.formatError( + exprFactory.getSourceLocation(argument), "The argument must be a simple name")); + } + + private static CelExpr reportAccumulatorOverwriteError( + CelMacroExprFactory exprFactory, CelExpr argument) { + return exprFactory.reportError( + CelIssue.formatError( + exprFactory.getSourceLocation(argument), + String.format( + "The iteration variable %s overwrites accumulator variable", + argument.ident().name()))); + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelEncoderExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelEncoderExtensions.java new file mode 100644 index 000000000..498b8555e --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelEncoderExtensions.java @@ -0,0 +1,153 @@ +// Copyright 2023 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.extensions; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.ByteString; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.types.SimpleType; +import dev.cel.common.values.CelByteString; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeLibrary; +import java.util.Base64; +import java.util.Base64.Decoder; +import java.util.Base64.Encoder; + +/** Internal implementation of Encoder Extensions. */ +@Immutable +public class CelEncoderExtensions + implements CelCompilerLibrary, CelRuntimeLibrary, CelExtensionLibrary.FeatureSet { + + private static final Encoder BASE64_ENCODER = Base64.getEncoder(); + + private static final Decoder BASE64_DECODER = Base64.getDecoder(); + + private final ImmutableSet functions; + private final CelOptions celOptions; + + enum Function { + DECODE( + CelFunctionDecl.newFunctionDeclaration( + "base64.decode", + CelOverloadDecl.newGlobalOverload( + "base64_decode_string", SimpleType.BYTES, SimpleType.STRING)), + CelFunctionBinding.from( + "base64_decode_string", + String.class, + str -> CelByteString.of(BASE64_DECODER.decode(str))), + CelFunctionBinding.from( + "base64_decode_string", + String.class, + str -> ByteString.copyFrom(BASE64_DECODER.decode(str)))), + ENCODE( + CelFunctionDecl.newFunctionDeclaration( + "base64.encode", + CelOverloadDecl.newGlobalOverload( + "base64_encode_bytes", SimpleType.STRING, SimpleType.BYTES)), + CelFunctionBinding.from( + "base64_encode_bytes", + CelByteString.class, + bytes -> BASE64_ENCODER.encodeToString(bytes.toByteArray())), + CelFunctionBinding.from( + "base64_encode_bytes", + ByteString.class, + bytes -> BASE64_ENCODER.encodeToString(bytes.toByteArray()))), + ; + + private final CelFunctionDecl functionDecl; + private final CelFunctionBinding nativeBytesFunctionBinding; + private final CelFunctionBinding protoBytesFunctionBinding; + + String getFunction() { + return functionDecl.name(); + } + + Function( + CelFunctionDecl functionDecl, + CelFunctionBinding nativeBytesFunctionBinding, + CelFunctionBinding protoBytesFunctionBinding) { + this.functionDecl = functionDecl; + this.nativeBytesFunctionBinding = nativeBytesFunctionBinding; + this.protoBytesFunctionBinding = protoBytesFunctionBinding; + } + } + + private static final class Library implements CelExtensionLibrary { + private final CelEncoderExtensions version0; + + @Override + public String name() { + return "encoders"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0); + } + + private Library(CelOptions celOptions) { + this.version0 = new CelEncoderExtensions(celOptions); + } + } + + static CelExtensionLibrary library(CelOptions celOptions) { + return new Library(celOptions); + } + + @Override + public int version() { + return 0; + } + + @Override + public ImmutableSet functions() { + return functions.stream().map(f -> f.functionDecl).collect(toImmutableSet()); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + functions.forEach(function -> checkerBuilder.addFunctionDeclarations(function.functionDecl)); + } + + @SuppressWarnings("Immutable") // Instances of java.util.Base64 are immutable + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + functions.forEach( + function -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + runtimeBuilder.addFunctionBindings( + CelFunctionBinding.fromOverloads( + function.getFunction(), function.nativeBytesFunctionBinding)); + } else { + runtimeBuilder.addFunctionBindings( + CelFunctionBinding.fromOverloads( + function.getFunction(), function.protoBytesFunctionBinding)); + } + }); + } + + CelEncoderExtensions(CelOptions celOptions) { + this.celOptions = celOptions; + this.functions = ImmutableSet.copyOf(Function.values()); + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelExtensionLibrary.java b/extensions/src/main/java/dev/cel/extensions/CelExtensionLibrary.java new file mode 100644 index 000000000..b7cb94297 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelExtensionLibrary.java @@ -0,0 +1,75 @@ +// Copyright 2025 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.extensions; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelVarDecl; +import dev.cel.parser.CelMacro; +import java.util.Comparator; + +/** + * Interface for defining CEL extension libraries. + * + *

An extension library is a collection of CEL functions, variables, and macros that can be added + * to a CEL environment to provide additional functionality. + */ +public interface CelExtensionLibrary { + + /** Returns the name of the extension library. */ + String name(); + + ImmutableSet versions(); + + default T latest() { + return versions().stream().max(Comparator.comparing(FeatureSet::version)).get(); + } + + default T version(int version) { + if (version == Integer.MAX_VALUE) { + return latest(); + } + + for (T v : versions()) { + if (v.version() == version) { + return v; + } + } + throw new IllegalArgumentException("Unsupported '" + name() + "' extension version " + version); + } + + /** + * Interface for defining a version of a CEL extension library. + */ + interface FeatureSet { + /** Returns the extension library version or -1 if unspecified. */ + int version(); + + /** Returns the set of function declarations defined by this extension library. */ + default ImmutableSet functions() { + return ImmutableSet.of(); + } + + /** Returns the set of macros defined by this extension library. */ + default ImmutableSet macros() { + return ImmutableSet.of(); + } + + /** Returns the set of variables defined by this extension library. */ + default ImmutableSet variables() { + return ImmutableSet.of(); + } + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelExtensions.java new file mode 100644 index 000000000..446fa26e7 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelExtensions.java @@ -0,0 +1,428 @@ +// Copyright 2024 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.extensions; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Streams; +import com.google.errorprone.annotations.InlineMe; +import dev.cel.common.CelOptions; +import dev.cel.extensions.CelMathExtensions.Function; +import java.util.EnumSet; +import java.util.Set; +import java.util.stream.Stream; + +/** + * Collections of CEL Extensions. + * + *

To use, supply the desired extensions into {@code CelCompiler} and {@code CelRuntime} through + * their builders: {@code CelCompilerBuilder#addLibraries} and {@code + * CelRuntimeBuilder#addLibraries}. + */ +public final class CelExtensions { + private static final CelStringExtensions STRING_EXTENSIONS_ALL = new CelStringExtensions(); + private static final CelProtoExtensions PROTO_EXTENSIONS = new CelProtoExtensions(); + private static final CelBindingsExtensions BINDINGS_EXTENSIONS = new CelBindingsExtensions(); + private static final CelRegexExtensions REGEX_EXTENSIONS = new CelRegexExtensions(); + private static final CelComprehensionsExtensions COMPREHENSIONS_EXTENSIONS = + new CelComprehensionsExtensions(); + + /** + * Implementation of optional values. + * + *

Refer to README.md for available functions. + */ + public static CelOptionalLibrary optional() { + return CelOptionalLibrary.library().latest(); + } + + /** + * Implementation of optional values. + * + *

Refer to README.md for available functions for each supported version. + */ + public static CelOptionalLibrary optional(int version) { + return CelOptionalLibrary.library().version(version); + } + + /** + * Extended functions for string manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include all functions denoted in {@link CelStringExtensions.Function}, including + * any future additions. To expose only a subset of functions, use {@link + * #strings(CelStringExtensions.Function...)} instead. + */ + public static CelStringExtensions strings() { + return STRING_EXTENSIONS_ALL; + } + + /** + * Extended functions for string manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include only the specific functions denoted by {@link + * CelStringExtensions.Function}. + */ + public static CelStringExtensions strings(CelStringExtensions.Function... functions) { + return strings(ImmutableSet.copyOf(functions)); + } + + /** + * Extended functions for string manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include only the specific functions denoted by {@link + * CelStringExtensions.Function}. + */ + public static CelStringExtensions strings(Set functions) { + return new CelStringExtensions(functions); + } + + /** + * Extended macros for proto manipulation. + * + *

This adds {@code proto.getExt} and {@code proto.hasExt}. See README.md for their + * documentation. + * + *

Note, these functions use the 'proto' namespace; however, at the time of macro expansion the + * namespace looks just like any other identifier. If you are currently using a variable named + * 'proto', the macro will likely work just as intended; however, there is some chance for + * collision. + */ + public static CelProtoExtensions protos() { + return PROTO_EXTENSIONS; + } + + /** + * Extended math helper macros and functions. + * + *

This adds {@code math.greatest} and {@code math.least}. See README.md for their + * documentation. + * + *

Note, all macros use the 'math' namespace; however, at the time of macro expansion the + * namespace looks just like any other identifier. If you are currently using a variable named + * 'math', the macro will likely work just as intended; however, there is some chance for + * collision. + * + *

This will include all functions denoted in {@link CelMathExtensions.Function}, including any + * future additions. To expose only a subset of these, use {@link #math(CelOptions, + * CelMathExtensions.Function...)} or {@link #math(CelOptions,int)} instead. + */ + public static CelMathExtensions math() { + return CelMathExtensions.library().latest(); + } + + /** + * Returns the specified version of the 'math' extension. + * + *

Refer to README.md for functions available in each version. + */ + public static CelMathExtensions math(int version) { + return CelMathExtensions.library().version(version); + } + + /** + * Extended math helper macros and functions. + * + *

This adds {@code math.greatest} and {@code math.least}. See README.md for their + * documentation. + * + *

Note, all macros use the 'math' namespace; however, at the time of macro * expansion the + * namespace looks just like any other identifier. If you are currently using a variable named + * 'math', the macro will likely work just as intended; however, there is some chance for + * collision. + * + *

This will include only the specific functions denoted by {@link CelMathExtensions.Function}. + */ + public static CelMathExtensions math(CelMathExtensions.Function... functions) { + return math(ImmutableSet.copyOf(functions)); + } + + /** + * Extended math helper macros and functions. + * + *

This adds {@code math.greatest} and {@code math.least}. See README.md for their + * documentation. + * + *

Note, all macros use the 'math' namespace; however, at the time of macro * expansion the + * namespace looks just like any other identifier. If you are currently using a variable named + * 'math', the macro will likely work just as intended; however, there is some chance for + * collision. + * + *

This will include only the specific functions denoted by {@link CelMathExtensions.Function}. + */ + public static CelMathExtensions math(Set functions) { + return new CelMathExtensions(functions); + } + + /** + * @deprecated Use {@link #math()} instead. + */ + @Deprecated + @InlineMe(replacement = "CelExtensions.math()", imports = "dev.cel.extensions.CelExtensions") + public static CelMathExtensions math(CelOptions unused) { + return math(); + } + + /** + * @deprecated Use {@link #math(int)} instead. + */ + @Deprecated + @InlineMe( + replacement = "CelExtensions.math(version)", + imports = "dev.cel.extensions.CelExtensions") + public static CelMathExtensions math(CelOptions unused, int version) { + return math(version); + } + + /** + * @deprecated Use {@link #math(Function...)} instead. + */ + @Deprecated + public static CelMathExtensions math(CelOptions unused, CelMathExtensions.Function... functions) { + return math(ImmutableSet.copyOf(functions)); + } + + /** + * @deprecated Use {@link #math(Set)} instead. + */ + @Deprecated + @InlineMe( + replacement = "CelExtensions.math(functions)", + imports = "dev.cel.extensions.CelExtensions") + public static CelMathExtensions math( + CelOptions unused, Set functions) { + return math(functions); + } + + /** + * Local variable binding macro(s). + * + *

This exposes {@code cel.bind} as a macro for use within expressions. See README.md for its + * documentation. + * + *

This change does not introduce any new functions, but rather leverages the comprehension AST + * to produce an expression which will introduce a new variable into the expression. + */ + public static CelBindingsExtensions bindings() { + return BINDINGS_EXTENSIONS; + } + + /** + * @deprecated Use {@link #encoders(CelOptions) instead.} + */ + @Deprecated + public static CelEncoderExtensions encoders() { + return new CelEncoderExtensions(CelOptions.DEFAULT); + } + + /** + * Extended functions for string, byte and object encodings. + * + *

This adds {@code base64.encode} and {@code base64.decode} functions. See README.md for their + * documentation. + * + * @param celOptions This should be the same {@link CelOptions} object used to configure + * compilation/runtime environments. + */ + public static CelEncoderExtensions encoders(CelOptions celOptions) { + return new CelEncoderExtensions(celOptions); + } + + /** + * Extended functions for Set manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include all functions denoted in {@link SetsFunction}, including any future + * additions. To expose only a subset of functions, use {@link #sets(CelOptions, SetsFunction...)} + * instead. + */ + public static CelSetsExtensions sets(CelOptions celOptions) { + return new CelSetsExtensions(celOptions); + } + + /** + * Extended functions for Set manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include only the specific functions denoted by {@link SetsFunction}. + */ + public static CelSetsExtensions sets(CelOptions celOptions, SetsFunction... functions) { + return sets(celOptions, ImmutableSet.copyOf(functions)); + } + + /** + * Extended functions for Set manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include only the specific functions denoted by {@link SetsFunction}. + */ + public static CelSetsExtensions sets(CelOptions celOptions, Set functions) { + return new CelSetsExtensions(celOptions, functions); + } + + /** + * Extended functions for List manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include only the specific functions denoted by {@link + * CelListsExtensions.Function}. + */ + public static CelListsExtensions lists() { + return CelListsExtensions.library().latest(); + } + + /** + * Extended functions for List manipulation. + * + *

Refer to README.md for functions available in each version. + */ + public static CelListsExtensions lists(int version) { + return CelListsExtensions.library().version(version); + } + + /** + * Extended functions for List manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include only the specific functions denoted by {@link + * CelListsExtensions.Function}. + */ + public static CelListsExtensions lists(CelListsExtensions.Function... functions) { + return lists(ImmutableSet.copyOf(functions)); + } + + /** + * Extended functions for List manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include all functions denoted in {@link CelListsExtensions.Function}, including + * any future additions. To expose only a subset of functions, use {@link + * #lists(CelListsExtensions.Function...)} instead. + */ + public static CelListsExtensions lists(Set functions) { + return new CelListsExtensions(functions); + } + + /** + * Extended functions for Regular Expressions. + * + *

Refer to README.md for available functions. + * + *

This will include all functions denoted in {@link CelRegexExtensions.Function}, including + * any future additions. + */ + public static CelRegexExtensions regex() { + return REGEX_EXTENSIONS; + } + + /** + * Extended functions for Two Variable Comprehensions Expressions. + * + *

Refer to README.md for available functions. + * + *

This will include all functions denoted in {@link CelComprehensionsExtensions.Function}, + * including any future additions. + */ + public static CelComprehensionsExtensions comprehensions() { + return COMPREHENSIONS_EXTENSIONS; + } + + /** + * Extensions for supporting native Java types (POJOs) in CEL. + * + *

Refer to README.md for details on property discovery, type mapping, and limitations. + * + *

Note: Passing classes with unsupported types or anonymous/local classes will result in an + * {@link IllegalArgumentException} when the runtime is built. + */ + public static CelNativeTypesExtensions nativeTypes(Class... classes) { + return CelNativeTypesExtensions.nativeTypes(classes); + } + + /** + * Retrieves all function names used by every extension libraries. + * + *

Note: Certain extensions such as {@link CelProtoExtensions} and {@link + * CelBindingsExtensions} are implemented via macros, not functions, and those are not included + * here. + */ + public static ImmutableSet getAllFunctionNames() { + return Streams.concat( + EnumSet.allOf(Function.class).stream().map(CelMathExtensions.Function::getFunction), + EnumSet.allOf(CelStringExtensions.Function.class).stream() + .map(CelStringExtensions.Function::getFunction), + EnumSet.allOf(SetsFunction.class).stream().map(SetsFunction::getFunction), + EnumSet.allOf(CelEncoderExtensions.Function.class).stream() + .map(CelEncoderExtensions.Function::getFunction), + EnumSet.allOf(CelListsExtensions.Function.class).stream() + .map(CelListsExtensions.Function::getFunction), + EnumSet.allOf(CelRegexExtensions.Function.class).stream() + .map(CelRegexExtensions.Function::getFunction), + Stream.of( + CelOptionalLibrary.Function.VALUE, + CelOptionalLibrary.Function.HAS_VALUE, + CelOptionalLibrary.Function.OPTIONAL_NONE, + CelOptionalLibrary.Function.OPTIONAL_OF, + CelOptionalLibrary.Function.OPTIONAL_UNWRAP, + CelOptionalLibrary.Function.OPTIONAL_OF_NON_ZERO_VALUE) + .map(CelOptionalLibrary.Function::getFunction), + EnumSet.allOf(CelComprehensionsExtensions.Function.class).stream() + .map(CelComprehensionsExtensions.Function::getFunction)) + .collect(toImmutableSet()); + } + + public static CelExtensionLibrary getExtensionLibrary( + String name, CelOptions options) { + switch (name) { + case "bindings": + return CelBindingsExtensions.library(); + case "encoders": + return CelEncoderExtensions.library(options); + case "lists": + return CelListsExtensions.library(); + case "math": + return CelMathExtensions.library(); + case "optional": + return CelOptionalLibrary.library(); + case "protos": + return CelProtoExtensions.library(); + case "regex": + return CelRegexExtensions.library(); + case "sets": + return CelSetsExtensions.library(options); + case "strings": + return CelStringExtensions.library(); + case "comprehensions": + return CelComprehensionsExtensions.library(); + // TODO: add support for remaining standard extensions + default: + throw new IllegalArgumentException("Unknown standard extension '" + name + "'"); + } + } + + private CelExtensions() {} +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelListsExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelListsExtensions.java new file mode 100644 index 000000000..79539b008 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelListsExtensions.java @@ -0,0 +1,455 @@ +// Copyright 2024 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.extensions; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelIssue; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.internal.ComparisonFunctions; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeParamType; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelMacroExprFactory; +import dev.cel.parser.CelParserBuilder; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelInternalRuntimeLibrary; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; +import java.util.Collection; +import java.util.Comparator; +import java.util.Iterator; +import java.util.List; +import java.util.Optional; +import java.util.Set; + +/** Internal implementation of CEL lists extensions. */ +public final class CelListsExtensions + implements CelCompilerLibrary, CelInternalRuntimeLibrary, CelExtensionLibrary.FeatureSet { + + /** Supported functions for Lists extension library. */ + @SuppressWarnings({"unchecked"}) // Unchecked: Type-checker guarantees casting safety. + public enum Function { + // Note! Creating dependencies on the outer class may cause circular initialization issues. + SLICE( + CelFunctionDecl.newFunctionDeclaration( + "slice", + CelOverloadDecl.newMemberOverload( + "list_slice", + "Returns a new sub-list using the indices provided", + ListType.create(TypeParamType.create("T")), + ListType.create(TypeParamType.create("T")), + SimpleType.INT, + SimpleType.INT)), + CelFunctionBinding.from( + "list_slice", + ImmutableList.of(Collection.class, Long.class, Long.class), + (args) -> { + Collection target = (Collection) args[0]; + long from = (Long) args[1]; + long to = (Long) args[2]; + return CelListsExtensions.slice(target, from, to); + })), + FLATTEN( + CelFunctionDecl.newFunctionDeclaration( + "flatten", + CelOverloadDecl.newMemberOverload( + "list_flatten", + "Flattens a list by a single level", + ListType.create(TypeParamType.create("T")), + ListType.create(ListType.create(TypeParamType.create("T")))), + CelOverloadDecl.newMemberOverload( + "list_flatten_list_int", + "Flattens a list to the specified level. A negative depth value flattens the list" + + " recursively to its deepest level.", + ListType.create(SimpleType.DYN), + ListType.create(SimpleType.DYN), + SimpleType.INT)), + CelFunctionBinding.from("list_flatten", Collection.class, list -> flatten(list, 1)), + CelFunctionBinding.from( + "list_flatten_list_int", Collection.class, Long.class, CelListsExtensions::flatten)), + RANGE( + CelFunctionDecl.newFunctionDeclaration( + "lists.range", + CelOverloadDecl.newGlobalOverload( + "lists_range", + "Returns a list of integers from 0 to n-1.", + ListType.create(SimpleType.INT), + SimpleType.INT)), + CelFunctionBinding.from("lists_range", Long.class, CelListsExtensions::genRange)), + DISTINCT( + CelFunctionDecl.newFunctionDeclaration( + "distinct", + CelOverloadDecl.newMemberOverload( + "list_distinct", + "Returns the distinct elements of a list", + ListType.create(TypeParamType.create("T")), + ListType.create(TypeParamType.create("T"))))), + REVERSE( + CelFunctionDecl.newFunctionDeclaration( + "reverse", + CelOverloadDecl.newMemberOverload( + "list_reverse", + "Returns the elements of a list in reverse order", + ListType.create(TypeParamType.create("T")), + ListType.create(TypeParamType.create("T")))), + CelFunctionBinding.from("list_reverse", Collection.class, CelListsExtensions::reverse)), + SORT( + CelFunctionDecl.newFunctionDeclaration( + "sort", + CelOverloadDecl.newMemberOverload( + "list_sort", + "Sorts a list with comparable elements.", + ListType.create(TypeParamType.create("T")), + ListType.create(TypeParamType.create("T")))), + CelFunctionBinding.from("list_sort", Collection.class, CelListsExtensions::sort)), + SORT_BY( + CelFunctionDecl.newFunctionDeclaration( + "lists.@sortByAssociatedKeys", + CelOverloadDecl.newGlobalOverload( + "list_sortByAssociatedKeys", + "Sorts a list by a key value. Used by the 'sortBy' macro", + ListType.create(TypeParamType.create("T")), + ListType.create(TypeParamType.create("T")))), + CelFunctionBinding.from( + "list_sortByAssociatedKeys", + Collection.class, + CelListsExtensions::sortByAssociatedKeys)); + + private final CelFunctionDecl functionDecl; + private final ImmutableSet functionBindings; + + String getFunction() { + return functionDecl.name(); + } + + Function(CelFunctionDecl functionDecl, CelFunctionBinding... functionBindings) { + this.functionDecl = functionDecl; + this.functionBindings = + functionBindings.length > 0 + ? CelFunctionBinding.fromOverloads(functionDecl.name(), functionBindings) + : ImmutableSet.of(); + } + } + + private static final CelExtensionLibrary LIBRARY = + new CelExtensionLibrary() { + private final CelListsExtensions version0 = + new CelListsExtensions(0, ImmutableSet.of(Function.SLICE)); + private final CelListsExtensions version1 = + new CelListsExtensions( + 1, + ImmutableSet.builder() + .addAll(version0.functions) + .add(Function.FLATTEN) + .build()); + private final CelListsExtensions version2 = + new CelListsExtensions( + 2, + ImmutableSet.builder() + .addAll(version1.functions) + .add( + Function.RANGE, + Function.DISTINCT, + Function.REVERSE, + Function.SORT, + Function.SORT_BY) + .build()); + + @Override + public String name() { + return "lists"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0, version1, version2); + } + }; + + static CelExtensionLibrary library() { + return LIBRARY; + } + + private final int version; + private final ImmutableSet functions; + + CelListsExtensions(Set functions) { + this(-1, functions); + } + + private CelListsExtensions(int version, Set functions) { + this.version = version; + this.functions = ImmutableSet.copyOf(functions); + } + + @Override + public int version() { + return version; + } + + @Override + public ImmutableSet functions() { + return functions.stream().map(f -> f.functionDecl).collect(toImmutableSet()); + } + + @Override + public ImmutableSet macros() { + if (version >= 2) { + return ImmutableSet.of( + CelMacro.newReceiverMacro("sortBy", 2, CelListsExtensions::sortByMacro)); + } + return ImmutableSet.of(); + } + + @Override + public void setParserOptions(CelParserBuilder parserBuilder) { + parserBuilder.addMacros(macros()); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + functions.forEach(function -> checkerBuilder.addFunctionDeclarations(function.functionDecl)); + } + + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + throw new UnsupportedOperationException("Unsupported"); + } + + @SuppressWarnings("unchecked") + @Override + public void setRuntimeOptions( + CelRuntimeBuilder runtimeBuilder, RuntimeEquality runtimeEquality, CelOptions celOptions) { + functions.forEach(function -> runtimeBuilder.addFunctionBindings(function.functionBindings)); + + runtimeBuilder.addFunctionBindings( + CelFunctionBinding.fromOverloads( + "distinct", + CelFunctionBinding.from( + "list_distinct", Collection.class, (list) -> distinct(list, runtimeEquality)))); + } + + private static ImmutableList slice(Collection list, long from, long to) { + Preconditions.checkArgument(from >= 0 && to >= 0, "Negative indexes not supported"); + Preconditions.checkArgument(to >= from, "Start index must be less than or equal to end index"); + Preconditions.checkArgument(to <= list.size(), "List is length %s", list.size()); + if (list instanceof List) { + List subList = ((List) list).subList((int) from, (int) to); + if (subList instanceof ImmutableList) { + return (ImmutableList) subList; + } + return ImmutableList.copyOf(subList); + } else { + ImmutableList.Builder builder = ImmutableList.builder(); + long index = 0; + for (Iterator iterator = list.iterator(); iterator.hasNext(); index++) { + Object element = iterator.next(); + if (index >= to) { + break; + } + if (index >= from) { + builder.add(element); + } + } + return builder.build(); + } + } + + @SuppressWarnings("unchecked") + private static ImmutableList flatten(Collection list, long depth) { + Preconditions.checkArgument(depth >= 0, "Level must be non-negative"); + ImmutableList.Builder builder = ImmutableList.builder(); + for (Object element : list) { + if (!(element instanceof Collection) || depth == 0) { + builder.add(element); + } else { + Collection listItem = (Collection) element; + builder.addAll(flatten(listItem, depth - 1)); + } + } + + return builder.build(); + } + + public static ImmutableList genRange(long end) { + ImmutableList.Builder builder = ImmutableList.builder(); + for (long i = 0; i < end; i++) { + builder.add(i); + } + return builder.build(); + } + + private static class RuntimeEqualityObjectWrapper { + private final Object object; + private final int hashCode; + private final RuntimeEquality runtimeEquality; + + RuntimeEqualityObjectWrapper(Object object, RuntimeEquality runtimeEquality) { + this.object = object; + this.runtimeEquality = runtimeEquality; + this.hashCode = runtimeEquality.hashCode(object); + } + + @Override + public int hashCode() { + return hashCode; + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof RuntimeEqualityObjectWrapper)) { + return false; + } + return runtimeEquality.objectEquals(object, ((RuntimeEqualityObjectWrapper) obj).object); + } + } + + private static ImmutableList distinct( + Collection list, RuntimeEquality runtimeEquality) { + int size = list.size(); + ImmutableList.Builder builder = ImmutableList.builderWithExpectedSize(size); + Set distinctValues = Sets.newHashSetWithExpectedSize(size); + for (Object element : list) { + if (distinctValues.add(new RuntimeEqualityObjectWrapper(element, runtimeEquality))) { + builder.add(element); + } + } + return builder.build(); + } + + private static List reverse(Collection list) { + if (list instanceof List) { + return Lists.reverse((List) list); + } else { + ImmutableList.Builder builder = ImmutableList.builderWithExpectedSize(list.size()); + Object[] objects = list.toArray(); + for (int i = objects.length - 1; i >= 0; i--) { + builder.add(objects[i]); + } + return builder.build(); + } + } + + private static ImmutableList sort(Collection objects) { + return ImmutableList.sortedCopyOf(new CelObjectComparator(), objects); + } + + private static class CelObjectComparator implements Comparator { + + CelObjectComparator() {} + + @SuppressWarnings({"unchecked"}) + @Override + public int compare(Object o1, Object o2) { + if (o1 instanceof Number && o2 instanceof Number) { + return ComparisonFunctions.numericCompare((Number) o1, (Number) o2); + } + + if (!(o1 instanceof Comparable)) { + throw new IllegalArgumentException("List elements must be comparable"); + } + if (o1.getClass() != o2.getClass()) { + throw new IllegalArgumentException("List elements must have the same type"); + } + return ((Comparable) o1).compareTo(o2); + } + } + + private static Optional sortByMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 2); + CelExpr varIdent = checkNotNull(arguments.get(0)); + if (varIdent.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of( + exprFactory.reportError( + CelIssue.formatError( + exprFactory.getSourceLocation(varIdent), + "sortBy(var, ...) variable name must be a simple identifier"))); + } + + String varName = varIdent.ident().name(); + CelExpr sortKeyExpr = checkNotNull(arguments.get(1)); + + // Compute the key using the second argument of the `sortBy(e, key)` macro. + // Combine the key and the value in a two-element list + CelExpr step = exprFactory.newList(sortKeyExpr, varIdent); + // Wrap the pair in another list in order to be able to use the `list+list` operator + step = exprFactory.newList(step); + // Append the key-value pair to the i + step = + exprFactory.newGlobalCall( + Operator.ADD.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + step); + // Create an intermediate list and populate it with key-value pairs + step = + exprFactory.fold( + varName, + target, + exprFactory.getAccumulatorVarName(), + exprFactory.newList(), + exprFactory.newBoolLiteral(true), // Include all elements + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + // Finally, sort the list of key-value pairs and map it to a list of values + step = exprFactory.newGlobalCall(Function.SORT_BY.getFunction(), step); + + return Optional.of(step); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + private static ImmutableList sortByAssociatedKeys( + Collection> keyValuePairs) { + List[] array = keyValuePairs.toArray(new List[0]); + Arrays.sort(array, new CelObjectByKeyComparator(new CelObjectComparator())); + ImmutableList.Builder builder = ImmutableList.builderWithExpectedSize(array.length); + for (List pair : array) { + builder.add(pair.get(1)); + } + return builder.build(); + } + + private static class CelObjectByKeyComparator implements Comparator { + private final CelObjectComparator keyComparator; + + CelObjectByKeyComparator(CelObjectComparator keyComparator) { + this.keyComparator = keyComparator; + } + + @SuppressWarnings({"unchecked"}) + @Override + public int compare(Object o1, Object o2) { + return keyComparator.compare(((List) o1).get(0), ((List) o2).get(0)); + } + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelLiteExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelLiteExtensions.java new file mode 100644 index 000000000..b46b40756 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelLiteExtensions.java @@ -0,0 +1,67 @@ +// Copyright 2025 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.extensions; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.util.Set; + +/** + * Collections of supported CEL Extensions for the lite runtime. + * + *

To use, supply the desired extensions using : {@code CelLiteRuntimeBuilder#addLibraries}. + */ +public final class CelLiteExtensions { + + /** + * Extended functions for Set manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include all functions denoted in {@link SetsFunction}, including any future + * additions. To expose only a subset of functions, use {@link #sets(CelOptions, SetsFunction...)} + * instead. + */ + public static SetsExtensionsRuntimeImpl sets(CelOptions celOptions) { + return sets(celOptions, SetsFunction.values()); + } + + /** + * Extended functions for Set manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include only the specific functions denoted by {@link SetsFunction}. + */ + public static SetsExtensionsRuntimeImpl sets(CelOptions celOptions, SetsFunction... functions) { + return sets(celOptions, ImmutableSet.copyOf(functions)); + } + + /** + * Extended functions for Set manipulation. + * + *

Refer to README.md for available functions. + * + *

This will include only the specific functions denoted by {@link SetsFunction}. + */ + public static SetsExtensionsRuntimeImpl sets(CelOptions celOptions, Set functions) { + RuntimeEquality runtimeEquality = RuntimeEquality.create(RuntimeHelpers.create(), celOptions); + return new SetsExtensionsRuntimeImpl(runtimeEquality, functions); + } + + private CelLiteExtensions() {} +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelMathExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelMathExtensions.java new file mode 100644 index 000000000..63108aa0c --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelMathExtensions.java @@ -0,0 +1,1107 @@ +// Copyright 2023 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.extensions; + +import static com.google.common.collect.Comparators.max; +import static com.google.common.collect.Comparators.min; +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.ImmutableTable; +import com.google.common.math.DoubleMath; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelIssue; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.common.internal.ComparisonFunctions; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelMacroExprFactory; +import dev.cel.parser.CelParserBuilder; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeLibrary; +import java.math.RoundingMode; +import java.util.List; +import java.util.Optional; +import java.util.Set; +import java.util.function.BiFunction; + +/** + * Internal implementation of Math Extensions + * + *

Note: For equal numbers with different types, the result is always the first argument e.g.: + * math.greatest(1u, 1.0) -> 1u + */ +@SuppressWarnings({"rawtypes", "unchecked"}) // Use of raw Comparables. +@Immutable +public final class CelMathExtensions + implements CelCompilerLibrary, CelRuntimeLibrary, CelExtensionLibrary.FeatureSet { + + private static final String MATH_NAMESPACE = "math"; + + private static final String MATH_MAX_FUNCTION = "math.@max"; + private static final String MATH_MAX_OVERLOAD_DOC = + "Returns the greatest valued number present in the arguments."; + private static final String MATH_MIN_FUNCTION = "math.@min"; + private static final String MATH_MIN_OVERLOAD_DOC = + "Returns the least valued number present in the arguments."; + + // Rounding Functions + private static final String MATH_CEIL_FUNCTION = "math.ceil"; + private static final String MATH_FLOOR_FUNCTION = "math.floor"; + private static final String MATH_ROUND_FUNCTION = "math.round"; + private static final String MATH_TRUNC_FUNCTION = "math.trunc"; + + // Floating Point Functions + private static final String MATH_ISFINITE_FUNCTION = "math.isFinite"; + private static final String MATH_ISNAN_FUNCTION = "math.isNaN"; + private static final String MATH_ISINF_FUNCTION = "math.isInf"; + + // Signedness Functions + private static final String MATH_ABS_FUNCTION = "math.abs"; + private static final String MATH_SIGN_FUNCTION = "math.sign"; + + // Bitwise Functions + private static final String MATH_BIT_AND_FUNCTION = "math.bitAnd"; + private static final String MATH_BIT_OR_FUNCTION = "math.bitOr"; + private static final String MATH_BIT_XOR_FUNCTION = "math.bitXor"; + private static final String MATH_BIT_NOT_FUNCTION = "math.bitNot"; + private static final String MATH_BIT_LEFT_SHIFT_FUNCTION = "math.bitShiftLeft"; + private static final String MATH_BIT_RIGHT_SHIFT_FUNCTION = "math.bitShiftRight"; + + private static final String MATH_SQRT_FUNCTION = "math.sqrt"; + + private static final int MAX_BIT_SHIFT = 63; + + /** + * Returns the proper comparison function to use for a math function call involving different + * argument types. + * + *

Example: (uint, int) -> {@link ComparisonFunctions#compareUintInt(UnsignedLong, long)} + */ + private static final ImmutableTable> + CLASSES_TO_COMPARATORS = newComparatorTable(); + + private static ImmutableTable> + newComparatorTable() { + ImmutableTable.Builder> builder = + new ImmutableTable.Builder<>(); + builder.put( + Long.class, + Double.class, + (x, y) -> ComparisonFunctions.compareIntDouble((Long) x, (Double) y)); + builder.put( + Double.class, + Long.class, + (x, y) -> ComparisonFunctions.compareDoubleInt((Double) x, (Long) y)); + builder.put( + Double.class, + UnsignedLong.class, + (x, y) -> ComparisonFunctions.compareDoubleUint((Double) x, (UnsignedLong) y)); + builder.put( + UnsignedLong.class, + Double.class, + (x, y) -> ComparisonFunctions.compareUintDouble((UnsignedLong) x, (Double) y)); + builder.put( + Long.class, + UnsignedLong.class, + (x, y) -> ComparisonFunctions.compareIntUint((Long) x, (UnsignedLong) y)); + builder.put( + UnsignedLong.class, + Long.class, + (x, y) -> ComparisonFunctions.compareUintInt((UnsignedLong) x, (Long) y)); + return builder.buildOrThrow(); + } + + /** Enumeration of functions for Math extension. */ + public enum Function { + MAX( + CelFunctionDecl.newFunctionDeclaration( + MATH_MAX_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_@max_double", MATH_MAX_OVERLOAD_DOC, SimpleType.DOUBLE, SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_@max_int", MATH_MAX_OVERLOAD_DOC, SimpleType.INT, SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_@max_uint", MATH_MAX_OVERLOAD_DOC, SimpleType.UINT, SimpleType.UINT), + CelOverloadDecl.newGlobalOverload( + "math_@max_double_double", + MATH_MAX_OVERLOAD_DOC, + SimpleType.DOUBLE, + SimpleType.DOUBLE, + SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_@max_int_int", + MATH_MAX_OVERLOAD_DOC, + SimpleType.INT, + SimpleType.INT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_@max_uint_uint", + MATH_MAX_OVERLOAD_DOC, + SimpleType.UINT, + SimpleType.UINT, + SimpleType.UINT), + CelOverloadDecl.newGlobalOverload( + "math_@max_int_uint", + MATH_MAX_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.INT, + SimpleType.UINT), + CelOverloadDecl.newGlobalOverload( + "math_@max_int_double", + MATH_MAX_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.INT, + SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_@max_double_int", + MATH_MAX_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.DOUBLE, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_@max_double_uint", + MATH_MAX_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.DOUBLE, + SimpleType.UINT), + CelOverloadDecl.newGlobalOverload( + "math_@max_uint_int", + MATH_MAX_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.UINT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_@max_uint_double", + MATH_MAX_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.UINT, + SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_@max_list_dyn", // Implementation supports double, int and uint as list + // literals. Anything else will error during macro expansion. + MATH_MAX_OVERLOAD_DOC, + SimpleType.DYN, + ListType.create(SimpleType.DYN))), + ImmutableSet.builder() + .add(CelFunctionBinding.from("math_@max_double", Double.class, x -> x)) + .add(CelFunctionBinding.from("math_@max_int", Long.class, x -> x)) + .add( + CelFunctionBinding.from( + "math_@max_double_double", + Double.class, + Double.class, + CelMathExtensions::maxPair)) + .add( + CelFunctionBinding.from( + "math_@max_int_int", Long.class, Long.class, CelMathExtensions::maxPair)) + .add( + CelFunctionBinding.from( + "math_@max_int_double", Long.class, Double.class, CelMathExtensions::maxPair)) + .add( + CelFunctionBinding.from( + "math_@max_double_int", Double.class, Long.class, CelMathExtensions::maxPair)) + .add( + CelFunctionBinding.from( + "math_@max_list_dyn", List.class, CelMathExtensions::maxList)) + .add(CelFunctionBinding.from("math_@max_uint", UnsignedLong.class, x -> x)) + .add( + CelFunctionBinding.from( + "math_@max_uint_uint", + UnsignedLong.class, + UnsignedLong.class, + CelMathExtensions::maxPair)) + .add( + CelFunctionBinding.from( + "math_@max_double_uint", + Double.class, + UnsignedLong.class, + CelMathExtensions::maxPair)) + .add( + CelFunctionBinding.from( + "math_@max_uint_int", + UnsignedLong.class, + Long.class, + CelMathExtensions::maxPair)) + .add( + CelFunctionBinding.from( + "math_@max_uint_double", + UnsignedLong.class, + Double.class, + CelMathExtensions::maxPair)) + .add( + CelFunctionBinding.from( + "math_@max_int_uint", + Long.class, + UnsignedLong.class, + CelMathExtensions::maxPair)) + .build()), + MIN( + CelFunctionDecl.newFunctionDeclaration( + MATH_MIN_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_@min_double", MATH_MIN_OVERLOAD_DOC, SimpleType.DOUBLE, SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_@min_int", MATH_MIN_OVERLOAD_DOC, SimpleType.INT, SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_@min_uint", MATH_MIN_OVERLOAD_DOC, SimpleType.UINT, SimpleType.UINT), + CelOverloadDecl.newGlobalOverload( + "math_@min_double_double", + MATH_MIN_OVERLOAD_DOC, + SimpleType.DOUBLE, + SimpleType.DOUBLE, + SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_@min_int_int", + MATH_MIN_OVERLOAD_DOC, + SimpleType.INT, + SimpleType.INT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_@min_uint_uint", + MATH_MIN_OVERLOAD_DOC, + SimpleType.UINT, + SimpleType.UINT, + SimpleType.UINT), + CelOverloadDecl.newGlobalOverload( + "math_@min_int_uint", + MATH_MIN_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.INT, + SimpleType.UINT), + CelOverloadDecl.newGlobalOverload( + "math_@min_int_double", + MATH_MIN_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.INT, + SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_@min_double_int", + MATH_MIN_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.DOUBLE, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_@min_double_uint", + MATH_MIN_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.DOUBLE, + SimpleType.UINT), + CelOverloadDecl.newGlobalOverload( + "math_@min_uint_int", + MATH_MIN_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.UINT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_@min_uint_double", + MATH_MIN_OVERLOAD_DOC, + SimpleType.DYN, + SimpleType.UINT, + SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_@min_list_dyn", // Implementation supports double, int and uint as list + // literals. Anything else will error during macro expansion. + MATH_MIN_OVERLOAD_DOC, + SimpleType.DYN, + ListType.create(SimpleType.DYN))), + ImmutableSet.builder() + .add(CelFunctionBinding.from("math_@min_double", Double.class, x -> x)) + .add(CelFunctionBinding.from("math_@min_int", Long.class, x -> x)) + .add( + CelFunctionBinding.from( + "math_@min_double_double", + Double.class, + Double.class, + CelMathExtensions::minPair)) + .add( + CelFunctionBinding.from( + "math_@min_int_int", Long.class, Long.class, CelMathExtensions::minPair)) + .add( + CelFunctionBinding.from( + "math_@min_int_double", Long.class, Double.class, CelMathExtensions::minPair)) + .add( + CelFunctionBinding.from( + "math_@min_double_int", Double.class, Long.class, CelMathExtensions::minPair)) + .add( + CelFunctionBinding.from( + "math_@min_list_dyn", List.class, CelMathExtensions::minList)) + .add(CelFunctionBinding.from("math_@min_uint", UnsignedLong.class, x -> x)) + .add( + CelFunctionBinding.from( + "math_@min_uint_uint", + UnsignedLong.class, + UnsignedLong.class, + CelMathExtensions::minPair)) + .add( + CelFunctionBinding.from( + "math_@min_double_uint", + Double.class, + UnsignedLong.class, + CelMathExtensions::minPair)) + .add( + CelFunctionBinding.from( + "math_@min_uint_int", + UnsignedLong.class, + Long.class, + CelMathExtensions::minPair)) + .add( + CelFunctionBinding.from( + "math_@min_uint_double", + UnsignedLong.class, + Double.class, + CelMathExtensions::minPair)) + .add( + CelFunctionBinding.from( + "math_@min_int_uint", + Long.class, + UnsignedLong.class, + CelMathExtensions::minPair)) + .build()), + CEIL( + CelFunctionDecl.newFunctionDeclaration( + MATH_CEIL_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_ceil_double", + "Compute the ceiling of a double value.", + SimpleType.DOUBLE, + SimpleType.DOUBLE)), + ImmutableSet.of(CelFunctionBinding.from("math_ceil_double", Double.class, Math::ceil))), + FLOOR( + CelFunctionDecl.newFunctionDeclaration( + MATH_FLOOR_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_floor_double", + "Compute the floor of a double value.", + SimpleType.DOUBLE, + SimpleType.DOUBLE)), + ImmutableSet.of(CelFunctionBinding.from("math_floor_double", Double.class, Math::floor))), + ROUND( + CelFunctionDecl.newFunctionDeclaration( + MATH_ROUND_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_round_double", + "Rounds the double value to the nearest whole number with ties rounding away from" + + " zero.", + SimpleType.DOUBLE, + SimpleType.DOUBLE)), + ImmutableSet.of( + CelFunctionBinding.from("math_round_double", Double.class, CelMathExtensions::round))), + TRUNC( + CelFunctionDecl.newFunctionDeclaration( + MATH_TRUNC_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_trunc_double", + "Truncates the fractional portion of the double value.", + SimpleType.DOUBLE, + SimpleType.DOUBLE)), + ImmutableSet.of( + CelFunctionBinding.from("math_trunc_double", Double.class, CelMathExtensions::trunc))), + ISFINITE( + CelFunctionDecl.newFunctionDeclaration( + MATH_ISFINITE_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_isFinite_double", + "Returns true if the value is a finite number.", + SimpleType.BOOL, + SimpleType.DOUBLE)), + ImmutableSet.of( + CelFunctionBinding.from("math_isFinite_double", Double.class, Double::isFinite))), + ISNAN( + CelFunctionDecl.newFunctionDeclaration( + MATH_ISNAN_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_isNaN_double", + "Returns true if the input double value is NaN, false otherwise.", + SimpleType.BOOL, + SimpleType.DOUBLE)), + ImmutableSet.of( + CelFunctionBinding.from("math_isNaN_double", Double.class, CelMathExtensions::isNaN))), + ISINF( + CelFunctionDecl.newFunctionDeclaration( + MATH_ISINF_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_isInf_double", + "Returns true if the input double value is -Inf or +Inf.", + SimpleType.BOOL, + SimpleType.DOUBLE)), + ImmutableSet.of( + CelFunctionBinding.from( + "math_isInf_double", Double.class, CelMathExtensions::isInfinite))), + ABS( + CelFunctionDecl.newFunctionDeclaration( + MATH_ABS_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_abs_double", + "Compute the absolute value of a double value.", + SimpleType.DOUBLE, + SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_abs_int", + "Compute the absolute value of an int value.", + SimpleType.INT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_abs_uint", + "Compute the absolute value of a uint value.", + SimpleType.UINT, + SimpleType.UINT)), + ImmutableSet.of( + CelFunctionBinding.from("math_abs_double", Double.class, Math::abs), + CelFunctionBinding.from("math_abs_int", Long.class, CelMathExtensions::absExact), + CelFunctionBinding.from("math_abs_uint", UnsignedLong.class, x -> x))), + SIGN( + CelFunctionDecl.newFunctionDeclaration( + MATH_SIGN_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_sign_double", + "Returns the sign of the input numeric type, either -1, 0, 1 cast as double.", + SimpleType.DOUBLE, + SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_sign_uint", + "Returns the sign of the input numeric type, either -1, 0, 1 case as uint.", + SimpleType.UINT, + SimpleType.UINT), + CelOverloadDecl.newGlobalOverload( + "math_sign_int", + "Returns the sign of the input numeric type, either -1, 0, 1.", + SimpleType.INT, + SimpleType.INT)), + ImmutableSet.of( + CelFunctionBinding.from("math_sign_double", Double.class, CelMathExtensions::sign), + CelFunctionBinding.from("math_sign_int", Long.class, CelMathExtensions::sign), + CelFunctionBinding.from( + "math_sign_uint", UnsignedLong.class, CelMathExtensions::sign))), + BITAND( + CelFunctionDecl.newFunctionDeclaration( + MATH_BIT_AND_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_bitAnd_int_int", + "Performs a bitwise-AND operation over two int values.", + SimpleType.INT, + SimpleType.INT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_bitAnd_uint_uint", + "Performs a bitwise-AND operation over two uint values.", + SimpleType.UINT, + SimpleType.UINT, + SimpleType.UINT)), + ImmutableSet.of( + CelFunctionBinding.from( + "math_bitAnd_int_int", Long.class, Long.class, CelMathExtensions::intBitAnd), + CelFunctionBinding.from( + "math_bitAnd_uint_uint", + UnsignedLong.class, + UnsignedLong.class, + CelMathExtensions::uintBitAnd))), + BITOR( + CelFunctionDecl.newFunctionDeclaration( + MATH_BIT_OR_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_bitOr_int_int", + "Performs a bitwise-OR operation over two int values.", + SimpleType.INT, + SimpleType.INT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_bitOr_uint_uint", + "Performs a bitwise-OR operation over two uint values.", + SimpleType.UINT, + SimpleType.UINT, + SimpleType.UINT)), + ImmutableSet.of( + CelFunctionBinding.from( + "math_bitOr_int_int", Long.class, Long.class, CelMathExtensions::intBitOr), + CelFunctionBinding.from( + "math_bitOr_uint_uint", + UnsignedLong.class, + UnsignedLong.class, + CelMathExtensions::uintBitOr))), + BITXOR( + CelFunctionDecl.newFunctionDeclaration( + MATH_BIT_XOR_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_bitXor_int_int", + "Performs a bitwise-XOR operation over two int values.", + SimpleType.INT, + SimpleType.INT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_bitXor_uint_uint", + "Performs a bitwise-XOR operation over two uint values.", + SimpleType.UINT, + SimpleType.UINT, + SimpleType.UINT)), + ImmutableSet.of( + CelFunctionBinding.from( + "math_bitXor_int_int", Long.class, Long.class, CelMathExtensions::intBitXor), + CelFunctionBinding.from( + "math_bitXor_uint_uint", + UnsignedLong.class, + UnsignedLong.class, + CelMathExtensions::uintBitXor))), + BITNOT( + CelFunctionDecl.newFunctionDeclaration( + MATH_BIT_NOT_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_bitNot_int_int", + "Performs a bitwise-NOT operation over two int values.", + SimpleType.INT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_bitNot_uint_uint", + "Performs a bitwise-NOT operation over two uint values.", + SimpleType.UINT, + SimpleType.UINT)), + ImmutableSet.of( + CelFunctionBinding.from( + "math_bitNot_int_int", Long.class, CelMathExtensions::intBitNot), + CelFunctionBinding.from( + "math_bitNot_uint_uint", UnsignedLong.class, CelMathExtensions::uintBitNot))), + BITSHIFTLEFT( + CelFunctionDecl.newFunctionDeclaration( + MATH_BIT_LEFT_SHIFT_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_bitShiftLeft_int_int", + "Performs a bitwise-SHIFTLEFT operation over two int values.", + SimpleType.INT, + SimpleType.INT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_bitShiftLeft_uint_int", + "Performs a bitwise-SHIFTLEFT operation over two uint values.", + SimpleType.UINT, + SimpleType.UINT, + SimpleType.INT)), + ImmutableSet.of( + CelFunctionBinding.from( + "math_bitShiftLeft_int_int", + Long.class, + Long.class, + CelMathExtensions::intBitShiftLeft), + CelFunctionBinding.from( + "math_bitShiftLeft_uint_int", + UnsignedLong.class, + Long.class, + CelMathExtensions::uintBitShiftLeft))), + BITSHIFTRIGHT( + CelFunctionDecl.newFunctionDeclaration( + MATH_BIT_RIGHT_SHIFT_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_bitShiftRight_int_int", + "Performs a bitwise-SHIFTRIGHT operation over two int values.", + SimpleType.INT, + SimpleType.INT, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_bitShiftRight_uint_int", + "Performs a bitwise-SHIFTRIGHT operation over two uint values.", + SimpleType.UINT, + SimpleType.UINT, + SimpleType.INT)), + ImmutableSet.of( + CelFunctionBinding.from( + "math_bitShiftRight_int_int", + Long.class, + Long.class, + CelMathExtensions::intBitShiftRight), + CelFunctionBinding.from( + "math_bitShiftRight_uint_int", + UnsignedLong.class, + Long.class, + CelMathExtensions::uintBitShiftRight))), + SQRT( + CelFunctionDecl.newFunctionDeclaration( + MATH_SQRT_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "math_sqrt_double", + "Computes square root of the double value.", + SimpleType.DOUBLE, + SimpleType.DOUBLE), + CelOverloadDecl.newGlobalOverload( + "math_sqrt_int", + "Computes square root of the int value.", + SimpleType.DOUBLE, + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "math_sqrt_uint", + "Computes square root of the unsigned value.", + SimpleType.DOUBLE, + SimpleType.UINT)), + ImmutableSet.of( + CelFunctionBinding.from( + "math_sqrt_double", Double.class, CelMathExtensions::sqrtDouble), + CelFunctionBinding.from("math_sqrt_int", Long.class, CelMathExtensions::sqrtInt), + CelFunctionBinding.from( + "math_sqrt_uint", UnsignedLong.class, CelMathExtensions::sqrtUint))); + + private final CelFunctionDecl functionDecl; + private final ImmutableSet functionBindings; + + String getFunction() { + return functionDecl.name(); + } + + Function(CelFunctionDecl functionDecl, ImmutableSet bindings) { + this.functionDecl = functionDecl; + this.functionBindings = bindings; + } + } + + private static final class Library implements CelExtensionLibrary { + private final CelMathExtensions version0; + private final CelMathExtensions version1; + private final CelMathExtensions version2; + + Library() { + version0 = new CelMathExtensions(0, ImmutableSet.of(Function.MIN, Function.MAX)); + + version1 = + new CelMathExtensions( + 1, + ImmutableSet.builder() + .addAll(version0.functions) + .add( + Function.CEIL, + Function.FLOOR, + Function.ROUND, + Function.TRUNC, + Function.ISINF, + Function.ISNAN, + Function.ISFINITE, + Function.ABS, + Function.SIGN, + Function.BITAND, + Function.BITOR, + Function.BITXOR, + Function.BITNOT, + Function.BITSHIFTLEFT, + Function.BITSHIFTRIGHT) + .build()); + + version2 = + new CelMathExtensions( + 2, + ImmutableSet.builder() + .addAll(version1.functions) + .add(Function.SQRT) + .build()); + } + + @Override + public String name() { + return "math"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0, version1, version2); + } + } + + private static final Library LIBRARY = new Library(); + + static CelExtensionLibrary library() { + return LIBRARY; + } + + private final ImmutableSet functions; + private final int version; + + CelMathExtensions(Set functions) { + this(-1, functions); + } + + private CelMathExtensions(int version, Set functions) { + this.version = version; + this.functions = ImmutableSet.copyOf(functions); + } + + @Override + public int version() { + return version; + } + + @Override + public ImmutableSet functions() { + return functions.stream().map(f -> f.functionDecl).collect(toImmutableSet()); + } + + @Override + public ImmutableSet macros() { + return ImmutableSet.of( + CelMacro.newReceiverVarArgMacro("greatest", CelMathExtensions::expandGreatestMacro), + CelMacro.newReceiverVarArgMacro("least", CelMathExtensions::expandLeastMacro)); + } + + @Override + public void setParserOptions(CelParserBuilder parserBuilder) { + parserBuilder.addMacros(macros()); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + functions.forEach(function -> checkerBuilder.addFunctionDeclarations(function.functionDecl)); + } + + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + functions.forEach( + function -> { + ImmutableSet combined = function.functionBindings; + if (!combined.isEmpty()) { + runtimeBuilder.addFunctionBindings( + CelFunctionBinding.fromOverloads(function.functionDecl.name(), combined)); + } + }); + } + + private static Optional expandGreatestMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + if (!isTargetInNamespace(target)) { + // Return empty to indicate that we're not interested in expanding this macro, and + // that the parser should default to a function call on the receiver. + return Optional.empty(); + } + + switch (arguments.size()) { + case 0: + return newError(exprFactory, "math.greatest() requires at least one argument", target); + case 1: + Optional invalidArg = + checkInvalidArgumentSingleArg(exprFactory, "math.greatest()", arguments.get(0)); + if (invalidArg.isPresent()) { + return invalidArg; + } + + return Optional.of(exprFactory.newGlobalCall(MATH_MAX_FUNCTION, arguments.get(0))); + case 2: + invalidArg = checkInvalidArgument(exprFactory, "math.greatest()", arguments); + if (invalidArg.isPresent()) { + return invalidArg; + } + + return Optional.of(exprFactory.newGlobalCall(MATH_MAX_FUNCTION, arguments)); + default: + invalidArg = checkInvalidArgument(exprFactory, "math.greatest()", arguments); + if (invalidArg.isPresent()) { + return invalidArg; + } + + return Optional.of( + exprFactory.newGlobalCall(MATH_MAX_FUNCTION, exprFactory.newList(arguments))); + } + } + + private static Comparable maxPair(Comparable x, Comparable y) { + if (x.getClass().equals(y.getClass())) { + return max(x, y); + } + + return CLASSES_TO_COMPARATORS.get(x.getClass(), y.getClass()).apply(x, y) >= 0 ? x : y; + } + + private static Comparable maxList(List list) { + if (list.isEmpty()) { + throw new IllegalStateException("math.@max(list) argument must not be empty"); + } + + Comparable max = list.get(0); + for (int i = 1; i < list.size(); i++) { + max = maxPair(max, list.get(i)); + } + + return max; + } + + private static Comparable minPair(Comparable x, Comparable y) { + if (x.getClass().equals(y.getClass())) { + return min(x, y); + } + + return CLASSES_TO_COMPARATORS.get(x.getClass(), y.getClass()).apply(x, y) <= 0 ? x : y; + } + + private static long absExact(long x) { + if (x == Long.MIN_VALUE) { + // The only case where standard Math.abs overflows silently + throw new CelNumericOverflowException("integer overflow"); + } + return Math.abs(x); + } + + private static boolean isNaN(double x) { + return Double.isNaN(x); + } + + private static Double trunc(Double x) { + if (isNaN(x) || isInfinite(x)) { + return x; + } + return (double) x.longValue(); + } + + private static boolean isInfinite(double x) { + return Double.isInfinite(x); + } + + private static double round(double x) { + if (isNaN(x) || isInfinite(x)) { + return x; + } + return DoubleMath.roundToLong(x, RoundingMode.HALF_UP); + } + + private static Number sign(Number x) { + if (x instanceof Double) { + double val = x.doubleValue(); + if (isNaN(val)) { + return val; + } + if (val == 0) { + return 0.0; + } + return val > 0 ? 1.0 : -1.0; + } + + if (x instanceof Long) { + long val = x.longValue(); + if (val == 0) { + return 0L; + } + return val > 0 ? 1L : -1L; + } + + if (x instanceof UnsignedLong) { + UnsignedLong val = (UnsignedLong) x; + if (val.equals(UnsignedLong.ZERO)) { + return val; + } + return UnsignedLong.ONE; + } + + throw new IllegalArgumentException("Unsupported type: " + x.getClass()); + } + + private static Long intBitAnd(long x, long y) { + return x & y; + } + + private static UnsignedLong uintBitAnd(UnsignedLong x, UnsignedLong y) { + return UnsignedLong.fromLongBits(x.longValue() & y.longValue()); + } + + private static Long intBitOr(long x, long y) { + return x | y; + } + + private static UnsignedLong uintBitOr(UnsignedLong x, UnsignedLong y) { + return UnsignedLong.fromLongBits(x.longValue() | y.longValue()); + } + + private static Long intBitXor(long x, long y) { + return x ^ y; + } + + private static UnsignedLong uintBitXor(UnsignedLong x, UnsignedLong y) { + return UnsignedLong.fromLongBits(x.longValue() ^ y.longValue()); + } + + private static Long intBitNot(long x) { + return ~x; + } + + private static UnsignedLong uintBitNot(UnsignedLong x) { + return UnsignedLong.fromLongBits(~x.longValue()); + } + + private static Long intBitShiftLeft(long value, long shiftAmount) { + if (shiftAmount < 0) { + throw new IllegalArgumentException("math.bitShiftLeft() negative offset:" + shiftAmount); + } + + if (shiftAmount > MAX_BIT_SHIFT) { + return 0L; + } + return value << shiftAmount; + } + + private static UnsignedLong uintBitShiftLeft(UnsignedLong value, long shiftAmount) { + if (shiftAmount < 0) { + throw new IllegalArgumentException("math.bitShiftLeft() negative offset:" + shiftAmount); + } + + if (shiftAmount > MAX_BIT_SHIFT) { + return UnsignedLong.ZERO; + } + return UnsignedLong.fromLongBits(value.longValue() << shiftAmount); + } + + private static Long intBitShiftRight(long value, long shiftAmount) { + if (shiftAmount < 0) { + throw new IllegalArgumentException("math.bitShiftRight() negative offset:" + shiftAmount); + } + + if (shiftAmount > MAX_BIT_SHIFT) { + return 0L; + } + return value >>> shiftAmount; + } + + private static UnsignedLong uintBitShiftRight(UnsignedLong value, long shiftAmount) { + if (shiftAmount < 0) { + throw new IllegalArgumentException("math.bitShiftRight() negative offset:" + shiftAmount); + } + + if (shiftAmount > MAX_BIT_SHIFT) { + return UnsignedLong.ZERO; + } + return UnsignedLong.fromLongBits(value.longValue() >>> shiftAmount); + } + + private static Double sqrtDouble(double x) { + return Math.sqrt(x); + } + + private static Double sqrtInt(Long x) { + return sqrtDouble(x.doubleValue()); + } + + private static Double sqrtUint(UnsignedLong x) { + return sqrtDouble(x.doubleValue()); + } + + private static Comparable minList(List list) { + if (list.isEmpty()) { + throw new IllegalStateException("math.@min(list) argument must not be empty"); + } + + Comparable min = list.get(0); + for (int i = 1; i < list.size(); i++) { + min = minPair(min, list.get(i)); + } + + return min; + } + + private static Optional expandLeastMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + if (!isTargetInNamespace(target)) { + // Return empty to indicate that we're not interested in expanding this macro, and + // that the parser should default to a function call on the receiver. + return Optional.empty(); + } + + switch (arguments.size()) { + case 0: + return newError(exprFactory, "math.least() requires at least one argument", target); + case 1: + Optional invalidArg = + checkInvalidArgumentSingleArg(exprFactory, "math.least()", arguments.get(0)); + if (invalidArg.isPresent()) { + return invalidArg; + } + + return Optional.of(exprFactory.newGlobalCall(MATH_MIN_FUNCTION, arguments.get(0))); + case 2: + invalidArg = checkInvalidArgument(exprFactory, "math.least()", arguments); + if (invalidArg.isPresent()) { + return invalidArg; + } + + return Optional.of(exprFactory.newGlobalCall(MATH_MIN_FUNCTION, arguments)); + default: + invalidArg = checkInvalidArgument(exprFactory, "math.least()", arguments); + if (invalidArg.isPresent()) { + return invalidArg; + } + + return Optional.of( + exprFactory.newGlobalCall(MATH_MIN_FUNCTION, exprFactory.newList(arguments))); + } + } + + private static boolean isTargetInNamespace(CelExpr target) { + return target.exprKind().getKind().equals(Kind.IDENT) + && target.ident().name().equals(MATH_NAMESPACE); + } + + private static Optional checkInvalidArgument( + CelMacroExprFactory exprFactory, String functionName, List arguments) { + + for (CelExpr arg : arguments) { + if (!isArgumentValidType(arg)) { + return newError( + exprFactory, + String.format("%s simple literal arguments must be numeric", functionName), + arg); + } + } + return Optional.empty(); + } + + private static Optional checkInvalidArgumentSingleArg( + CelMacroExprFactory exprFactory, String functionName, CelExpr argument) { + if (argument.exprKind().getKind() == Kind.LIST) { + if (argument.list().elements().isEmpty()) { + return newError( + exprFactory, String.format("%s invalid single argument value", functionName), argument); + } + + return checkInvalidArgument(exprFactory, functionName, argument.list().elements()); + } + if (isArgumentValidType(argument)) { + return Optional.empty(); + } + + return newError( + exprFactory, String.format("%s invalid single argument value", functionName), argument); + } + + private static boolean isArgumentValidType(CelExpr argument) { + if (argument.exprKind().getKind() == Kind.CONSTANT) { + CelConstant constant = argument.constant(); + return constant.getKind() == CelConstant.Kind.INT64_VALUE + || constant.getKind() == CelConstant.Kind.UINT64_VALUE + || constant.getKind() == CelConstant.Kind.DOUBLE_VALUE; + } else if (argument.exprKind().getKind().equals(Kind.LIST) + || argument.exprKind().getKind().equals(Kind.STRUCT) + || argument.exprKind().getKind().equals(Kind.MAP)) { + return false; + } + + return true; + } + + private static Optional newError( + CelMacroExprFactory exprFactory, String errorMessage, CelExpr argument) { + return Optional.of( + exprFactory.reportError( + CelIssue.formatError(exprFactory.getSourceLocation(argument), errorMessage))); + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelNativeTypesExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelNativeTypesExtensions.java new file mode 100644 index 000000000..f150a8437 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelNativeTypesExtensions.java @@ -0,0 +1,1118 @@ +// 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.extensions; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static java.util.Arrays.stream; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.Primitives; +import com.google.common.primitives.UnsignedLong; +import com.google.common.reflect.TypeToken; +import com.google.errorprone.annotations.Immutable; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.exceptions.CelAttributeNotFoundException; +import dev.cel.common.exceptions.CelInvalidArgumentException; +import dev.cel.common.internal.ReflectionUtil; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.CelValue; +import dev.cel.common.values.CelValueConverter; +import dev.cel.common.values.CelValueProvider; +import dev.cel.common.values.StructValue; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeLibrary; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; +import java.lang.reflect.Array; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.lang.reflect.Type; +import java.time.Duration; +import java.time.Instant; +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.Queue; +import java.util.Set; +import java.util.function.BiConsumer; +import java.util.function.Function; +import org.jspecify.annotations.Nullable; + +/** + * Extension for supporting native Java types (POJOs) in CEL. + * + *

This allows seamless plugin and evaluation of message creations and field selections without + * involving protobuf. + */ +@Immutable +public final class CelNativeTypesExtensions implements CelCompilerLibrary, CelRuntimeLibrary { + + private final NativeTypeRegistry registry; + + // Set of all standard java.lang.Object method names. + private static final ImmutableSet OBJECT_METHOD_NAMES = + stream(Object.class.getDeclaredMethods()).map(Method::getName).collect(toImmutableSet()); + + // Set of all standard java.lang.Enum method names. + private static final ImmutableSet ENUM_METHOD_NAMES = + stream(Enum.class.getDeclaredMethods()).map(Method::getName).collect(toImmutableSet()); + + private static final ImmutableMap, CelType> JAVA_TO_CEL_TYPE_MAP = + ImmutableMap., CelType>builder() + .put(boolean.class, SimpleType.BOOL) + .put(Boolean.class, SimpleType.BOOL) + .put(String.class, SimpleType.STRING) + .put(int.class, SimpleType.INT) + .put(Integer.class, SimpleType.INT) + .put(long.class, SimpleType.INT) + .put(Long.class, SimpleType.INT) + .put(UnsignedLong.class, SimpleType.UINT) + .put(float.class, SimpleType.DOUBLE) + .put(Float.class, SimpleType.DOUBLE) + .put(double.class, SimpleType.DOUBLE) + .put(Double.class, SimpleType.DOUBLE) + .put(byte[].class, SimpleType.BYTES) + .put(CelByteString.class, SimpleType.BYTES) + .put(Duration.class, SimpleType.DURATION) + .put(Instant.class, SimpleType.TIMESTAMP) + .put(Object.class, SimpleType.DYN) + .buildOrThrow(); + + private static final ImmutableMap, Object> JAVA_TO_DEFAULT_VALUE_MAP = + ImmutableMap., Object>builder() + .put(boolean.class, false) + .put(Boolean.class, false) + .put(String.class, "") + .put(int.class, 0L) + .put(Integer.class, 0L) + .put(long.class, 0L) + .put(Long.class, 0L) + .put(UnsignedLong.class, UnsignedLong.ZERO) + .put(float.class, 0.0) + .put(Float.class, 0.0) + .put(double.class, 0.0) + .put(Double.class, 0.0) + .put(byte[].class, new byte[0]) + .put(CelByteString.class, CelByteString.EMPTY) + .put(Duration.class, Duration.ZERO) + .put(Instant.class, Instant.EPOCH) + .put(Optional.class, Optional.empty()) + .buildOrThrow(); + + /** Creates a new instance of {@link CelNativeTypesExtensions} for the given classes. */ + static CelNativeTypesExtensions nativeTypes(Class... classes) { + return new CelNativeTypesExtensions(new NativeTypeRegistry(NativeTypeScanner.scan(classes))); + } + + @VisibleForTesting + NativeTypeRegistry getRegistry() { + return registry; + } + + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + runtimeBuilder.setValueProvider(registry); + runtimeBuilder.setTypeProvider(registry); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + checkerBuilder.setTypeProvider(registry); + } + + /** + * NativeTypeScanner scans registered Java classes to extract properties and compile accessors. + */ + @VisibleForTesting + static final class NativeTypeScanner { + private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup(); + + private NativeTypeScanner() {} + + private static final class ScanResult { + private final ImmutableMap> classMap; + private final ImmutableMap typeMap; + private final ImmutableMap, StructType> classToTypeMap; + private final ImmutableMap, ImmutableMap> accessorMap; + + ScanResult( + ImmutableMap> classMap, + ImmutableMap typeMap, + ImmutableMap, StructType> classToTypeMap, + ImmutableMap, ImmutableMap> accessorMap) { + this.classMap = classMap; + this.typeMap = typeMap; + this.classToTypeMap = classToTypeMap; + this.accessorMap = accessorMap; + } + } + + private static ScanResult scan(Class... classes) { + ImmutableMap.Builder> classMapBuilder = ImmutableMap.builder(); + ImmutableMap.Builder typeMapBuilder = ImmutableMap.builder(); + ImmutableMap.Builder, StructType> classToTypeMapBuilder = ImmutableMap.builder(); + ImmutableMap.Builder, ImmutableMap> accessorMapBuilder = + ImmutableMap.builder(); + + Set> visited = new HashSet<>(); + Queue> queue = new ArrayDeque<>(Arrays.asList(classes)); + + while (!queue.isEmpty()) { + Class clazz = queue.poll(); + if (shouldSkip(clazz, visited)) { + continue; + } + visited.add(clazz); + + String typeName = getCelTypeName(clazz); + classMapBuilder.put(typeName, clazz); + + ImmutableMap accessors = scanProperties(clazz, queue); + accessorMapBuilder.put(clazz, accessors); + } + + ImmutableMap> classMap = classMapBuilder.buildOrThrow(); + ImmutableMap, ImmutableMap> accessorMap = + accessorMapBuilder.buildOrThrow(); + + for (Map.Entry> entry : classMap.entrySet()) { + String typeName = entry.getKey(); + Class clazz = entry.getValue(); + + StructType structType = createStructType(clazz, classMap, accessorMap); + typeMapBuilder.put(typeName, structType); + classToTypeMapBuilder.put(clazz, structType); + } + + ScanResult result = + new ScanResult( + classMap, + typeMapBuilder.buildOrThrow(), + classToTypeMapBuilder.buildOrThrow(), + accessorMap); + + validateRegisteredClasses(result.classToTypeMap, result.classMap, result.accessorMap); + + return result; + } + + private static void validateRegisteredClasses( + ImmutableMap, StructType> classToTypeMap, + ImmutableMap> classMap, + ImmutableMap, ImmutableMap> accessorMap) { + for (Class clazz : classToTypeMap.keySet()) { + for (String prop : getProperties(clazz)) { + try { + getPropertyType(clazz, prop, classMap, accessorMap); + } catch (IllegalArgumentException e) { + throw new IllegalArgumentException( + "Unsupported type for property '" + prop + "' in class " + clazz.getName(), e); + } + } + } + } + + private static boolean shouldSkip(Class clazz, Set> visited) { + return clazz == null + || visited.contains(clazz) + || clazz.isInterface() + || isSupportedType(clazz); + } + + private static boolean isSupportedType(Class type) { + return JAVA_TO_CEL_TYPE_MAP.containsKey(type) + || type == Optional.class + || List.class.isAssignableFrom(type) + || Map.class.isAssignableFrom(type) + || type.isArray(); + } + + private static StructType createStructType( + Class clazz, + ImmutableMap> classMap, + ImmutableMap, ImmutableMap> accessorMap) { + return StructType.create( + getCelTypeName(clazz), + getProperties(clazz), + fieldName -> Optional.of(getPropertyType(clazz, fieldName, classMap, accessorMap))); + } + + private static CelType getPropertyType( + Class clazz, + String propertyName, + ImmutableMap> classMap, + ImmutableMap, ImmutableMap> accessorMap) { + ImmutableMap accessors = accessorMap.get(clazz); + if (accessors != null) { + PropertyAccessor accessor = accessors.get(propertyName); + if (accessor != null) { + return mapJavaTypeToCelType(accessor.targetType, accessor.genericTargetType, classMap); + } + } + throw new IllegalArgumentException("No public field or getter for " + propertyName); + } + + private static CelType mapJavaTypeToCelType( + Class type, Type genericType, ImmutableMap> classMap) { + + CelType celType = JAVA_TO_CEL_TYPE_MAP.get(type); + if (celType != null) { + return celType; + } + + if (type.isArray()) { + TypeToken token = TypeToken.of(genericType); + TypeToken componentToken = + Preconditions.checkNotNull( + token.getComponentType(), "Array component type cannot be null"); + return ListType.create( + mapJavaTypeToCelType(componentToken.getRawType(), componentToken.getType(), classMap)); + } + + if (type.isInterface() + && !List.class.isAssignableFrom(type) + && !Map.class.isAssignableFrom(type)) { + throw new IllegalArgumentException("Unsupported interface type: " + type.getName()); + } + + TypeToken token = TypeToken.of(genericType); + + if (List.class.isAssignableFrom(type)) { + Type elementType = ReflectionUtil.resolveGenericParameter(token, List.class, 0); + return ListType.create( + mapJavaTypeToCelType(ReflectionUtil.getRawType(elementType), elementType, classMap)); + } + + if (Map.class.isAssignableFrom(type)) { + Type keyType = ReflectionUtil.resolveGenericParameter(token, Map.class, 0); + Type valueType = ReflectionUtil.resolveGenericParameter(token, Map.class, 1); + + CelType celKeyType = + mapJavaTypeToCelType(ReflectionUtil.getRawType(keyType), keyType, classMap); + if (celKeyType == SimpleType.DOUBLE) { + throw new IllegalArgumentException("Decimals are not allowed as map keys in CEL."); + } + + return MapType.create( + celKeyType, + mapJavaTypeToCelType(ReflectionUtil.getRawType(valueType), valueType, classMap)); + } + + // Optional is a final class, so reference equality is equivalent to isAssignableFrom + // but slightly more performant than tree traversal. + if (type == Optional.class) { + Type optionalType = ReflectionUtil.resolveGenericParameter(token, Optional.class, 0); + return OptionalType.create( + mapJavaTypeToCelType(ReflectionUtil.getRawType(optionalType), optionalType, classMap)); + } + + String typeName = getCelTypeName(type); + if (classMap.containsKey(typeName)) { + return StructTypeReference.create(typeName); + } + + throw new IllegalArgumentException( + "Unsupported Java type for CEL mapping: " + type.getName()); + } + + private static ImmutableMap scanProperties( + Class clazz, Queue> queue) { + ImmutableMap.Builder builtAccessors = ImmutableMap.builder(); + + for (String propName : getProperties(clazz)) { + buildPropertyAccessor(clazz, propName, queue) + .ifPresent(accessor -> builtAccessors.put(propName, accessor)); + } + + return builtAccessors.buildOrThrow(); + } + + private static Optional buildPropertyAccessor( + Class clazz, String propName, Queue> queue) { + Method getter = findGetter(clazz, propName); + Field field = findField(clazz, propName); + + Class propType = null; + Type genericPropType = null; + Function compiledGetter = null; + BiConsumer compiledSetter = null; + + if (getter != null) { + propType = getter.getReturnType(); + genericPropType = getter.getGenericReturnType(); + queue.addAll(TypeReferenceCollector.collect(genericPropType)); + compiledGetter = compileGetter(getter); + } else if (field != null) { + propType = field.getType(); + genericPropType = field.getGenericType(); + queue.addAll(TypeReferenceCollector.collect(genericPropType)); + compiledGetter = compileFieldGetter(field); + } + + if (propType != null) { + Method setter = findSetter(clazz, propName, propType); + if (setter != null) { + compiledSetter = compileSetter(setter); + } else if (field != null + && !Modifier.isFinal(field.getModifiers()) + && Primitives.wrap(field.getType()) == Primitives.wrap(propType)) { + compiledSetter = compileFieldSetter(field); + } + } + + if (compiledGetter != null) { + return Optional.of( + new PropertyAccessor(compiledGetter, compiledSetter, propType, genericPropType)); + } + + return Optional.empty(); + } + + /** + * Recursively explores a {@link Type} and discovers any transitive, user-defined custom POJO + * classes nested inside multi-level generic collections, lists, maps, or optionals, collecting + * them for subsequent properties discovery. + * + *

"Custom types" are any public non-primitive, non-built-in Java classes that require + * explicit properties reflective scanning and mapping to a CEL StructType schema (as opposed to + * standard built-in types like {@code String}, {@code List}, or {@code Map}). + */ + private static final class TypeReferenceCollector { + private final Set> collectedTypes = new HashSet<>(); + + /** + * Traverses the given type and returns an immutable set of all custom POJO classes found. + * + * @param type The Java type token or parameterized collection type to recursively unpack. + */ + private static ImmutableSet> collect(Type type) { + TypeReferenceCollector collector = new TypeReferenceCollector(); + collector.discover(type); + return ImmutableSet.copyOf(collector.collectedTypes); + } + + private void discover(Type type) { + Preconditions.checkNotNull(type, "Type to discover cannot be null."); + TypeToken token = TypeToken.of(type); + Class rawType = token.getRawType(); + + if (rawType.isArray()) { + TypeToken componentToken = + Preconditions.checkNotNull( + token.getComponentType(), "Array component type cannot be null"); + discover(componentToken.getType()); + return; + } + + if (List.class.isAssignableFrom(rawType)) { + discover(ReflectionUtil.resolveGenericParameter(token, List.class, 0)); + return; + } + + if (Map.class.isAssignableFrom(rawType)) { + discover(ReflectionUtil.resolveGenericParameter(token, Map.class, 0)); + discover(ReflectionUtil.resolveGenericParameter(token, Map.class, 1)); + return; + } + + if (rawType == Optional.class) { + discover(ReflectionUtil.resolveGenericParameter(token, Optional.class, 0)); + return; + } + + // Custom types are non-builtin, public classes + if (!JAVA_TO_DEFAULT_VALUE_MAP.containsKey(rawType) + && Modifier.isPublic(rawType.getModifiers())) { + collectedTypes.add(rawType); + } + } + } + + private static Function compileGetter(Method getter) { + try { + // Required to unreflect public getters of package-private classes registered from other + // packages. + getter.setAccessible(true); + MethodHandle mh = LOOKUP.unreflect(getter); + return instance -> { + try { + return mh.invoke(instance); + } catch (Throwable t) { + throw new IllegalStateException("Failed to invoke getter for " + getter, t); + } + }; + } catch (IllegalAccessException e) { + throw new IllegalStateException("Failed to unreflect getter", e); + } + } + + private static Function compileFieldGetter(Field field) { + try { + // Required to unreflect public fields of package-private classes registered from other + // packages. + field.setAccessible(true); + MethodHandle mh = LOOKUP.unreflectGetter(field); + return instance -> { + try { + return mh.invoke(instance); + } catch (Throwable t) { + throw new IllegalStateException("Failed to get field " + field, t); + } + }; + } catch (IllegalAccessException e) { + throw new IllegalStateException("Failed to access field " + field, e); + } + } + + private static BiConsumer compileSetter(Method setter) { + try { + setter.setAccessible(true); + MethodHandle mh = LOOKUP.unreflect(setter); + return (instance, value) -> { + try { + mh.invoke(instance, value); + } catch (Throwable t) { + throw new IllegalStateException("Failed to invoke setter for " + setter, t); + } + }; + } catch (IllegalAccessException e) { + throw new IllegalStateException("Failed to unreflect setter", e); + } + } + + private static BiConsumer compileFieldSetter(Field field) { + try { + field.setAccessible(true); + MethodHandle mh = LOOKUP.unreflectSetter(field); + return (instance, value) -> { + try { + mh.invoke(instance, value); + } catch (Throwable t) { + throw new IllegalStateException("Failed to set field " + field, t); + } + }; + } catch (IllegalAccessException e) { + throw new IllegalStateException("Failed to access field " + field, e); + } + } + + private static @Nullable Method findGetter(Class clazz, String propertyName) { + String getterName = buildMethodName("get", propertyName); + String isGetterName = buildMethodName("is", propertyName); + + Method isGetter = null; + Method prefixLess = null; + + for (Method method : clazz.getMethods()) { + if (method.isBridge() || method.isSynthetic()) { + // Ignore compiler-generated duplicates + continue; + } + if (method.getParameterCount() == 0) { + String name = method.getName(); + if (name.equals(getterName)) { + return method; + } + if (name.equals(isGetterName)) { + isGetter = method; + } + if (name.equals(propertyName)) { + prefixLess = method; + } + } + } + + if (isGetter != null) { + return isGetter; + } + return prefixLess; + } + + private static @Nullable Field findField(Class clazz, String propertyName) { + for (Field field : clazz.getFields()) { + if (field.getName().equals(propertyName)) { + return field; + } + } + return null; + } + + private static @Nullable Method findSetter( + Class clazz, String propertyName, Class propertyType) { + String setterName = buildMethodName("set", propertyName); + return stream(clazz.getMethods()) + .filter(m -> !m.isBridge() && !m.isSynthetic()) + .filter(m -> m.getName().equals(setterName)) + .filter(m -> m.getParameterCount() == 1) + .filter(m -> m.getParameterTypes()[0].equals(propertyType)) + .findFirst() + .orElse(null); + } + + private static Set getAllDeclaredFieldNames(Class clazz) { + Set declaredFieldNames = new HashSet<>(); + Class currentClass = clazz; + while (currentClass != null) { + for (Field field : currentClass.getDeclaredFields()) { + declaredFieldNames.add(field.getName()); + } + currentClass = currentClass.getSuperclass(); + } + return declaredFieldNames; + } + + @VisibleForTesting + static ImmutableSet getProperties(Class clazz) { + ImmutableSet.Builder properties = ImmutableSet.builder(); + Set declaredFieldNames = getAllDeclaredFieldNames(clazz); + for (Field field : clazz.getFields()) { + if (Modifier.isStatic(field.getModifiers())) { + continue; + } + properties.add(field.getName()); + } + for (Method method : clazz.getMethods()) { + if (isGetter(method)) { + String propName = getPropertyName(method); + if (method.getName().startsWith("get") || method.getName().startsWith("is")) { + properties.add(propName); + } else if (declaredFieldNames.contains(propName)) { + properties.add(propName); + } + } + } + return properties.build(); + } + + private static boolean isGetter(Method method) { + if (Modifier.isStatic(method.getModifiers())) { + return false; + } + if (!Modifier.isPublic(method.getModifiers()) || method.getParameterCount() != 0) { + return false; + } + if (method.getReturnType() == void.class) { + return false; + } + String name = method.getName(); + if (OBJECT_METHOD_NAMES.contains(name)) { + return false; + } + if (Enum.class.isAssignableFrom(method.getDeclaringClass()) + && ENUM_METHOD_NAMES.contains(name)) { + return false; + } + if (name.startsWith("get")) { + return name.length() > 3; + } + if (name.startsWith("is")) { + return name.length() > 2 && Primitives.wrap(method.getReturnType()) == Boolean.class; + } + return true; + } + + private static String decapitalize(String name) { + Preconditions.checkArgument(name != null && !name.isEmpty()); + if (name.length() > 1 + && Character.isUpperCase(name.charAt(1)) + && Character.isUpperCase(name.charAt(0))) { + return name; + } + char[] chars = name.toCharArray(); + chars[0] = Character.toLowerCase(chars[0]); + return new String(chars); + } + + private static String getPropertyName(Method method) { + String name = method.getName(); + if (name.startsWith("get")) { + return decapitalize(name.substring(3)); + } + if (name.startsWith("is")) { + return decapitalize(name.substring(2)); + } + if (name.startsWith("set")) { + return decapitalize(name.substring(3)); + } + return name; + } + + private static String capitalize(String name) { + return Character.toUpperCase(name.charAt(0)) + name.substring(1); + } + + private static String buildMethodName(String prefix, String propertyName) { + return prefix + capitalize(propertyName); + } + } + + /** + * NativeTypeRegistry holds the state produced by NativeTypeScanner and acts as a CelValueProvider + * and CelTypeProvider for the CEL runtime. + */ + @VisibleForTesting + @Immutable + static final class NativeTypeRegistry implements CelValueProvider, CelTypeProvider { + + private final ImmutableMap> classMap; + private final ImmutableMap typeMap; + private final ImmutableMap, StructType> classToTypeMap; + private final ImmutableMap, ImmutableMap> accessorMap; + private final NativeValueConverter converter; + + private NativeTypeRegistry(NativeTypeScanner.ScanResult scanResult) { + this.classMap = scanResult.classMap; + this.typeMap = scanResult.typeMap; + this.classToTypeMap = scanResult.classToTypeMap; + this.accessorMap = scanResult.accessorMap; + this.converter = new NativeValueConverter(this); + } + + @Override + public ImmutableList types() { + return ImmutableList.copyOf(typeMap.values()); + } + + @Override + public Optional findType(String typeName) { + return Optional.ofNullable(typeMap.get(typeName)); + } + + @Override + public Optional newValue(String typeName, Map fields) { + Class clazz = classMap.get(typeName); + if (clazz == null) { + return Optional.empty(); + } + + try { + Constructor constructor = clazz.getDeclaredConstructor(); + constructor.setAccessible(true); + Object instance = constructor.newInstance(); + ImmutableMap accessors = accessorMap.get(clazz); + + for (Map.Entry entry : fields.entrySet()) { + PropertyAccessor accessor = accessors.get(entry.getKey()); + if (accessor == null) { + throw new IllegalArgumentException( + "Unknown field: " + entry.getKey() + " for type " + typeName); + } + Object value = + converter.toNative(entry.getValue(), accessor.targetType, accessor.genericTargetType); + accessor.setValue(instance, value); + } + + StructType structType = typeMap.get(typeName); + return Optional.of(new PojoStructValue(instance, accessors, structType)); + } catch (NoSuchMethodException e) { + throw new IllegalStateException( + "Failed to create instance of " + + typeName + + ": No public no-argument constructor found.", + e); + } catch (Exception e) { + throw new IllegalStateException("Failed to create instance of " + typeName, e); + } + } + + @Override + public CelValueConverter celValueConverter() { + return this.converter; + } + } + + /** + * PropertyAccessor holds the compiled getter and setter for a property, along with its type + * information. + */ + @Immutable + @SuppressWarnings("Immutable") + private static final class PropertyAccessor { + private final Function getter; + private final @Nullable BiConsumer setter; + private final Class targetType; + private final @Nullable Type genericTargetType; + + private PropertyAccessor( + Function getter, + @Nullable BiConsumer setter, + Class targetType, + @Nullable Type genericTargetType) { + this.getter = getter; + this.setter = setter; + this.targetType = targetType; + this.genericTargetType = genericTargetType; + } + + Object getValue(Object instance) { + return getter.apply(instance); + } + + Object getDefaultValue() { + return getDefaultValue(targetType); + } + + private static Object getDefaultValue(Class targetType) { + Object defaultValue = JAVA_TO_DEFAULT_VALUE_MAP.get(targetType); + if (defaultValue != null) { + return defaultValue; + } + if (List.class.isAssignableFrom(targetType)) { + return ImmutableList.of(); + } + if (Map.class.isAssignableFrom(targetType)) { + return ImmutableMap.of(); + } + if (targetType.isArray()) { + return Array.newInstance(targetType.getComponentType(), 0); + } + + try { + Constructor constructor = targetType.getDeclaredConstructor(); + constructor.setAccessible(true); + return constructor.newInstance(); + } catch (Exception e) { + throw new IllegalStateException( + String.format( + "Failed to instantiate default instance for uninitialized field of type [%s]. " + + "Please ensure the class has a no-argument constructor or is initialized.", + targetType.getName()), + e); + } + } + + void setValue(Object instance, Object value) { + if (setter != null) { + setter.accept(instance, value); + } else { + throw new IllegalStateException("No setter found for property"); + } + } + } + + /** NativeValueConverter handles conversion between Java objects and CEL values. */ + @Immutable + private static final class NativeValueConverter extends CelValueConverter { + + private final NativeTypeRegistry registry; + + private NativeValueConverter(NativeTypeRegistry registry) { + this.registry = registry; + } + + @Override + public Object toRuntimeValue(Object value) { + if (value instanceof CelValue) { + return super.toRuntimeValue(value); + } + + Class clazz = value.getClass(); + ImmutableMap accessors = registry.accessorMap.get(clazz); + + if (accessors != null) { + return new PojoStructValue(value, accessors, registry.classToTypeMap.get(clazz)); + } + + if (clazz.isArray() && clazz != byte[].class) { + return convertArrayToList(value); + } + + return super.toRuntimeValue(value); + } + + Object toNative(Object value, Class targetType, Type genericType) { + if (value instanceof CelValue && !StructValue.class.isAssignableFrom(targetType)) { + value = super.maybeUnwrap(value); + } + if (targetType == Optional.class) { + if (value instanceof Optional) { + return value; + } + return Optional.ofNullable(value); + } + if (targetType == UnsignedLong.class) { + if (value instanceof UnsignedLong) { + return value; + } + } + if (targetType == byte[].class && value instanceof CelByteString) { + return ((CelByteString) value).toByteArray(); + } + + if (value instanceof List) { + List listValue = (List) value; + if (List.class.isAssignableFrom(targetType)) { + return convertListToNative(listValue, targetType, genericType); + } + if (targetType.isArray()) { + return convertListToArray(listValue, targetType, genericType); + } + } + + if (Map.class.isAssignableFrom(targetType) && value instanceof Map) { + return convertMapToNative((Map) value, targetType, genericType); + } + + return downcastPrimitives(value, targetType); + } + + // Safe reflection collection cast. + @SuppressWarnings("unchecked") + private List convertListToNative(List list, Class targetType, Type genericType) { + TypeToken token = TypeToken.of(genericType); + Type elementType = ReflectionUtil.resolveGenericParameter(token, List.class, 0); + Class componentType = ReflectionUtil.getRawType(elementType); + + boolean isConcreteClass = + !targetType.isInterface() && !Modifier.isAbstract(targetType.getModifiers()); + + // Instantiates concrete collection types to prevent ClassCastExceptions. + // For example, if a POJO field is declared as a concrete implementation like + // ArrayList, assigning a Guava ImmutableList will fail at runtime due to type + // mismatch. + if (isConcreteClass) { + List concreteList; + try { + concreteList = (List) targetType.getConstructor().newInstance(); + } catch (Exception e) { + throw new IllegalStateException( + "Failed to instantiate concrete collection class for field target type: " + + targetType.getName(), + e); + } + + for (Object element : list) { + concreteList.add(toNative(element, componentType, elementType)); + } + return concreteList; + } + + ImmutableList.Builder builder = null; + for (int i = 0; i < list.size(); i++) { + Object element = list.get(i); + Object converted = toNative(element, componentType, elementType); + if (!Objects.equals(converted, element) && builder == null) { + builder = ImmutableList.builderWithExpectedSize(list.size()); + for (int j = 0; j < i; j++) { + builder.add(list.get(j)); + } + } + if (builder != null) { + builder.add(converted); + } + } + + if (builder == null) { + return list; + } + return builder.build(); + } + + // Safe reflection collection cast. + @SuppressWarnings("unchecked") + private Map convertMapToNative(Map map, Class targetType, Type genericType) { + TypeToken token = TypeToken.of(genericType); + Type keyType = ReflectionUtil.resolveGenericParameter(token, Map.class, 0); + Type valueType = ReflectionUtil.resolveGenericParameter(token, Map.class, 1); + Class rawKeyType = ReflectionUtil.getRawType(keyType); + Class rawValueType = ReflectionUtil.getRawType(valueType); + + boolean isConcreteClass = + !targetType.isInterface() && !Modifier.isAbstract(targetType.getModifiers()); + + // Instantiates concrete map types to prevent ClassCastExceptions. + // For example, if a POJO field is declared as a concrete implementation like HashMap, + // assigning a Guava ImmutableMap will fail at runtime due to type mismatch. + if (isConcreteClass) { + Map concreteMap; + try { + concreteMap = (Map) targetType.getConstructor().newInstance(); + } catch (Exception e) { + throw new IllegalStateException( + "Failed to instantiate concrete map class for field target type: " + + targetType.getName(), + e); + } + + for (Map.Entry entry : map.entrySet()) { + concreteMap.put( + toNative(entry.getKey(), rawKeyType, keyType), + toNative(entry.getValue(), rawValueType, valueType)); + } + return concreteMap; + } + + ImmutableMap.Builder builder = null; + for (Map.Entry entry : map.entrySet()) { + Object key = entry.getKey(); + Object val = entry.getValue(); + Object convertedKey = toNative(key, rawKeyType, keyType); + Object convertedVal = toNative(val, rawValueType, valueType); + + if ((!Objects.equals(convertedKey, key) || !Objects.equals(convertedVal, val)) + && builder == null) { + builder = ImmutableMap.builderWithExpectedSize(map.size()); + for (Map.Entry prevEntry : map.entrySet()) { + if (Objects.equals(prevEntry.getKey(), entry.getKey())) { + break; + } + builder.put(prevEntry.getKey(), prevEntry.getValue()); + } + } + + if (builder != null) { + builder.put(convertedKey, convertedVal); + } + } + + if (builder == null) { + return map; + } + return builder.buildOrThrow(); + } + + private Object convertListToArray(List list, Class targetType, Type genericType) { + Class componentType = targetType.getComponentType(); + Object array = Array.newInstance(componentType, list.size()); + TypeToken token = TypeToken.of(genericType); + TypeToken componentToken = + Preconditions.checkNotNull( + token.getComponentType(), "Array component type cannot be null"); + Type componentGenericType = componentToken.getType(); + + for (int i = 0; i < list.size(); i++) { + Object element = list.get(i); + Object converted = toNative(element, componentType, componentGenericType); + Array.set(array, i, converted); + } + return array; + } + + private ImmutableList convertArrayToList(Object array) { + int length = Array.getLength(array); + ImmutableList.Builder builder = ImmutableList.builderWithExpectedSize(length); + for (int i = 0; i < length; i++) { + Object element = Array.get(array, i); + if (element == null) { + throw new CelInvalidArgumentException(String.format("Element at index %d is null.", i)); + } + builder.add(toRuntimeValue(element)); + } + return builder.build(); + } + + private Object downcastPrimitives(Object value, Class targetType) { + Class wrappedTargetType = Primitives.wrap(targetType); + if (wrappedTargetType == Integer.class && value instanceof Long) { + return ((Long) value).intValue(); + } + if (wrappedTargetType == Float.class && value instanceof Double) { + return ((Double) value).floatValue(); + } + + return value; + } + } + + /** PojoStructValue represents a native Java object as a CEL struct value. */ + @SuppressWarnings("Immutable") + private static final class PojoStructValue extends StructValue { + private final Object instance; + private final ImmutableMap accessors; + private final StructType celType; + + private PojoStructValue( + Object instance, ImmutableMap accessors, StructType celType) { + this.instance = instance; + this.accessors = accessors; + this.celType = celType; + } + + @Override + public Object value() { + return instance; + } + + @Override + public boolean isZeroValue() { + throw new UnsupportedOperationException( + "isZeroValue is unsupported for ordinary Java POJOs. Please implement StructValue" + + " directly on the backing class if zero-value trait support is required."); + } + + @Override + public CelType celType() { + return celType; + } + + @Override + public Object select(String field) { + // Intentionally not proxying `find` here to avoid Optional wrapper allocations. + PropertyAccessor accessor = accessors.get(field); + if (accessor != null) { + Object value = accessor.getValue(instance); + if (value == null) { + return accessor.getDefaultValue(); + } + return value; + } + throw CelAttributeNotFoundException.forFieldResolution(field); + } + + @Override + public Optional find(String field) { + PropertyAccessor accessor = accessors.get(field); + if (accessor == null) { + return Optional.empty(); + } + Object value = accessor.getValue(instance); + return Optional.ofNullable(value); + } + } + + private static String getCelTypeName(Class clazz) { + String canonicalName = clazz.getCanonicalName(); + if (canonicalName == null) { + throw new IllegalArgumentException( + "Cannot get canonical name for class: " + + clazz.getName() + + ". Anonymous or local classes are not supported."); + } + return canonicalName; + } + + private CelNativeTypesExtensions(NativeTypeRegistry registry) { + this.registry = registry; + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelOptionalLibrary.java b/extensions/src/main/java/dev/cel/extensions/CelOptionalLibrary.java new file mode 100644 index 000000000..87a31341f --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelOptionalLibrary.java @@ -0,0 +1,560 @@ +// Copyright 2023 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.extensions; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; +import static dev.cel.common.Operator.INDEX; +import static dev.cel.common.Operator.OPTIONAL_INDEX; +import static dev.cel.common.Operator.OPTIONAL_SELECT; +import static dev.cel.extensions.CelOptionalLibrary.Function.FIRST; +import static dev.cel.extensions.CelOptionalLibrary.Function.HAS_VALUE; +import static dev.cel.extensions.CelOptionalLibrary.Function.LAST; +import static dev.cel.extensions.CelOptionalLibrary.Function.OPTIONAL_NONE; +import static dev.cel.extensions.CelOptionalLibrary.Function.OPTIONAL_OF; +import static dev.cel.extensions.CelOptionalLibrary.Function.OPTIONAL_OF_NON_ZERO_VALUE; +import static dev.cel.extensions.CelOptionalLibrary.Function.OPTIONAL_UNWRAP; +import static dev.cel.extensions.CelOptionalLibrary.Function.VALUE; +import static dev.cel.runtime.CelFunctionBinding.fromOverloads; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import com.google.common.primitives.Ints; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Duration; +import com.google.protobuf.Message; +import com.google.protobuf.Timestamp; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelIssue; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelVarDecl; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeParamType; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.CelValue; +import dev.cel.common.values.NullValue; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelMacroExprFactory; +import dev.cel.parser.CelParserBuilder; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelInternalRuntimeLibrary; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** Internal implementation of CEL optional values. */ +public final class CelOptionalLibrary + implements CelCompilerLibrary, CelInternalRuntimeLibrary, CelExtensionLibrary.FeatureSet { + + /** Enumerations of function names used for supporting optionals. */ + public enum Function { + VALUE("value"), + HAS_VALUE("hasValue"), + OPTIONAL_NONE("optional.none"), + OPTIONAL_OF("optional.of"), + OPTIONAL_UNWRAP("optional.unwrap"), + OPTIONAL_OF_NON_ZERO_VALUE("optional.ofNonZeroValue"), + OR("or"), + OR_VALUE("orValue"), + FIRST("first"), + LAST("last"); + + private final String functionName; + + public String getFunction() { + return functionName; + } + + Function(String functionName) { + this.functionName = functionName; + } + } + + private static final CelExtensionLibrary LIBRARY = + new CelExtensionLibrary() { + final TypeParamType paramTypeK = TypeParamType.create("K"); + final TypeParamType paramTypeV = TypeParamType.create("V"); + final OptionalType optionalTypeV = OptionalType.create(paramTypeV); + final ListType listTypeV = ListType.create(paramTypeV); + final MapType mapTypeKv = MapType.create(paramTypeK, paramTypeV); + + private final CelOptionalLibrary version0 = + new CelOptionalLibrary( + 0, + ImmutableSet.of( + CelFunctionDecl.newFunctionDeclaration( + OPTIONAL_OF.getFunction(), + CelOverloadDecl.newGlobalOverload( + "optional_of", optionalTypeV, paramTypeV)), + CelFunctionDecl.newFunctionDeclaration( + OPTIONAL_OF_NON_ZERO_VALUE.getFunction(), + CelOverloadDecl.newGlobalOverload( + "optional_ofNonZeroValue", optionalTypeV, paramTypeV)), + CelFunctionDecl.newFunctionDeclaration( + OPTIONAL_NONE.getFunction(), + CelOverloadDecl.newGlobalOverload("optional_none", optionalTypeV)), + CelFunctionDecl.newFunctionDeclaration( + VALUE.getFunction(), + CelOverloadDecl.newMemberOverload( + "optional_value", paramTypeV, optionalTypeV)), + CelFunctionDecl.newFunctionDeclaration( + HAS_VALUE.getFunction(), + CelOverloadDecl.newMemberOverload( + "optional_hasValue", SimpleType.BOOL, optionalTypeV)), + CelFunctionDecl.newFunctionDeclaration( + OPTIONAL_UNWRAP.getFunction(), + CelOverloadDecl.newGlobalOverload( + "optional_unwrap_list", listTypeV, ListType.create(optionalTypeV))), + // Note: Implementation of "or" and "orValue" are special-cased inside the + // interpreter. Hence, their bindings are not provided here. + CelFunctionDecl.newFunctionDeclaration( + "or", + CelOverloadDecl.newMemberOverload( + "optional_or_optional", optionalTypeV, optionalTypeV, optionalTypeV)), + CelFunctionDecl.newFunctionDeclaration( + "orValue", + CelOverloadDecl.newMemberOverload( + "optional_orValue_value", paramTypeV, optionalTypeV, paramTypeV)), + // Note: Function bindings for optional field selection and indexer is defined + // in {@code StandardFunctions}. + CelFunctionDecl.newFunctionDeclaration( + Operator.OPTIONAL_SELECT.getFunction(), + CelOverloadDecl.newGlobalOverload( + "select_optional_field", + optionalTypeV, + SimpleType.DYN, + SimpleType.STRING)), + CelFunctionDecl.newFunctionDeclaration( + Operator.OPTIONAL_INDEX.getFunction(), + CelOverloadDecl.newGlobalOverload( + "list_optindex_optional_int", optionalTypeV, listTypeV, SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "optional_list_optindex_optional_int", + optionalTypeV, + OptionalType.create(listTypeV), + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "map_optindex_optional_value", optionalTypeV, mapTypeKv, paramTypeK), + CelOverloadDecl.newGlobalOverload( + "optional_map_optindex_optional_value", + optionalTypeV, + OptionalType.create(mapTypeKv), + paramTypeK)), + // Index overloads to accommodate using an optional value as the operand + CelFunctionDecl.newFunctionDeclaration( + Operator.INDEX.getFunction(), + CelOverloadDecl.newGlobalOverload( + "optional_list_index_int", + optionalTypeV, + OptionalType.create(listTypeV), + SimpleType.INT), + CelOverloadDecl.newGlobalOverload( + "optional_map_index_value", + optionalTypeV, + OptionalType.create(mapTypeKv), + paramTypeK))), + ImmutableSet.of( + CelMacro.newReceiverMacro("optMap", 2, CelOptionalLibrary::expandOptMap)), + ImmutableSet.of( + // Type declaration for optional_type -> type(optional_type(V)) + CelVarDecl.newVarDeclaration( + OptionalType.NAME, TypeType.create(optionalTypeV)))); + + private final CelOptionalLibrary version1 = + new CelOptionalLibrary( + 1, + version0.functions, + ImmutableSet.builder() + .addAll(version0.macros) + .add( + CelMacro.newReceiverMacro( + "optFlatMap", 2, CelOptionalLibrary::expandOptFlatMap)) + .build(), + version0.variables); + + private final CelOptionalLibrary version2 = + new CelOptionalLibrary( + 2, + ImmutableSet.builder() + .addAll(version1.functions) + .add( + CelFunctionDecl.newFunctionDeclaration( + FIRST.functionName, + CelOverloadDecl.newMemberOverload( + "optional_list_first", + "Return the first value in a list if present, otherwise" + + " optional.none()", + optionalTypeV, + listTypeV)), + CelFunctionDecl.newFunctionDeclaration( + LAST.functionName, + CelOverloadDecl.newMemberOverload( + "optional_list_last", + "Return the last value in a list if present, otherwise" + + " optional.none()", + optionalTypeV, + listTypeV))) + .build(), + version1.macros, + version1.variables); + + @Override + public String name() { + return "optional"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0, version1, version2); + } + }; + + static CelExtensionLibrary library() { + return LIBRARY; + } + + // TODO migrate from this constant to the CelExtensions.optional() + public static final CelOptionalLibrary INSTANCE = CelOptionalLibrary.library().latest(); + + private static final String UNUSED_ITER_VAR = "#unused"; + + private final int version; + private final ImmutableSet functions; + private final ImmutableSet macros; + private final ImmutableSet variables; + + CelOptionalLibrary( + int version, + ImmutableSet functions, + ImmutableSet macros, + ImmutableSet variables) { + this.version = version; + this.functions = functions; + this.macros = macros; + this.variables = variables; + } + + @Override + public int version() { + return version; + } + + @Override + public ImmutableSet functions() { + return functions; + } + + @Override + public ImmutableSet variables() { + return variables; + } + + @Override + public ImmutableSet macros() { + return macros; + } + + @Override + public void setParserOptions(CelParserBuilder parserBuilder) { + if (!parserBuilder.getOptions().enableOptionalSyntax()) { + // Enable optional syntax by default if the optional library has been added to the + // environment + parserBuilder.setOptions( + parserBuilder.getOptions().toBuilder().enableOptionalSyntax(true).build()); + } + parserBuilder.addMacros(macros()); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + checkerBuilder.addVarDeclarations(variables()); + checkerBuilder.addFunctionDeclarations(functions()); + } + + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + throw new UnsupportedOperationException("Unsupported"); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Override + public void setRuntimeOptions( + CelRuntimeBuilder runtimeBuilder, RuntimeEquality runtimeEquality, CelOptions celOptions) { + runtimeBuilder.addFunctionBindings( + fromOverloads( + OPTIONAL_OF.getFunction(), + CelFunctionBinding.from("optional_of", Object.class, Optional::of))); + runtimeBuilder.addFunctionBindings( + fromOverloads( + OPTIONAL_OF_NON_ZERO_VALUE.getFunction(), + CelFunctionBinding.from( + "optional_ofNonZeroValue", + Object.class, + val -> { + if (isZeroValue(val)) { + return Optional.empty(); + } + return Optional.of(val); + }))); + runtimeBuilder.addFunctionBindings( + fromOverloads( + OPTIONAL_UNWRAP.getFunction(), + CelFunctionBinding.from( + "optional_unwrap_list", + Collection.class, + CelOptionalLibrary::elideOptionalCollection))); + runtimeBuilder.addFunctionBindings( + fromOverloads( + OPTIONAL_NONE.getFunction(), + CelFunctionBinding.from("optional_none", ImmutableList.of(), val -> Optional.empty()))); + runtimeBuilder.addFunctionBindings( + fromOverloads( + VALUE.getFunction(), + CelFunctionBinding.from( + "optional_value", Object.class, val -> ((Optional) val).get()))); + runtimeBuilder.addFunctionBindings( + fromOverloads( + HAS_VALUE.getFunction(), + CelFunctionBinding.from( + "optional_hasValue", Object.class, val -> ((Optional) val).isPresent()))); + + runtimeBuilder.addFunctionBindings( + fromOverloads( + OPTIONAL_SELECT.getFunction(), + CelFunctionBinding.from( + "select_optional_field", // This only handles map selection. Proto selection is + // special cased inside the interpreter. + Map.class, + String.class, + runtimeEquality::findInMap))); + + runtimeBuilder.addFunctionBindings( + fromOverloads( + OPTIONAL_INDEX.getFunction(), + CelFunctionBinding.from( + "list_optindex_optional_int", + List.class, + Long.class, + (List list, Long index) -> { + int castIndex = Ints.checkedCast(index); + if (castIndex < 0 || castIndex >= list.size()) { + return Optional.empty(); + } + return Optional.of(list.get(castIndex)); + }), + CelFunctionBinding.from( + "optional_list_optindex_optional_int", + Optional.class, + Long.class, + CelOptionalLibrary::indexOptionalList), + CelFunctionBinding.from( + "map_optindex_optional_value", Map.class, Object.class, runtimeEquality::findInMap), + CelFunctionBinding.from( + "optional_map_optindex_optional_value", + Optional.class, + Object.class, + (Optional optionalMap, Object key) -> + indexOptionalMap(optionalMap, key, runtimeEquality)))); + + runtimeBuilder.addFunctionBindings( + fromOverloads( + INDEX.getFunction(), + CelFunctionBinding.from( + "optional_list_index_int", + Optional.class, + Long.class, + CelOptionalLibrary::indexOptionalList), + CelFunctionBinding.from( + "optional_map_index_value", + Optional.class, + Object.class, + (Optional optionalMap, Object key) -> + indexOptionalMap(optionalMap, key, runtimeEquality)))); + + if (version >= 2) { + runtimeBuilder.addFunctionBindings( + fromOverloads( + "first", + CelFunctionBinding.from( + "optional_list_first", Collection.class, CelOptionalLibrary::listOptionalFirst))); + runtimeBuilder.addFunctionBindings( + fromOverloads( + "last", + CelFunctionBinding.from( + "optional_list_last", Collection.class, CelOptionalLibrary::listOptionalLast))); + } + } + + private static ImmutableList elideOptionalCollection(Collection> list) { + return list.stream().filter(Optional::isPresent).map(Optional::get).collect(toImmutableList()); + } + + private static boolean isZeroValue(Object val) { + if (val instanceof Boolean) { + return !((Boolean) val); + } else if (val instanceof Long) { + return (Long) val == 0L; + } else if (val instanceof Double) { + return (Double) val == 0.0d; + } else if (val instanceof String) { + return ((String) val).isEmpty(); + } else if (val instanceof UnsignedLong) { + return val.equals(UnsignedLong.ZERO); + } else if (val instanceof Collection) { + return ((Collection) val).isEmpty(); + } else if (val instanceof Map) { + return ((Map) val).isEmpty(); + } else if (val instanceof CelByteString) { + return ((CelByteString) val).isEmpty(); + } else if (val instanceof Duration) { + return val.equals(((Duration) val).getDefaultInstanceForType()); + } else if (val instanceof Timestamp) { + return val.equals(((Timestamp) val).getDefaultInstanceForType()); + } else if (val instanceof Message) { + return val.equals(((Message) val).getDefaultInstanceForType()); + } else if (val instanceof NullValue) { + // A null value always represents an absent value + return true; + } else if (val instanceof Instant) { + return val.equals(Instant.EPOCH); + } else if (val instanceof java.time.Duration) { + return val.equals(java.time.Duration.ZERO); + } else if (val instanceof CelValue) { + return ((CelValue) val).isZeroValue(); + } + + // Unknown. Assume that it is non-zero. + return false; + } + + private static Optional expandOptMap( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 2); + + CelExpr varIdent = checkNotNull(arguments.get(0)); + if (varIdent.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of( + exprFactory.reportError( + CelIssue.formatError( + exprFactory.getSourceLocation(varIdent), + "optMap() variable name must be a simple identifier"))); + } + CelExpr mapExpr = checkNotNull(arguments.get(1)); + String varName = varIdent.ident().name(); + + return Optional.of( + exprFactory.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + exprFactory.newReceiverCall(HAS_VALUE.getFunction(), target), + exprFactory.newGlobalCall( + OPTIONAL_OF.getFunction(), + exprFactory.fold( + UNUSED_ITER_VAR, + exprFactory.newList(), + varName, + exprFactory.newReceiverCall(VALUE.getFunction(), exprFactory.copy(target)), + exprFactory.newBoolLiteral(true), + exprFactory.newIdentifier(varName), + mapExpr)), + exprFactory.newGlobalCall(OPTIONAL_NONE.getFunction()))); + } + + private static Optional expandOptFlatMap( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 2); + + CelExpr varIdent = checkNotNull(arguments.get(0)); + if (varIdent.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of( + exprFactory.reportError( + CelIssue.formatError( + exprFactory.getSourceLocation(varIdent), + "optFlatMap() variable name must be a simple identifier"))); + } + CelExpr mapExpr = checkNotNull(arguments.get(1)); + String varName = varIdent.ident().name(); + + return Optional.of( + exprFactory.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + exprFactory.newReceiverCall(HAS_VALUE.getFunction(), target), + exprFactory.fold( + UNUSED_ITER_VAR, + exprFactory.newList(), + varName, + exprFactory.newReceiverCall(VALUE.getFunction(), exprFactory.copy(target)), + exprFactory.newBoolLiteral(true), + exprFactory.newIdentifier(varName), + mapExpr), + exprFactory.newGlobalCall(OPTIONAL_NONE.getFunction()))); + } + + private static Object indexOptionalMap( + Optional optionalMap, Object key, RuntimeEquality runtimeEquality) { + if (!optionalMap.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(); + } + List list = (List) optionalList.get(); + int castIndex = Ints.checkedCast(index); + if (castIndex < 0 || castIndex >= list.size()) { + return Optional.empty(); + } + return Optional.of(list.get(castIndex)); + } + + @SuppressWarnings("rawtypes") + private static Object listOptionalFirst(Collection list) { + if (list.isEmpty()) { + return Optional.empty(); + } + if (list instanceof List) { + return Optional.ofNullable(((List) list).get(0)); + } + return Optional.ofNullable(Iterables.getFirst(list, null)); + } + + private static Object listOptionalLast(Collection list) { + return Optional.ofNullable(Iterables.getLast(list, null)); + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelProtoExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelProtoExtensions.java new file mode 100644 index 000000000..6fe3c4c0c --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelProtoExtensions.java @@ -0,0 +1,154 @@ +// Copyright 2022 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.extensions; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelIssue; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.internal.Constants; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelMacroExprFactory; +import dev.cel.parser.CelParserBuilder; +import java.util.Optional; + +/** Internal implementation of CEL proto extensions. */ +@Immutable +public final class CelProtoExtensions + implements CelCompilerLibrary, CelExtensionLibrary.FeatureSet { + + private static final String PROTO_NAMESPACE = "proto"; + private static final CelExpr ERROR = CelExpr.newBuilder().setConstant(Constants.ERROR).build(); + + private static final CelExtensionLibrary LIBRARY = + new CelExtensionLibrary() { + private final CelProtoExtensions version0 = new CelProtoExtensions(); + + @Override + public String name() { + return "protos"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0); + } + }; + + static CelExtensionLibrary library() { + return LIBRARY; + } + + @Override + public int version() { + return 0; + } + + @Override + public ImmutableSet macros() { + return ImmutableSet.of( + CelMacro.newReceiverMacro("hasExt", 2, CelProtoExtensions::expandHasProtoExt), + CelMacro.newReceiverMacro("getExt", 2, CelProtoExtensions::expandGetProtoExt)); + } + + @Override + public void setParserOptions(CelParserBuilder parserBuilder) { + parserBuilder.addMacros(macros()); + } + + private static Optional expandHasProtoExt( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + return expandProtoExt(exprFactory, target, arguments, true); + } + + private static Optional expandGetProtoExt( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + return expandProtoExt(exprFactory, target, arguments, false); + } + + private static Optional expandProtoExt( + CelMacroExprFactory exprFactory, + CelExpr target, + ImmutableList arguments, + boolean testOnly) { + if (!isTargetInNamespace(target)) { + // Return empty to indicate that we're not interested in expanding this macro, and + // that the parser should default to a function call on the receiver. + return Optional.empty(); + } + + checkArgument(arguments.size() == 2); + CelExpr arg1 = checkNotNull(arguments.get(0)); + CelExpr arg2 = checkNotNull(arguments.get(1)); + + StringBuilder extensionFieldNameBuilder = new StringBuilder(); + CelExpr result = getExtensionFieldName(arg2, extensionFieldNameBuilder); + if (result.equals(ERROR)) { + return Optional.of( + exprFactory.reportError( + CelIssue.formatError( + exprFactory.getSourceLocation(arg2), "invalid extension field"))); + } + return Optional.of(exprFactory.newSelect(arg1, extensionFieldNameBuilder.toString(), testOnly)); + } + + /** + * Populates the fully qualified extension field name into the string builder. + * + * @param target Target expression. + * @param sb String builder to populate the field name in. + * @return {@link #ERROR} expression if the target expr AST is malformed. + */ + private static CelExpr getExtensionFieldName(CelExpr target, StringBuilder sb) { + if (target.exprKind().getKind() != CelExpr.ExprKind.Kind.SELECT) { + return ERROR; + } + + return buildExtensionFieldName(target, sb); + } + + private static CelExpr buildExtensionFieldName(CelExpr target, StringBuilder sb) { + switch (target.exprKind().getKind()) { + case IDENT: + sb.append(target.ident().name()); + return target; + case SELECT: + CelExpr.CelSelect select = target.select(); + if (select.testOnly()) { + return ERROR; + } + CelExpr operand = buildExtensionFieldName(select.operand(), sb); + if (operand.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return ERROR; + } + sb.append(".").append(select.field()); + return operand; + default: + return ERROR; + } + } + + private static boolean isTargetInNamespace(CelExpr target) { + return target.exprKind().getKind().equals(CelExpr.ExprKind.Kind.IDENT) + && target.ident().name().equals(PROTO_NAMESPACE); + } + + CelProtoExtensions() {} +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelRegexExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelRegexExtensions.java new file mode 100644 index 000000000..564422cd4 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelRegexExtensions.java @@ -0,0 +1,310 @@ +// Copyright 2025 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.extensions; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import com.google.re2j.Matcher; +import com.google.re2j.Pattern; +import com.google.re2j.PatternSyntaxException; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.types.ListType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeLibrary; +import java.util.Optional; +import java.util.Set; + +/** Internal implementation of CEL regex extensions. */ +@Immutable +public final class CelRegexExtensions + implements CelCompilerLibrary, CelRuntimeLibrary, CelExtensionLibrary.FeatureSet { + + private static final String REGEX_REPLACE_FUNCTION = "regex.replace"; + private static final String REGEX_EXTRACT_FUNCTION = "regex.extract"; + private static final String REGEX_EXTRACT_ALL_FUNCTION = "regex.extractAll"; + + enum Function { + REPLACE( + CelFunctionDecl.newFunctionDeclaration( + REGEX_REPLACE_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "regex_replaceAll_string_string_string", + "Replaces all the matched values using the given replace string.", + SimpleType.STRING, + SimpleType.STRING, + SimpleType.STRING, + SimpleType.STRING), + CelOverloadDecl.newGlobalOverload( + "regex_replaceCount_string_string_string_int", + "Replaces the given number of matched values using the given replace string.", + SimpleType.STRING, + SimpleType.STRING, + SimpleType.STRING, + SimpleType.STRING, + SimpleType.INT)), + ImmutableSet.of( + CelFunctionBinding.from( + "regex_replaceAll_string_string_string", + ImmutableList.of(String.class, String.class, String.class), + (args) -> { + String target = (String) args[0]; + String pattern = (String) args[1]; + String replaceStr = (String) args[2]; + return CelRegexExtensions.replace(target, pattern, replaceStr); + }), + CelFunctionBinding.from( + "regex_replaceCount_string_string_string_int", + ImmutableList.of(String.class, String.class, String.class, Long.class), + (args) -> { + String target = (String) args[0]; + String pattern = (String) args[1]; + String replaceStr = (String) args[2]; + long count = (long) args[3]; + return CelRegexExtensions.replaceN(target, pattern, replaceStr, count); + }))), + EXTRACT( + CelFunctionDecl.newFunctionDeclaration( + REGEX_EXTRACT_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "regex_extract_string_string", + "Returns the first substring that matches the regex.", + OptionalType.create(SimpleType.STRING), + SimpleType.STRING, + SimpleType.STRING)), + ImmutableSet.of( + CelFunctionBinding.from( + "regex_extract_string_string", + String.class, + String.class, + CelRegexExtensions::extract))), + EXTRACTALL( + CelFunctionDecl.newFunctionDeclaration( + REGEX_EXTRACT_ALL_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "regex_extractAll_string_string", + "Returns an array of all substrings that match the regex.", + ListType.create(SimpleType.STRING), + SimpleType.STRING, + SimpleType.STRING)), + ImmutableSet.of( + CelFunctionBinding.from( + "regex_extractAll_string_string", + String.class, + String.class, + CelRegexExtensions::extractAll))); + + private final CelFunctionDecl functionDecl; + private final ImmutableSet functionBindings; + + String getFunction() { + return functionDecl.name(); + } + + Function(CelFunctionDecl functionDecl, ImmutableSet functionBindings) { + this.functionDecl = functionDecl; + this.functionBindings = + CelFunctionBinding.fromOverloads(functionDecl.name(), functionBindings); + } + } + + private static final CelExtensionLibrary LIBRARY = + new CelExtensionLibrary() { + private final CelRegexExtensions version0 = new CelRegexExtensions(); + + @Override + public String name() { + return "regex"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0); + } + }; + + static CelExtensionLibrary library() { + return LIBRARY; + } + + private final ImmutableSet functions; + + CelRegexExtensions() { + this.functions = ImmutableSet.copyOf(Function.values()); + } + + CelRegexExtensions(Set functions) { + this.functions = ImmutableSet.copyOf(functions); + } + + @Override + public int version() { + return 0; + } + + @Override + public ImmutableSet functions() { + return functions.stream().map(f -> f.functionDecl).collect(toImmutableSet()); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + functions.forEach(function -> checkerBuilder.addFunctionDeclarations(function.functionDecl)); + } + + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + functions.forEach(function -> runtimeBuilder.addFunctionBindings(function.functionBindings)); + } + + private static Pattern compileRegexPattern(String regex) { + try { + return Pattern.compile(regex); + } catch (PatternSyntaxException e) { + throw new IllegalArgumentException("Failed to compile regex: " + regex, e); + } + } + + private static String replace(String target, String regex, String replaceStr) { + return replaceN(target, regex, replaceStr, -1); + } + + private static String replaceN( + String target, String regex, String replaceStr, long replaceCount) { + if (replaceCount == 0) { + return target; + } + // For all negative replaceCount, do a replaceAll + if (replaceCount < 0) { + replaceCount = -1; + } + + Pattern pattern = compileRegexPattern(regex); + Matcher matcher = pattern.matcher(target); + StringBuffer sb = new StringBuffer(); + int counter = 0; + + while (matcher.find()) { + if (replaceCount != -1 && counter >= replaceCount) { + break; + } + + String processedReplacement = replaceStrValidator(matcher, replaceStr); + matcher.appendReplacement(sb, Matcher.quoteReplacement(processedReplacement)); + counter++; + } + matcher.appendTail(sb); + + return sb.toString(); + } + + private static String replaceStrValidator(Matcher matcher, String replacement) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < replacement.length(); i++) { + char c = replacement.charAt(i); + + if (c != '\\') { + sb.append(c); + continue; + } + + if (i + 1 >= replacement.length()) { + throw new IllegalArgumentException("Invalid replacement string: \\ not allowed at end"); + } + + char nextChar = replacement.charAt(++i); + + if (Character.isDigit(nextChar)) { + int groupNum = Character.digit(nextChar, 10); + int groupCount = matcher.groupCount(); + + if (groupNum > groupCount) { + throw new IllegalArgumentException( + "Replacement string references group " + + groupNum + + " but regex has only " + + groupCount + + " group(s)"); + } + + String groupValue = matcher.group(groupNum); + if (groupValue != null) { + sb.append(groupValue); + } + } else if (nextChar == '\\') { + sb.append('\\'); + } else { + throw new IllegalArgumentException( + "Invalid replacement string: \\ must be followed by a digit"); + } + } + return sb.toString(); + } + + private static Optional extract(String target, String regex) { + Pattern pattern = compileRegexPattern(regex); + Matcher matcher = pattern.matcher(target); + + if (!matcher.find()) { + return Optional.empty(); + } + + int groupCount = matcher.groupCount(); + if (groupCount > 1) { + throw new IllegalArgumentException( + "Regular expression has more than one capturing group: " + regex); + } + + String result = (groupCount == 1) ? matcher.group(1) : matcher.group(0); + + return Optional.ofNullable(result); + } + + private static ImmutableList extractAll(String target, String regex) { + Pattern pattern = compileRegexPattern(regex); + Matcher matcher = pattern.matcher(target); + + if (matcher.groupCount() > 1) { + throw new IllegalArgumentException( + "Regular expression has more than one capturing group: " + regex); + } + + ImmutableList.Builder builder = ImmutableList.builder(); + boolean hasOneGroup = matcher.groupCount() == 1; + + while (matcher.find()) { + if (hasOneGroup) { + String group = matcher.group(1); + // Add the captured group's content only if it's not null + if (group != null) { + builder.add(group); + } + } else { + // No capturing groups + builder.add(matcher.group(0)); + } + } + + return builder.build(); + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelSetsExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelSetsExtensions.java new file mode 100644 index 000000000..324528b05 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelSetsExtensions.java @@ -0,0 +1,151 @@ +// Copyright 2024 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.extensions; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeParamType; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeLibrary; +import dev.cel.runtime.ProtoMessageRuntimeEquality; +import java.util.Set; + +/** + * Internal implementation of CEL Set extensions. + * + *

TODO: https://github.com/google/cel-go/blob/master/ext/sets.go#L127 + * + *

Invoking in operator will result in O(n) complexity. We need to wire in the CEL optimizers to + * rewrite the AST into a map to achieve a O(1) lookup. + */ +@Immutable +public final class CelSetsExtensions + implements CelCompilerLibrary, CelRuntimeLibrary, CelExtensionLibrary.FeatureSet { + + private static final String SET_CONTAINS_OVERLOAD_DOC = + "Returns whether the first list argument contains all elements in the second list" + + " argument. The list may contain elements of any type and standard CEL" + + " equality is used to determine whether a value exists in both lists. If the" + + " second list is empty, the result will always return true."; + private static final String SET_EQUIVALENT_OVERLOAD_DOC = + "Returns whether the first and second list are set equivalent. Lists are set equivalent if" + + " for every item in the first list, there is an element in the second which is equal." + + " The lists may not be of the same size as they do not guarantee the elements within" + + " them are unique, so size does not factor into the computation."; + private static final String SET_INTERSECTS_OVERLOAD_DOC = + "Returns whether the first and second list intersect. Lists intersect if there is at least" + + " one element in the first list which is equal to an element in the second list. The" + + " lists may not be of the same size as they do not guarantee the elements within them" + + " are unique, so size does not factor into the computation. If either list is empty," + + " the result will be false."; + + private static final ImmutableMap FUNCTION_DECL_MAP = + ImmutableMap.of( + SetsFunction.CONTAINS, + CelFunctionDecl.newFunctionDeclaration( + SetsFunction.CONTAINS.getFunction(), + CelOverloadDecl.newGlobalOverload( + "list_sets_contains_list", + SET_CONTAINS_OVERLOAD_DOC, + SimpleType.BOOL, + ListType.create(TypeParamType.create("T")), + ListType.create(TypeParamType.create("T")))), + SetsFunction.EQUIVALENT, + CelFunctionDecl.newFunctionDeclaration( + SetsFunction.EQUIVALENT.getFunction(), + CelOverloadDecl.newGlobalOverload( + "list_sets_equivalent_list", + SET_EQUIVALENT_OVERLOAD_DOC, + SimpleType.BOOL, + ListType.create(TypeParamType.create("T")), + ListType.create(TypeParamType.create("T")))), + SetsFunction.INTERSECTS, + CelFunctionDecl.newFunctionDeclaration( + SetsFunction.INTERSECTS.getFunction(), + CelOverloadDecl.newGlobalOverload( + "list_sets_intersects_list", + SET_INTERSECTS_OVERLOAD_DOC, + SimpleType.BOOL, + ListType.create(TypeParamType.create("T")), + ListType.create(TypeParamType.create("T"))))); + + private static final class Library implements CelExtensionLibrary { + private final CelSetsExtensions version0; + + Library(CelOptions celOptions) { + version0 = new CelSetsExtensions(celOptions); + } + + @Override + public String name() { + return "sets"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0); + } + } + + static CelExtensionLibrary library(CelOptions options) { + return new Library(options); + } + + private final ImmutableSet functions; + private final SetsExtensionsRuntimeImpl setsExtensionsRuntime; + + CelSetsExtensions(CelOptions celOptions) { + this(celOptions, ImmutableSet.copyOf(SetsFunction.values())); + } + + CelSetsExtensions(CelOptions celOptions, Set functions) { + this.functions = ImmutableSet.copyOf(functions); + ProtoMessageRuntimeEquality runtimeEquality = + ProtoMessageRuntimeEquality.create( + DynamicProto.create(DefaultMessageFactory.INSTANCE), celOptions); + this.setsExtensionsRuntime = new SetsExtensionsRuntimeImpl(runtimeEquality, functions); + } + + @Override + public int version() { + return 0; + } + + @Override + public ImmutableSet functions() { + return ImmutableSet.copyOf(FUNCTION_DECL_MAP.values()); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + functions.forEach( + function -> checkerBuilder.addFunctionDeclarations(FUNCTION_DECL_MAP.get(function))); + } + + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + runtimeBuilder.addFunctionBindings(setsExtensionsRuntime.newFunctionBindings()); + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelStringExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelStringExtensions.java new file mode 100644 index 000000000..2bb477b82 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelStringExtensions.java @@ -0,0 +1,795 @@ +// Copyright 2022 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.extensions; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static java.lang.Math.max; +import static java.lang.Math.min; + +import com.google.common.base.Ascii; +import com.google.common.base.Joiner; +import com.google.common.base.Splitter; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.internal.CelCodePointArray; +import dev.cel.common.types.ListType; +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.CelFunctionBinding; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeLibrary; +import java.util.List; +import java.util.Set; + +/** Internal implementation of CEL string extensions. */ +@Immutable +public final class CelStringExtensions + implements CelCompilerLibrary, CelRuntimeLibrary, CelExtensionLibrary.FeatureSet { + + /** Denotes the string extension function */ + @SuppressWarnings({"unchecked"}) // Unchecked: Type-checker guarantees casting safety. + public enum Function { + CHAR_AT( + CelFunctionDecl.newFunctionDeclaration( + "charAt", + CelOverloadDecl.newMemberOverload( + "string_char_at_int", + "Returns the character at the given position. If the position is negative, or" + + " greater than the length of the string, the function will produce an error.", + SimpleType.STRING, + ImmutableList.of(SimpleType.STRING, SimpleType.INT))), + CelFunctionBinding.from( + "string_char_at_int", String.class, Long.class, CelStringExtensions::charAt)), + INDEX_OF( + CelFunctionDecl.newFunctionDeclaration( + "indexOf", + CelOverloadDecl.newMemberOverload( + "string_index_of_string", + "Returns the integer index of the first occurrence of the search string. If the" + + " search string is not found the function returns -1.", + SimpleType.INT, + ImmutableList.of(SimpleType.STRING, SimpleType.STRING)), + CelOverloadDecl.newMemberOverload( + "string_index_of_string_int", + "Returns the integer index of the first occurrence of the search string from the" + + " given offset. If the search string is not found the function returns" + + " -1. If the substring is the empty string, the index where the search starts" + + " is returned (zero or custom).", + SimpleType.INT, + ImmutableList.of(SimpleType.STRING, SimpleType.STRING, SimpleType.INT))), + CelFunctionBinding.from( + "string_index_of_string", String.class, String.class, CelStringExtensions::indexOf), + CelFunctionBinding.from( + "string_index_of_string_int", + ImmutableList.of(String.class, String.class, Long.class), + CelStringExtensions::indexOf)), + JOIN( + CelFunctionDecl.newFunctionDeclaration( + "join", + CelOverloadDecl.newMemberOverload( + "list_join", + "Returns a new string where the elements of string list are concatenated.", + SimpleType.STRING, + ListType.create(SimpleType.STRING)), + CelOverloadDecl.newMemberOverload( + "list_join_string", + "Returns a new string where the elements of string list are concatenated using the" + + " separator.", + SimpleType.STRING, + ImmutableList.of(ListType.create(SimpleType.STRING), SimpleType.STRING))), + CelFunctionBinding.from("list_join", List.class, CelStringExtensions::join), + CelFunctionBinding.from( + "list_join_string", List.class, String.class, CelStringExtensions::join)), + LAST_INDEX_OF( + CelFunctionDecl.newFunctionDeclaration( + "lastIndexOf", + CelOverloadDecl.newMemberOverload( + "string_last_index_of_string", + "Returns the integer index of the last occurrence of the search string. If the" + + " search string is not found the function returns -1.", + SimpleType.INT, + ImmutableList.of(SimpleType.STRING, SimpleType.STRING)), + CelOverloadDecl.newMemberOverload( + "string_last_index_of_string_int", + "Returns the integer index of the last occurrence of the search string from the" + + " given offset. If the search string is not found the function returns -1. If" + + " the substring is the empty string, the index where the search starts is" + + " returned (string length or custom).", + SimpleType.INT, + ImmutableList.of(SimpleType.STRING, SimpleType.STRING, SimpleType.INT))), + CelFunctionBinding.from( + "string_last_index_of_string", + String.class, + String.class, + CelStringExtensions::lastIndexOf), + CelFunctionBinding.from( + "string_last_index_of_string_int", + ImmutableList.of(String.class, String.class, Long.class), + CelStringExtensions::lastIndexOf)), + LOWER_ASCII( + CelFunctionDecl.newFunctionDeclaration( + "lowerAscii", + CelOverloadDecl.newMemberOverload( + "string_lower_ascii", + "Returns a new string where all ASCII characters are lower-cased. This function" + + " does not perform Unicode case-mapping for characters outside the ASCII" + + " range.", + SimpleType.STRING, + SimpleType.STRING)), + CelFunctionBinding.from("string_lower_ascii", String.class, Ascii::toLowerCase)), + QUOTE( + CelFunctionDecl.newFunctionDeclaration( + "strings.quote", + CelOverloadDecl.newGlobalOverload( + "strings_quote", + "Takes the given string and makes it safe to print (without any formatting" + + " due to escape sequences). If any invalid UTF-8 characters are" + + " encountered, they are replaced with \\uFFFD.", + SimpleType.STRING, + ImmutableList.of(SimpleType.STRING))), + CelFunctionBinding.from("strings_quote", String.class, CelStringExtensions::quote)), + REPLACE( + CelFunctionDecl.newFunctionDeclaration( + "replace", + CelOverloadDecl.newMemberOverload( + "string_replace_string_string", + "Returns a new string based on the target, which replaces the occurrences of a" + + " search string with a replacement string if present.", + SimpleType.STRING, + ImmutableList.of(SimpleType.STRING, SimpleType.STRING, SimpleType.STRING)), + CelOverloadDecl.newMemberOverload( + "string_replace_string_string_int", + "Returns a new string based on the target, which replaces the occurrences of a" + + " search string with a replacement string if present. The function accepts a" + + " limit on the number of substring replacements to be made. When the" + + " replacement limit is 0, the result is the original string. When the limit" + + " is a negative number, the function behaves the same as replace all.", + SimpleType.STRING, + ImmutableList.of( + SimpleType.STRING, SimpleType.STRING, SimpleType.STRING, SimpleType.INT))), + CelFunctionBinding.from( + "string_replace_string_string", + ImmutableList.of(String.class, String.class, String.class), + CelStringExtensions::replaceAll), + CelFunctionBinding.from( + "string_replace_string_string_int", + ImmutableList.of(String.class, String.class, String.class, Long.class), + CelStringExtensions::replace)), + REVERSE( + CelFunctionDecl.newFunctionDeclaration( + "reverse", + CelOverloadDecl.newMemberOverload( + "string_reverse", + "Returns a new string whose characters are the same as the target string," + + " only formatted in reverse order.", + SimpleType.STRING, + SimpleType.STRING)), + CelFunctionBinding.from("string_reverse", String.class, CelStringExtensions::reverse)), + SPLIT( + CelFunctionDecl.newFunctionDeclaration( + "split", + CelOverloadDecl.newMemberOverload( + "string_split_string", + "Returns a mutable list of strings split from the input by the given separator.", + ListType.create(SimpleType.STRING), + ImmutableList.of(SimpleType.STRING, SimpleType.STRING)), + CelOverloadDecl.newMemberOverload( + "string_split_string_int", + "Returns a mutable list of strings split from the input by the given separator with" + + " the specified limit on the number of substrings produced by the split.", + ListType.create(SimpleType.STRING), + ImmutableList.of(SimpleType.STRING, SimpleType.STRING, SimpleType.INT))), + CelFunctionBinding.from( + "string_split_string", String.class, String.class, CelStringExtensions::split), + CelFunctionBinding.from( + "string_split_string_int", + ImmutableList.of(String.class, String.class, Long.class), + CelStringExtensions::split)), + SUBSTRING( + CelFunctionDecl.newFunctionDeclaration( + "substring", + CelOverloadDecl.newMemberOverload( + "string_substring_int", + "returns a string that is a substring of this string. The substring begins with the" + + " character at the specified index and extends to the end of this string.", + SimpleType.STRING, + ImmutableList.of(SimpleType.STRING, SimpleType.INT)), + CelOverloadDecl.newMemberOverload( + "string_substring_int_int", + "returns a string that is a substring of this string. The substring begins at the" + + " specified beginIndex and extends to the character at index endIndex - 1." + + " Thus the length of the substring is {@code endIndex-beginIndex}.", + SimpleType.STRING, + ImmutableList.of(SimpleType.STRING, SimpleType.INT, SimpleType.INT))), + CelFunctionBinding.from( + "string_substring_int", String.class, Long.class, CelStringExtensions::substring), + CelFunctionBinding.from( + "string_substring_int_int", + ImmutableList.of(String.class, Long.class, Long.class), + CelStringExtensions::substring)), + TRIM( + CelFunctionDecl.newFunctionDeclaration( + "trim", + CelOverloadDecl.newMemberOverload( + "string_trim", + "Returns a new string which removes the leading and trailing whitespace in the" + + " target string. The trim function uses the Unicode definition of whitespace" + + " which does not include the zero-width spaces. ", + SimpleType.STRING, + SimpleType.STRING)), + CelFunctionBinding.from("string_trim", String.class, CelStringExtensions::trim)), + UPPER_ASCII( + CelFunctionDecl.newFunctionDeclaration( + "upperAscii", + CelOverloadDecl.newMemberOverload( + "string_upper_ascii", + "Returns a new string where all ASCII characters are upper-cased. This function" + + " does not perform Unicode case-mapping for characters outside the ASCII" + + " range.", + SimpleType.STRING, + SimpleType.STRING)), + CelFunctionBinding.from("string_upper_ascii", String.class, Ascii::toUpperCase)); + + private final CelFunctionDecl functionDecl; + private final ImmutableSet functionBindings; + + String getFunction() { + return functionDecl.name(); + } + + Function(CelFunctionDecl functionDecl, CelFunctionBinding... functionBindings) { + this.functionDecl = functionDecl; + this.functionBindings = + CelFunctionBinding.fromOverloads(functionDecl.name(), functionBindings); + } + } + + private final ImmutableSet functions; + + CelStringExtensions() { + this(ImmutableSet.copyOf(Function.values())); + } + + CelStringExtensions(Set functions) { + this.functions = ImmutableSet.copyOf(functions); + } + + private static final CelExtensionLibrary LIBRARY = + new CelExtensionLibrary() { + private final CelStringExtensions version0 = new CelStringExtensions(); + + @Override + public String name() { + return "strings"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0); + } + }; + + static CelExtensionLibrary library() { + return LIBRARY; + } + + @Override + public int version() { + return 0; + } + + @Override + public ImmutableSet functions() { + return functions.stream().map(f -> f.functionDecl).collect(toImmutableSet()); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + functions.forEach(function -> checkerBuilder.addFunctionDeclarations(function.functionDecl)); + } + + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + functions.forEach(function -> runtimeBuilder.addFunctionBindings(function.functionBindings)); + } + + private static String charAt(String s, long i) throws CelEvaluationException { + int index; + try { + index = Math.toIntExact(i); + } catch (ArithmeticException 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 CelEvaluationExceptionBuilder.newBuilder( + "charAt failure: Index out of range: %d", index) + .build(); + } + + return codePointArray.slice(index, index + 1).toString(); + } + + private static Long indexOf(String str, String substr) throws CelEvaluationException { + Object[] params = {str, substr, 0L}; + return indexOf(params); + } + + /** + * @param args Object array with indices of: [0: string], [1: substring], [2: offset] + */ + private static Long indexOf(Object[] args) throws CelEvaluationException { + String str = (String) args[0]; + String substr = (String) args[1]; + long offsetInLong = (Long) args[2]; + int offset; + try { + offset = Math.toIntExact(offsetInLong); + } catch (ArithmeticException e) { + throw CelEvaluationExceptionBuilder.newBuilder( + "indexOf failure: Offset must not exceed the int32 range: %d", offsetInLong) + .setCause(e) + .build(); + } + + return indexOf(str, substr, offset); + } + + private static Long indexOf(String str, String substr, int offset) throws CelEvaluationException { + if (substr.isEmpty()) { + return (long) offset; + } + + CelCodePointArray strCpa = CelCodePointArray.fromString(str); + CelCodePointArray substrCpa = CelCodePointArray.fromString(substr); + + if (offset < 0 || offset >= strCpa.length()) { + throw CelEvaluationExceptionBuilder.newBuilder( + "indexOf failure: Offset out of range: %d", offset) + .build(); + } + + return safeIndexOf(strCpa, substrCpa, offset); + } + + /** Retrieves the index of the substring in a given string without throwing. */ + private static Long safeIndexOf(CelCodePointArray str, CelCodePointArray substr, int offset) { + for (int i = offset; i < str.length() - (substr.length() - 1); i++) { + int j; + for (j = 0; j < substr.length(); j++) { + if (str.get(i + j) != substr.get(j)) { + break; + } + } + + if (j == substr.length()) { + return (long) i; + } + } + + // Offset is out of bound. + return -1L; + } + + private static String join(List stringList) { + return join(stringList, ""); + } + + private static String join(List stringList, String separator) { + return Joiner.on(separator).join(stringList); + } + + private static Long lastIndexOf(String str, String substr) throws CelEvaluationException { + CelCodePointArray strCpa = CelCodePointArray.fromString(str); + CelCodePointArray substrCpa = CelCodePointArray.fromString(substr); + if (substrCpa.isEmpty()) { + return (long) strCpa.length(); + } + + if (strCpa.length() < substrCpa.length()) { + return -1L; + } + + return lastIndexOf(strCpa, substrCpa, (long) strCpa.length() - 1); + } + + private static Long lastIndexOf(Object[] args) throws CelEvaluationException { + CelCodePointArray strCpa = CelCodePointArray.fromString((String) args[0]); + CelCodePointArray substrCpa = CelCodePointArray.fromString((String) args[1]); + long offset = (long) args[2]; + + return lastIndexOf(strCpa, substrCpa, offset); + } + + private static Long lastIndexOf(CelCodePointArray str, CelCodePointArray substr, long offset) + throws CelEvaluationException { + if (substr.isEmpty()) { + return offset; + } + + int off; + try { + off = Math.toIntExact(offset); + } catch (ArithmeticException 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 CelEvaluationExceptionBuilder.newBuilder( + "lastIndexOf failure: Offset out of range: %d", offset) + .build(); + } + + if (off > str.length() - substr.length()) { + off = str.length() - substr.length(); + } + + for (int i = off; i >= 0; i--) { + int j; + for (j = 0; j < substr.length(); j++) { + if (str.get(i + j) != substr.get(j)) { + break; + } + } + + if (j == substr.length()) { + return (long) i; + } + } + + return -1L; + } + + private static String quote(String s) { + StringBuilder sb = new StringBuilder(s.length() + 2); + sb.append('"'); + for (int i = 0; i < s.length(); ) { + int codePoint = s.codePointAt(i); + if (isMalformedUtf16(s, i)) { + sb.append('\uFFFD'); + i++; + continue; + } + switch (codePoint) { + case '\u0007': + sb.append("\\a"); + break; + case '\b': + sb.append("\\b"); + break; + case '\f': + sb.append("\\f"); + break; + case '\n': + sb.append("\\n"); + break; + case '\r': + sb.append("\\r"); + break; + case '\t': + sb.append("\\t"); + break; + case '\u000B': + sb.append("\\v"); + break; + case '\\': + sb.append("\\\\"); + break; + case '"': + sb.append("\\\""); + break; + default: + sb.appendCodePoint(codePoint); + break; + } + i += Character.charCount(codePoint); + } + sb.append('"'); + return sb.toString(); + } + + private static boolean isMalformedUtf16(String s, int index) { + char currentChar = s.charAt(index); + if (Character.isLowSurrogate(currentChar)) { + return true; + } + // Check for unpaired high surrogate + return Character.isHighSurrogate(currentChar) + && (index + 1 >= s.length() || !Character.isLowSurrogate(s.charAt(index + 1))); + } + + private static String replaceAll(Object[] objects) { + return replace((String) objects[0], (String) objects[1], (String) objects[2], -1); + } + + private static String replace(Object[] objects) throws CelEvaluationException { + Long indexInLong = (Long) objects[3]; + int index; + try { + index = Math.toIntExact(indexInLong); + } catch (ArithmeticException 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); + } + + private static String replace(String text, String searchString, String replacement, int limit) { + if (searchString.equals(replacement) || limit == 0) { + return text; + } + + if (text.isEmpty()) { + return searchString.isEmpty() ? replacement : ""; + } + + CelCodePointArray textCpa = CelCodePointArray.fromString(text); + CelCodePointArray searchCpa = CelCodePointArray.fromString(searchString); + CelCodePointArray replaceCpa = CelCodePointArray.fromString(replacement); + + int start = 0; + int end = Math.toIntExact(safeIndexOf(textCpa, searchCpa, 0)); + if (end < 0) { + return text; + } + + // The minimum length of 1 handles the case of searchString being empty, where every character + // would be matched. This ensures the window is always moved forward to continue the search. + int minSearchLength = max(searchCpa.length(), 1); + StringBuilder sb = + new StringBuilder(textCpa.length() - searchCpa.length() + replaceCpa.length()); + + do { + CelCodePointArray sliced = textCpa.slice(start, end); + sb.append(sliced).append(replaceCpa); + start = end + searchCpa.length(); + limit--; + } while (limit != 0 + && (end = Math.toIntExact(safeIndexOf(textCpa, searchCpa, end + minSearchLength))) > 0); + + return sb.append(textCpa.slice(start, textCpa.length())).toString(); + } + + private static String reverse(String s) { + return new StringBuilder(s).reverse().toString(); + } + + private static ImmutableList split(String str, String separator) { + return split(str, separator, Integer.MAX_VALUE); + } + + /** + * @param args Object array with indices of: [0: string], [1: separator], [2: limit] + */ + private static ImmutableList split(Object[] args) throws CelEvaluationException { + long limitInLong = (Long) args[2]; + int limit; + try { + limit = Math.toIntExact(limitInLong); + } catch (ArithmeticException 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); + } + + /** Returns an immutable list of strings split on the separator */ + private static ImmutableList split(String str, String separator, int limit) { + if (limit == 0) { + return ImmutableList.of(); + } + + if (limit == 1) { + return ImmutableList.of(str); + } + + if (limit < 0) { + limit = str.length(); + } + + if (separator.isEmpty()) { + return explode(str, limit); + } + + Iterable splitString = Splitter.on(separator).limit(limit).split(str); + return ImmutableList.copyOf(splitString); + } + + /** + * Explodes a given string up to a limit + * + *

Example 1: "aκ°€b😁" (no limit or negative limit) -> ["a", "κ°€", "b", "😁"] + * + *

Example 2: "aκ°€b😁" (limit 2) -> ["a", "κ°€", "b😁"] + * + *

This exists because neither the built-in String.split nor Guava's splitter is able to deal + * with separating single printable characters. + */ + private static ImmutableList explode(String str, int limit) { + ImmutableList.Builder exploded = ImmutableList.builder(); + CelCodePointArray codePointArray = CelCodePointArray.fromString(str); + if (limit > 0) { + limit -= 1; + } + int charCount = min(codePointArray.length(), limit); + for (int i = 0; i < charCount; i++) { + exploded.add(codePointArray.slice(i, i + 1).toString()); + } + if (codePointArray.length() > limit) { + exploded.add(codePointArray.slice(limit, codePointArray.length()).toString()); + } + return exploded.build(); + } + + private static Object substring(String s, long i) throws CelEvaluationException { + int beginIndex; + try { + beginIndex = Math.toIntExact(i); + } catch (ArithmeticException 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 CelEvaluationExceptionBuilder.newBuilder( + "substring failure: Range [%d, %d) out of bounds", + beginIndex, codePointArray.length()) + .build(); + } + + if (beginIndex == codePointArray.length()) { + return ""; + } + + return codePointArray.slice(beginIndex, codePointArray.length()).toString(); + } + + /** + * @param args Object array with indices of [0: string], [1: beginIndex], [2: endIndex] + */ + private static String substring(Object[] args) throws CelEvaluationException { + Long beginIndexInLong = (Long) args[1]; + Long endIndexInLong = (Long) args[2]; + int beginIndex; + int endIndex; + try { + beginIndex = Math.toIntExact(beginIndexInLong); + endIndex = Math.toIntExact(endIndexInLong); + } catch (ArithmeticException e) { + throw CelEvaluationExceptionBuilder.newBuilder( + "substring failure: Indices must not exceed the int32 range: [%d, %d)", + beginIndexInLong, endIndexInLong) + .setCause(e) + .build(); + } + + String s = (String) args[0]; + CelCodePointArray codePointArray = CelCodePointArray.fromString(s); + + boolean indicesIsInRange = + beginIndex <= endIndex + && beginIndex >= 0 + && beginIndex <= codePointArray.length() + && endIndex <= codePointArray.length(); + if (!indicesIsInRange) { + throw CelEvaluationExceptionBuilder.newBuilder( + "substring failure: Range [%d, %d) out of bounds", beginIndex, endIndex) + .build(); + } + + if (beginIndex == endIndex) { + return ""; + } + + return codePointArray.slice(beginIndex, endIndex).toString(); + } + + private static String trim(String text) { + CelCodePointArray textCpa = CelCodePointArray.fromString(text); + int left = indexOfNonWhitespace(textCpa); + if (left == textCpa.length()) { + return ""; + } + int right = lastIndexOfNonWhitespace(textCpa); + return textCpa.slice(left, right + 1).toString(); + } + + /** + * Finds the first index of the non-whitespace character found in the string. See {@link + * #isWhitespace} for definition of a whitespace char. + * + * @return index of first non-whitespace character found (ex: " test " -> 0). Length of the string + * is returned instead if a non-whitespace character is not found. + */ + private static int indexOfNonWhitespace(CelCodePointArray textCpa) { + for (int i = 0; i < textCpa.length(); i++) { + if (!isWhitespace(textCpa.get(i))) { + return i; + } + } + return textCpa.length(); + } + + /** + * Finds the last index of the non-whitespace character found in the string. See {@link + * #isWhitespace} for definition of a whitespace char. + * + * @return index of last non-whitespace character found. (ex: " test " -> 5). 0 is returned + * instead if a non-whitespace char is not found. -1 is returned for an empty string (""). + */ + private static int lastIndexOfNonWhitespace(CelCodePointArray textCpa) { + if (textCpa.isEmpty()) { + return -1; + } + + for (int i = textCpa.length() - 1; i >= 0; i--) { + if (!isWhitespace(textCpa.get(i))) { + return i; + } + } + + return 0; + } + + /** + * Checks if a provided codepoint is a whitespace according to Unicode's standard + * (White_Space=yes). + * + *

This exists because Java's native Character.isWhitespace does not follow the Unicode's + * standard of whitespace definition. + * + *

See link for the full list. + */ + private static boolean isWhitespace(int codePoint) { + return (codePoint >= 0x0009 && codePoint <= 0x000D) + || codePoint == 0x0020 + || codePoint == 0x0085 + || codePoint == 0x00A0 + || codePoint == 0x1680 + || (codePoint >= 0x2000 && codePoint <= 0x200A) + || codePoint == 0x2028 + || codePoint == 0x2029 + || codePoint == 0x202F + || codePoint == 0x205F + || codePoint == 0x3000; + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/README.md b/extensions/src/main/java/dev/cel/extensions/README.md new file mode 100644 index 000000000..e6ee73aba --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/README.md @@ -0,0 +1,1128 @@ +# Extensions + +CEL extensions are a related set of constants, functions, macros, or other +features which may not be covered by the core CEL spec. + +To use, supply the desired extensions into `CelCompiler` and `CelRuntime` +through `addLibrary` methods in their builder: + + CelCompilerFactory.standardCelCompilerBuilder().addLibraries(CelExtensions.strings()) + CelRuntimeFactory.standardCelRuntimeBuilder().addLibraries(CelExtensions.strings()) + +## Cel + +The `cel` namespace is reserved for linguistic constructs which augment the +expressiveness of the language. + +### Cel.Bind + +Binds a simple identifier to an initialization expression which may be used in a +subsequent result expression. Bindings may also be nested within each other. + + cel.bind(, , ) + +Examples: + + cel.bind(a, 'hello', + cel.bind(b, 'world', a + b + b + a)) // "helloworldworldhello" + + // Avoid a list allocation within the exists comprehension. + cel.bind(valid_values, [a, b, c], + [d, e, f].exists(elem, elem in valid_values)) + + cel.bind(sum, x + y + z, sum < 10 || sum > 20) + +Local bindings are not guaranteed to be evaluated before use. + +## Math + +Math configures namespaced math helper macros and functions. + +Note, all macros use the 'math' namespace; however, at the time of macro +expansion the namespace looks just like any other identifier. If you are +currently using a variable named 'math', the macro will likely work just as +intended; however, there is some chance for collision. + +### Math.Greatest + +Returns the greatest valued number present in the arguments to the macro. + +Greatest is a variable argument count macro which must take at least one +argument. Simple numeric and list literals are supported as valid argument +types; however, other literals will be flagged as errors during macro +expansion. If the argument expression does not resolve to a numeric or +list(numeric) type during type-checking, or during runtime then an error +will be produced. If a list argument is empty, this too will produce an +error. + + math.greatest(, ...) -> + +Examples: + + math.greatest(1) // 1 + math.greatest(1u, 2u) // 2u + math.greatest(-42.0, -21.5, -100.0) // -21.5 + math.greatest([-42.0, -21.5, -100.0]) // -21.5 + math.greatest(numbers) // numbers must be list(numeric) + + math.greatest() // parse error + math.greatest('string') // parse error + math.greatest(a, b) // check-time error if a or b is non-numeric + math.greatest(dyn('string')) // runtime error + +### Math.Least + +Returns the least valued number present in the arguments to the macro. + +Least is a variable argument count macro which must take at least one +argument. Simple numeric and list literals are supported as valid argument +types; however, other literals will be flagged as errors during macro +expansion. If the argument expression does not resolve to a numeric or +list(numeric) type during type-checking, or during runtime then an error +will be produced. If a list argument is empty, this too will produce an error. + + math.least(, ...) -> + +Examples: + + math.least(1) // 1 + math.least(1u, 2u) // 1u + math.least(-42.0, -21.5, -100.0) // -100.0 + math.least([-42.0, -21.5, -100.0]) // -100.0 + math.least(numbers) // numbers must be list(numeric) + + math.least() // parse error + math.least('string') // parse error + math.least(a, b) // check-time error if a or b is non-numeric + math.least(dyn('string')) // runtime error + +### Math.BitOr + +Introduced at version: 1 + +Performs a bitwise-OR operation over two int or uint values. + + math.bitOr(, ) -> + math.bitOr(, ) -> + +Examples: + + math.bitOr(1u, 2u) // returns 3u + math.bitOr(-2, -4) // returns -2 + +### Math.BitAnd + +Introduced at version: 1 + +Performs a bitwise-AND operation over two int or uint values. + + math.bitAnd(, ) -> + math.bitAnd(, ) -> + +Examples: + + math.bitAnd(3u, 2u) // return 2u + math.bitAnd(3, 5) // returns 3 + math.bitAnd(-3, -5) // returns -7 + +### Math.BitXor + +Introduced at version: 1 + + math.bitXor(, ) -> + math.bitXor(, ) -> + +Performs a bitwise-XOR operation over two int or uint values. + +Examples: + + math.bitXor(3u, 5u) // returns 6u + math.bitXor(1, 3) // returns 2 + +### Math.BitNot + +Introduced at version: 1 + +Function which accepts a single int or uint and performs a bitwise-NOT +ones-complement of the given binary value. + + math.bitNot() -> + math.bitNot() -> + +Examples + + math.bitNot(1) // returns -1 + math.bitNot(-1) // return 0 + math.bitNot(0u) // returns 18446744073709551615u + +### Math.BitShiftLeft + +Introduced at version: 1 + +Perform a left shift of bits on the first parameter, by the amount of bits +specified in the second parameter. The first parameter is either a uint or +an int. The second parameter must be an int. + +When the second parameter is 64 or greater, 0 will be always be returned +since the number of bits shifted is greater than or equal to the total bit +length of the number being shifted. Negative valued bit shifts will result +in a runtime error. + + math.bitShiftLeft(, ) -> + math.bitShiftLeft(, ) -> + +Examples + + math.bitShiftLeft(1, 2) // returns 4 + math.bitShiftLeft(-1, 2) // returns -4 + math.bitShiftLeft(1u, 2) // return 4u + math.bitShiftLeft(1u, 200) // returns 0u + +### Math.BitShiftRight + +Introduced at version: 1 + +Perform a right shift of bits on the first parameter, by the amount of bits +specified in the second parameter. The first parameter is either a uint or +an int. The second parameter must be an int. + +When the second parameter is 64 or greater, 0 will always be returned since +the number of bits shifted is greater than or equal to the total bit length +of the number being shifted. Negative valued bit shifts will result in a +runtime error. + +The sign bit extension will not be preserved for this operation: vacant bits +on the left are filled with 0. + + math.bitShiftRight(, ) -> + math.bitShiftRight(, ) -> + +Examples + + math.bitShiftRight(1024, 2) // returns 256 + math.bitShiftRight(1024u, 2) // returns 256u + math.bitShiftRight(1024u, 64) // returns 0u + +### Math.Ceil + +Introduced at version: 1 + +Compute the ceiling of a double value. + + math.ceil() -> + +Examples: + + math.ceil(1.2) // returns 2.0 + math.ceil(-1.2) // returns -1.0 + +### Math.Floor + +Introduced at version: 1 + +Compute the floor of a double value. + + math.floor() -> + +Examples: + + math.floor(1.2) // returns 1.0 + math.floor(-1.2) // returns -2.0 + +### Math.Round + +Introduced at version: 1 + +Rounds the double value to the nearest whole number with ties rounding away +from zero, e.g. 1.5 -> 2.0, -1.5 -> -2.0. + + math.round() -> + +Examples: + + math.round(1.2) // returns 1.0 + math.round(1.5) // returns 2.0 + math.round(-1.5) // returns -2.0 + +### Math.Trunc + +Introduced at version: 1 + +Truncates the fractional portion of the double value. + + math.trunc() -> + +Examples: + + math.trunc(-1.3) // returns -1.0 + math.trunc(1.3) // returns 1.0 + +### Math.Abs + +Introduced at version: 1 + +Returns the absolute value of the numeric type provided as input. If the +value is NaN, the output is NaN. If the input is int64 min, the function +will result in an overflow error. + + math.abs() -> + math.abs() -> + math.abs() -> + +Examples: + + math.abs(-1) // returns 1 + math.abs(1) // returns 1 + math.abs(-9223372036854775808) // overlflow error + +### Math.Sign + +Introduced at version: 1 + +Returns the sign of the numeric type, either -1, 0, 1 as an int, double, or +uint depending on the overload. For floating point values, if NaN is +provided as input, the output is also NaN. The implementation does not +differentiate between positive and negative zero. + + math.sign() -> + math.sign() -> + math.sign() -> + +Examples: + + math.sign(-42) // returns -1 + math.sign(0) // returns 0 + math.sign(42) // returns 1 + +### Math.IsInf + +Introduced at version: 1 + +Returns true if the input double value is -Inf or +Inf. + + math.isInf() -> + +Examples: + + math.isInf(1.0/0.0) // returns true + math.isInf(1.2) // returns false + +### Math.IsNaN + +Introduced at version: 1 + +Returns true if the input double value is NaN, false otherwise. + + math.isNaN() -> + +Examples: + + math.isNaN(0.0/0.0) // returns true + math.isNaN(1.2) // returns false + +### Math.IsFinite + +Introduced at version: 1 + +Returns true if the value is a finite number. Equivalent in behavior to: +!math.isNaN(double) && !math.isInf(double) + + math.isFinite() -> + +Examples: + + math.isFinite(0.0/0.0) // returns false + math.isFinite(1.2) // returns true + +### Math.sqrt + +Introduced at version: 2 + +Returns the square root of the numeric type provided as input. If the value is +NaN, the output is NaN. If the input is negative, the output is NaN. + + math.sqrt() -> + math.sqrt() -> + math.sqrt() -> + +Examples: + + math.sqrt(81.0) // returns 9.0 + math.sqrt(4) // returns 2.0 + math.sqrt(-4) // returns NaN + +## Protos + +Extended macros and functions for proto manipulation. + +Protos configures extended macros and functions for proto manipulation. + +Note, all macros use the 'proto' namespace; however, at the time of macro +expansion the namespace looks just like any other identifier. If you are +currently using a variable named 'proto', the macro will likely work just as +you intend; however, there is some chance for collision. + +### Proto.GetExt + +Macro which generates a select expression that retrieves an extension field +from the input proto2 syntax message. If the field is not set, the default +value for the extension field is returned according to safe-traversal semantics. + + proto.getExt(, ) -> + +Example: + + proto.getExt(msg, google.expr.proto2.test.int32_ext) // returns int value + +### Proto.HasExt + +Macro which generates a test-only select expression that determines whether +an extension field is set on a proto2 syntax message. + + proto.hasExt(, ) -> + +Example: + + proto.hasExt(msg, google.expr.proto2.test.int32_ext) // returns true || false + +## Strings + +Extended functions for string manipulation. As a general note, all indices are +zero-based. + +### CharAt + +Returns the character at the given position. If the position is negative, or greater than +the length of the string, the function will produce an error. + + .charAt() -> + +Examples: + + 'hello'.charAt(4) // return 'o' + 'hello'.charAt(5) // return '' + 'hello'.charAt(-1) // error + +### IndexOf + +Returns the integer index of the first occurrence of the search string. If the search string is +not found the function returns -1. + +The function also accepts an optional offset from which to begin the substring search. If the +substring is the empty string, the index where the search starts is returned (zero or custom). + + .indexOf() -> + .indexOf(, ) -> + +Examples: + + 'hello mellow'.indexOf('') // returns 0 + 'hello mellow'.indexOf('ello') // returns 1 + 'hello mellow'.indexOf('jello') // returns -1 + 'hello mellow'.indexOf('', 2) // returns 2 + 'hello mellow'.indexOf('ello', 2) // returns 7 + 'hello mellow'.indexOf('ello', 20) // error + +### Join + +Returns a new string where the elements of string list are concatenated. + +The function also accepts an optional separator which is placed between elements in the resulting string. + + >.join() -> + >.join() -> + +Examples: + + ['hello', 'mellow'].join() // returns 'hellomellow' + ['hello', 'mellow'].join(' ') // returns 'hello mellow' + [].join() // returns '' + [].join('/') // returns '' + +### LastIndexOf + +Returns the integer index of the last occurrence of the search string. If the +search string is not found the function returns -1. + +The function also accepts an optional offset which represents the last index +to be considered as the beginning of the substring match. If the substring is +the empty string, the index where the search starts is returned (string length +or custom). + + .lastIndexOf() -> + .lastIndexOf(, ) -> + +Examples: + + 'hello mellow'.lastIndexOf('') // returns 12 + 'hello mellow'.lastIndexOf('ello') // returns 7 + 'hello mellow'.lastIndexOf('jello') // returns -1 + 'hello mellow'.lastIndexOf('ello', 6) // returns 1 + 'hello mellow'.lastIndexOf('ello', -1) // error + +### LowerAscii + +Returns a new string where all ASCII characters are lower-cased. + +This function does not perform Unicode case-mapping for characters outside the +ASCII range. + + .lowerAscii() -> + +Examples: + + 'TacoCat'.lowerAscii() // returns 'tacocat' + 'TacoCÆt Xii'.lowerAscii() // returns 'tacocÆt xii' + +### Quote + +Takes the given string and makes it safe to print (without any formatting due +to escape sequences). +If any invalid UTF-8 characters are encountered, they are replaced with \uFFFD. + + strings.quote() + +Examples: + + strings.quote('single-quote with "double quote"') // returns '"single-quote with \"double quote\""' + strings.quote("two escape sequences \a\n") // returns '"two escape sequences \\a\\n"' + +### Replace + +Returns a new string based on the target, which replaces the occurrences of a +search string with a replacement string if present. The function accepts an +optional limit on the number of substring replacements to be made. + +When the replacement limit is 0, the result is the original string. When the +limit is a negative number, the function behaves the same as replace all. + + .replace(, ) -> + .replace(, , ) -> + +Examples: + + 'hello hello'.replace('he', 'we') // returns 'wello wello' + 'hello hello'.replace('he', 'we', -1) // returns 'wello wello' + 'hello hello'.replace('he', 'we', 1) // returns 'wello hello' + 'hello hello'.replace('he', 'we', 0) // returns 'hello hello' + +### Reverse + +Returns a new string whose characters are the same as the target string, only +formatted in reverse order. +This function relies on converting strings to Unicode code point arrays in +order to reverse. + + .reverse() -> + +Examples: + + 'gums'.reverse() // returns 'smug' + 'John Smith'.reverse() // returns 'htimS nhoJ' + +### Split + +Returns a list of strings split from the input by the given separator. The +function accepts an optional argument specifying a limit on the number of +substrings produced by the split. + +When the split limit is 0, the result is an empty list. When the limit is 1, +the result is the target string to split. When the limit is a negative +number, the function behaves the same as split all. + + .split() -> > + .split(, ) -> > + +Examples: + + 'hello hello hello'.split(' ') // returns ['hello', 'hello', 'hello'] + 'hello hello hello'.split(' ', 0) // returns [] + 'hello hello hello'.split(' ', 1) // returns ['hello hello hello'] + 'hello hello hello'.split(' ', 2) // returns ['hello', 'hello hello'] + 'hello hello hello'.split(' ', -1) // returns ['hello', 'hello', 'hello'] + +### Substring + +Returns the substring given a numeric range corresponding to character +positions. Optionally may omit the trailing range for a substring from a given +character position until the end of a string. + +Character offsets are 0-based with an inclusive start range and exclusive end +range. It is an error to specify an end range that is lower than the start +range, or for either the start or end index to be negative or exceed the string +length. + + .substring() -> + .substring(, ) -> + +Examples: + + 'tacocat'.substring(4) // returns 'cat' + 'tacocat'.substring(0, 4) // returns 'taco' + 'tacocat'.substring(-1) // error + 'tacocat'.substring(2, 1) // error + +### Trim + +Returns a new string which removes the leading and trailing whitespace in the +target string. The trim function uses the Unicode definition of whitespace +which does not include the zero-width spaces. See: +https://en.wikipedia.org/wiki/Whitespace_character#Unicode + + .trim() -> + +Examples: + + ' \ttrim\n '.trim() // returns 'trim' + +### UpperAscii + +Returns a new string where all ASCII characters are upper-cased. + +This function does not perform Unicode case-mapping for characters outside the +ASCII range. + + .upperAscii() -> + +Examples: + + 'TacoCat'.upperAscii() // returns 'TACOCAT' + 'TacoCÆt Xii'.upperAscii() // returns 'TACOCÆT XII' + +## Encoders + +Encoding utilities for marshalling data into standardized representations. + +### Base64.Decode + +Decodes base64-encoded string to bytes. + +This function will return an error if the string input is not +base64-encoded. + + base64.decode() -> + +Examples: + + base64.decode('aGVsbG8=') // return b'hello' + base64.decode('aGVsbG8') // return b'hello'. Note that the padding + // character can be omitted. + base64.decode('z!') // error + +### Base64.Encode + +Encodes bytes to a base64-encoded string. Note that the string is encoded in +ISO_8859_1. + + base64.encode() -> + +Example: + + base64.encode(b'hello') // return 'aGVsbG8=' + +## Sets + +Sets provides set relationship tests. + +There is no set type within CEL, and while one may be introduced in the future, +there are cases where a `list` type is known to behave like a set. For such +cases, this library provides some basic functionality for determining set +containment, equivalence, and intersection. + +### Sets.Contains + +Returns whether the first list argument contains all elements in the second list +argument. The list may contain elements of any type and standard CEL equality is +used to determine whether a value exists in both lists. If the second list is +empty, the result will always return true. + +``` +sets.contains(list(T), list(T)) -> bool +``` + +Examples: + +``` +sets.contains([], []) // true +sets.contains([], [1]) // false +sets.contains([1, 2, 3, 4], [2, 3]) // true +sets.contains([1, 2.0, 3u], [1.0, 2u, 3]) // true +``` + +### Sets.Equivalent + +Returns whether the first and second list are set equivalent. Lists are set +equivalent if for every item in the first list, there is an element in the +second which is equal. The lists may not be of the same size as they do not +guarantee the elements within them are unique, so size does not factor into the +computation. + +``` +sets.equivalent(list(T), list(T)) -> bool +``` + +Examples: + +``` +sets.equivalent([], []) // true +sets.equivalent([1], [1, 1]) // true +sets.equivalent([1], [1u, 1.0]) // true +sets.equivalent([1, 2, 3], [3u, 2.0, 1]) // true +``` + +### Sets.Intersects + +Returns whether the first list has at least one element whose value is equal to +an element in the second list. If either list is empty, the result will be +false. + +``` +sets.intersects(list(T), list(T)) -> bool +``` + +Examples: + +``` +sets.intersects([1], []) // false +sets.intersects([1], [1, 2]) // true +sets.intersects([[1], [2, 3]], [[1, 2], [2, 3.0]]) // true +``` + +## Lists + +Extended functions for list manipulation. As a general note, all indices are +zero-based. + +### Slice + +Returns a new sub-list using the indexes provided. The `from` index is +inclusive, the `to` index is exclusive. + + .slice(, ) -> + +Examples: + + [1,2,3,4].slice(1, 3) // return [2, 3] + [1,2,3,4].slice(2, 4) // return [3, 4] + +### Flatten + +Introduced at version: 1 + +Flattens a list by one level, or to the specified level. Providing a negative level will error. + +Examples: + +``` +// Single-level flatten: + +[].flatten() // [] +[1,[2,3],[4]].flatten() // [1, 2, 3, 4] +[1,[2,[3,4]]].flatten() // [1, 2, [3, 4]] +[1,2,[],[],[3,4]].flatten() // [1, 2, 3, 4] + +// Recursive flatten +[1,[2,[3,[4]]]].flatten(2) // return [1, 2, 3, [4]] +[1,[2,[3,[4]]]].flatten(3) // return [1, 2, 3, 4] + +// Error +[1,[2,[3,[4]]]].flatten(-1) +``` + +Note that due to the current limitations of type-checker, a compilation error +will occur if an already flat list is populated to the argument-less flatten +function. + +For time being, you must explicitly provide 1 as the depth level, or wrap the +list in dyn if you anticipate having to deal with a flat list: + +``` +[1,2,3].flatten() // error + +// But the following will work: +[1,2,3].flatten(1) // [1,2,3] +dyn([1,2,3]).flatten() // [1,2,3] +``` + +This will be addressed once we add the appropriate capabilities in the +type-checker to handle type-reductions, or union types. + +### Range + +Introduced at version: 2 + +Given integer size n returns a list of integers from 0 to n-1. If size <= 0 +then return empty list. + +``` +lists.range(int) -> list(int) +``` + +Examples: + +``` +lists.range(5) -> [0, 1, 2, 3, 4] +lists.range(0) -> [] +``` + +### Distinct + +Introduced at version: 2 + +Returns the distinct elements of a list. + + .distinct() -> + +Examples: + + [1, 2, 2, 3, 3, 3].distinct() // return [1, 2, 3] + ["b", "b", "c", "a", "c"].distinct() // return ["b", "c", "a"] + [1, "b", 2, "b"].distinct() // return [1, "b", 2] + [1, 1.0, 2, 2u].distinct() // return [1, 2] + +### Reverse + +Introduced in version 2 + +Returns the elements of a list in reverse order. + + .reverse() -> + +Examples: + + [5, 3, 1, 2].reverse() // return [2, 1, 3, 5] + +### Sort + +Introduced in version 2 + +Sorts a list with comparable elements. If the element type is not comparable +or the element types are not the same, the function will produce an error. + + .sort() -> + // T in {int, uint, double, bool, duration, timestamp, string, bytes} + +Examples: + + [3, 2, 1].sort() // return [1, 2, 3] + ["b", "c", "a"].sort() // return ["a", "b", "c"] + [1, "b"].sort() // error + [[1, 2, 3]].sort() // error + +### SortBy + +Introduced in version 2 + +Sorts a list by a key value, i.e., the order is determined by the result of +an expression applied to each element of the list. + + .sortBy(, ) -> + keyExpr returns a value in {int, uint, double, bool, duration, timestamp, string, bytes} + +Examples: + + [ + Player { name: "foo", score: 0 }, + Player { name: "bar", score: -10 }, + Player { name: "baz", score: 1000 }, + ].sortBy(e, e.score).map(e, e.name) + == ["bar", "foo", "baz"] + +### Last + +Introduced in the 'optional' extension version 2 + +Returns an optional with the last value from the list or `optional.None` if the +list is empty. + + .last() -> + +Examples: + + [1, 2, 3].last().value() == 3 + [].last().orValue('test') == 'test' + +This is syntactic sugar for list[list.size()-1]. + +### First + +Introduced in the 'optional' extension version 2 + +Returns an optional with the first value from the list or `optional.None` if the +list is empty. + + .first() -> + +Examples: + + [1, 2, 3].first().value() == 1 + [].first().orValue('test') == 'test' + +## Regex + +Regex introduces support for regular expressions in CEL. + +This library provides functions for capturing groups, replacing strings using +regex patterns, Regex configures namespaced regex helper functions. Note, all +functions use the 'regex' namespace. If you are currently using a variable named +'regex', the macro will likely work just as intended; however, there is some +chance for collision. + +### Replace + +The `regex.replace` function replaces all non-overlapping substring of a regex +pattern in the target string with a replacement string. Optionally, you can +limit the number of replacements by providing a count argument. When the count +is a negative number, the function acts as replace all. Only numeric (\N) +capture group references are supported in the replacement string, with +validation for correctness. Backslashed-escaped digits (\1 to \9) within the +replacement argument can be used to insert text matching the corresponding +parenthesized group in the regexp pattern. An error will be thrown for invalid +regex or replace string. + +``` +regex.replace(target: string, pattern: string, replacement: string) -> string +regex.replace(target: string, pattern: string, replacement: string, count: int) -> string +``` + +Examples: + +``` +regex.replace('hello world hello', 'hello', 'hi') == 'hi world hi' +regex.replace('banana', 'a', 'x', 0) == 'banana' +regex.replace('banana', 'a', 'x', 1) == 'bxnana' +regex.replace('banana', 'a', 'x', 2) == 'bxnxna' +regex.replace('banana', 'a', 'x', -12) == 'bxnxnx' +regex.replace('foo bar', '(fo)o (ba)r', '\\2 \\1') == 'ba fo' + +regex.replace('test', '(.)', '$2') \\ Runtime Error invalid replace string +regex.replace('foo bar', '(', '$2 $1') \\ Runtime Error invalid regex string +regex.replace('id=123', 'id=(?P\\\\d+)', 'value: \\values') \\ Runtime Error invalid replace string + +``` + +### Extract + +The `regex.extract` function returns the first match of a regex pattern in a +string. If no match is found, it returns an optional none value. An error will +be thrown for invalid regex or for multiple capture groups. + +``` +regex.extract(target: string, pattern: string) -> optional +``` + +Examples: + +``` +regex.extract('hello world', 'hello(.*)') == optional.of(' world') +regex.extract('item-A, item-B', 'item-(\\w+)') == optional.of('A') +regex.extract('HELLO', 'hello') == optional.empty() + +regex.extract('testuser@testdomain', '(.*)@([^.]*)')) \\ Runtime Error multiple extract group +``` + +### Extract All + +The `regex.extractAll` function returns a list of all matches of a regex +pattern in a target string. If no matches are found, it returns an empty list. +An error will be thrown for invalid regex or for multiple capture groups. + +``` +regex.extractAll(target: string, pattern: string) -> list +``` + +Examples: + +``` +regex.extractAll('id:123, id:456', 'id:\\d+') == ['id:123', 'id:456'] +regex.extractAll('id:123, id:456', 'assa') == [] + +regex.extractAll('testuser@testdomain', '(.*)@([^.]*)') \\ Runtime Error multiple capture group +``` + +## Comprehensions + +TwoVarComprehensions introduces support for two-variable comprehensions. + +The two-variable form of comprehensions looks similar to the one-variable +counterparts. Where possible, the same macro names were used and additional +macro signatures added. The notable distinction for two-variable comprehensions +is the introduction of `transformList`, `transformMap`, and `transformMapEntry` +support for list and map types rather than the more traditional `map` and +`filter` macros. + +### All + +Comprehension which tests whether all elements in the list or map satisfy a +given predicate. The `all` macro evaluates in a manner consistent with logical +AND and will short-circuit when encountering a `false` value. + + .all(indexVar, valueVar, ) -> bool + .all(keyVar, valueVar, ) -> bool + +Examples: + + [1, 2, 3].all(i, j, i < j) // returns true + {'hello': 'world', 'taco': 'taco'}.all(k, v, k != v) // returns false + + // Combines two-variable comprehension with single variable + {'h': ['hello', 'hi'], 'j': ['joke', 'jog']} + .all(k, vals, vals.all(v, v.startsWith(k))) // returns true + +### Exists + +Comprehension which tests whether any element in a list or map exists which +satisfies a given predicate. The `exists` macro evaluates in a manner consistent +with logical OR and will short-circuit when encountering a `true` value. + + .exists(indexVar, valueVar, ) -> bool + .exists(keyVar, valueVar, ) -> bool + +Examples: + + {'greeting': 'hello', 'farewell': 'goodbye'} + .exists(k, v, k.startsWith('good') || v.endsWith('bye')) // returns true + [1, 2, 4, 8, 16].exists(i, v, v == 1024 && i == 10) // returns false + +### Exists_One + +Comprehension which tests whether exactly one element in a list or map exists +which satisfies a given predicate expression. The `exists_one` macro +comprehension does not short-circuit in keeping with the one-variable semantics. + + .existsOne(indexVar, valueVar, ) + .existsOne(keyVar, valueVar, ) + +Examples: + + [1, 2, 1, 3, 1, 4].existsOne(i, v, i == 1 || v == 1) // returns false + [1, 1, 2, 2, 3, 3].existsOne(i, v, i == 2 && v == 2) // returns true + {'i': 0, 'j': 1, 'k': 2}.existsOne(i, v, i == 'l' || v == 1) // returns true + +### TransformList + +Comprehension which converts a map or a list into a list value. The output +expression of the comprehension determines the contents of the output list. +Elements in the list may optionally be filtered according to a predicate +expression, where elements that satisfy the predicate are transformed. + + .transformList(indexVar, valueVar, ) + .transformList(indexVar, valueVar, , ) + .transformList(keyVar, valueVar, ) + .transformList(keyVar, valueVar, , ) + +Examples: + + [1, 2, 3].transformList(indexVar, valueVar, + (indexVar * valueVar) + valueVar) // returns [1, 4, 9] + [1, 2, 3].transformList(indexVar, valueVar, indexVar % 2 == 0 + (indexVar * valueVar) + valueVar) // returns [1, 9] + {'greeting': 'hello', 'farewell': 'goodbye'} + .transformList(k, _, k) // returns ['greeting', 'farewell'] + {'greeting': 'hello', 'farewell': 'goodbye'} + .transformList(_, v, v) // returns ['hello', 'goodbye'] + +### TransformMap + +Comprehension which converts a map or a list into a map value. The output +expression of the comprehension determines the value of the output map entry; +however, the key remains fixed. Elements in the map may optionally be filtered +according to a predicate expression, where elements that satisfy the predicate +are transformed. + + .transformMap(indexVar, valueVar, ) + .transformMap(indexVar, valueVar, , ) + .transformMap(keyVar, valueVar, ) + .transformMap(keyVar, valueVar, , ) + +Examples: + + [1, 2, 3].transformMap(indexVar, valueVar, + (indexVar * valueVar) + valueVar) // returns {0: 1, 1: 4, 2: 9} + [1, 2, 3].transformMap(indexVar, valueVar, indexVar % 2 == 0 + (indexVar * valueVar) + valueVar) // returns {0: 1, 2: 9} + {'greeting': 'hi'}.transformMap(k, v, v + '!') // returns {'greeting': 'hi!'} + +### TransformMapEntry + +Comprehension which converts a map or a list into a map value; however, this +transform expects the entry expression be a map literal. If the transform +produces an entry which duplicates a key in the target map, the comprehension +will error. Note, that key equality is determined using CEL equality which +asserts that numeric values which are equal, even if they don't have the same +type will cause a key collision. + +Elements in the map may optionally be filtered according to a predicate +expression, where elements that satisfy the predicate are transformed. + + .transformMapEntry(indexVar, valueVar, ) + .transformMapEntry(indexVar, valueVar, , ) + .transformMapEntry(keyVar, valueVar, ) + .transformMapEntry(keyVar, valueVar, , ) + +Examples: + + {'greeting': 'hello'}.transformMapEntry(keyVar, valueVar, + {valueVar: keyVar}) // returns {'hello': 'greeting'} + // reverse lookup, require all values in list be unique + [1, 2, 3].transformMapEntry(indexVar, valueVar, + {valueVar: indexVar}) // returns {1:0, 2:1, 3:2} + + {'greeting': 'aloha', 'farewell': 'aloha'} + .transformMapEntry(k, v, {v: k}) // error, duplicate key + +## Native Types + +The `nativeTypes` extension allows registering native Java types (POJOs) to be +used in CEL expressions. + +All POJO classes are exposed to CEL using their fully qualified canonical name. +For example, if you have a class `com.example.Account`: + +```java +package com.example; +public class Account { + public int id; +} +``` + +The type `com.example.Account` would be exported to CEL using its full name. If +you set the container to `com.example` on the compiler, you can use it simply +as `Account`: `Account{id: 1234}` would create a new `Account` instance with the +`id` field populated. + +Properties are discovered by reflectively scanning public fields and public +getter methods of public classes. For field selection (reading) and object +creation (writing), resolution happens in the following order of precedence: + +1. Standard JavaBeans getter (e.g., `getFoo()`) or setter (e.g., `setFoo(...)`) +2. Boolean getter (e.g., `isFoo()`) for boolean properties +3. Prefix-less getter (e.g., `foo()`) matching a declared field name +4. Public field directly (e.g., `public String foo`) + +### Type Mapping + +The type-mapping between Java and CEL is as follows: + +| Java type | CEL type | +| :--- | :--- | +| `boolean`, `Boolean` | `bool` | +| `byte[]` | `bytes` | +| `float`, `Float`, `double`, `Double` | `double` | +| `int`, `Integer`, `long`, `Long` | `int` | +| `com.google.common.primitives.UnsignedLong` | `uint` | +| `String` | `string` | +| `java.time.Duration` | `duration` | +| `java.time.Instant` | `timestamp` | +| `java.util.List`, `T[]` (except `byte[]`) | `list` | +| `java.util.Map` | `map` | +| `java.util.Optional` | `optional_type` | + +### Notes + +* This is only supported for the planner runtime (e.g., `CelRuntimeFactory.plannerRuntimeBuilder()`). +* Native Java arrays are supported. `byte[]` maps to `bytes`, while other arrays map to `list`. +* Java `enum` properties are not currently supported and will be safely ignored during scanning. +* If there is a name collision with a Protobuf type, the protobuf type will take precedence. +* Instantiating new struct values (e.g., `Account{id: 1234}`) requires the class to have a no-argument constructor (public, protected, package-private, or private). +* Final fields are supported only in a **read-only** capacity; they cannot be populated when instantiating new struct values. diff --git a/extensions/src/main/java/dev/cel/extensions/SetsExtensionsRuntimeImpl.java b/extensions/src/main/java/dev/cel/extensions/SetsExtensionsRuntimeImpl.java new file mode 100644 index 000000000..a02fdba8a --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/SetsExtensionsRuntimeImpl.java @@ -0,0 +1,147 @@ +// Copyright 2025 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.extensions; + +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelLiteRuntimeBuilder; +import dev.cel.runtime.CelLiteRuntimeLibrary; +import dev.cel.runtime.RuntimeEquality; +import java.util.Collection; +import java.util.Iterator; +import java.util.Set; + +@Immutable +final class SetsExtensionsRuntimeImpl implements CelLiteRuntimeLibrary { + private final RuntimeEquality runtimeEquality; + + private final ImmutableSet functions; + + SetsExtensionsRuntimeImpl(RuntimeEquality runtimeEquality, Set functions) { + this.runtimeEquality = runtimeEquality; + this.functions = ImmutableSet.copyOf(functions); + } + + @Override + public void setRuntimeOptions(CelLiteRuntimeBuilder runtimeBuilder) { + runtimeBuilder.addFunctionBindings(newFunctionBindings()); + } + + ImmutableSet newFunctionBindings() { + ImmutableSet.Builder bindingBuilder = ImmutableSet.builder(); + for (SetsFunction function : functions) { + switch (function) { + case CONTAINS: + bindingBuilder.addAll( + CelFunctionBinding.fromOverloads( + function.getFunction(), + CelFunctionBinding.from( + "list_sets_contains_list", + Collection.class, + Collection.class, + this::containsAll))); + break; + case EQUIVALENT: + bindingBuilder.addAll( + CelFunctionBinding.fromOverloads( + function.getFunction(), + CelFunctionBinding.from( + "list_sets_equivalent_list", + Collection.class, + Collection.class, + (listA, listB) -> containsAll(listA, listB) && containsAll(listB, listA)))); + break; + case INTERSECTS: + bindingBuilder.addAll( + CelFunctionBinding.fromOverloads( + function.getFunction(), + CelFunctionBinding.from( + "list_sets_intersects_list", + Collection.class, + Collection.class, + this::setIntersects))); + break; + } + } + + return bindingBuilder.build(); + } + + /** + * This implementation iterates over the specified collection, checking each element returned by + * the iterator in turn to see if it's contained in this collection. If all elements are so + * contained true is returned, otherwise false. + * + *

This is picked verbatim as implemented in the Java standard library + * Collections.containsAll() method. + * + * @see #contains(Object, Collection) + */ + private boolean containsAll(Collection list, Collection subList) { + for (Object e : subList) { + if (!contains(e, list)) { + return false; + } + } + return true; + } + + /** + * This implementation iterates over the elements in the collection, checking each element in turn + * for equality with the specified element. + * + *

This is picked verbatim as implemented in the Java standard library Collections.contains() + * method. + * + *

Source: OpenJDK + * AbstractCollection + */ + private boolean contains(Object o, Collection list) { + Iterator it = list.iterator(); + if (o == null) { + while (it.hasNext()) { + if (it.next() == null) { + return true; + } + } + } else { + while (it.hasNext()) { + Object item = it.next(); + if (objectsEquals(item, o)) { + return true; + } + } + } + return false; + } + + private boolean objectsEquals(Object o1, Object o2) { + return runtimeEquality.objectEquals(o1, o2); + } + + private boolean setIntersects(Collection listA, Collection listB) { + if (listA.isEmpty() || listB.isEmpty()) { + return false; + } + for (Object element : listB) { + if (contains(element, listA)) { + return true; + } + } + return false; + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/SetsFunction.java b/extensions/src/main/java/dev/cel/extensions/SetsFunction.java new file mode 100644 index 000000000..ad67f861d --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/SetsFunction.java @@ -0,0 +1,32 @@ +// Copyright 2025 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.extensions; + +/** Denotes the extension function used in {@code CelSetsExtension}. */ +public enum SetsFunction { + CONTAINS("sets.contains"), + EQUIVALENT("sets.equivalent"), + INTERSECTS("sets.intersects"); + + private final String functionName; + + String getFunction() { + return functionName; + } + + SetsFunction(String functionName) { + this.functionName = functionName; + } +} diff --git a/extensions/src/test/java/dev/cel/extensions/BUILD.bazel b/extensions/src/test/java/dev/cel/extensions/BUILD.bazel new file mode 100644 index 000000000..9fda186cf --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/BUILD.bazel @@ -0,0 +1,67 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//bundle:cel", + "//common:cel_ast", + "//common:cel_exception", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common/exceptions:attribute_not_found", + "//common/exceptions:divide_by_zero", + "//common/exceptions:index_out_of_bounds", + "//common/exceptions:invalid_argument", + "//common/types", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_byte_string", + "//common/values:cel_value_provider", + "//compiler", + "//compiler:compiler_builder", + "//extensions", + "//extensions:extension_library", + "//extensions:lite_extensions", + "//extensions:math", + "//extensions:native", + "//extensions:optional_library", + "//extensions:sets", + "//extensions:sets_function", + "//extensions:strings", + "//parser:macro", + "//parser:unparser", + "//runtime", + "//runtime:function_binding", + "//runtime:interpreter_util", + "//runtime:lite_runtime", + "//runtime:lite_runtime_factory", + "//runtime:partial_vars", + "//runtime:unknown_attributes", + "//testing:cel_runtime_flavor", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/test:simple_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/extensions/src/test/java/dev/cel/extensions/CelBindingsExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelBindingsExtensionsTest.java new file mode 100644 index 000000000..00fcad473 --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelBindingsExtensionsTest.java @@ -0,0 +1,322 @@ +// Copyright 2023 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelValidationException; +import dev.cel.common.exceptions.CelDivideByZeroException; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelBindingsExtensionsTest extends CelExtensionTestBase { + + @Override + protected Cel newCelEnv() { + return runtimeFlavor + .builder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addCompilerLibraries(CelOptionalLibrary.INSTANCE, CelExtensions.bindings()) + .addRuntimeLibraries(CelOptionalLibrary.INSTANCE) + .build(); + } + + @Test + public void library() { + CelExtensionLibrary library = + CelExtensions.getExtensionLibrary("bindings", CelOptions.DEFAULT); + assertThat(library.name()).isEqualTo("bindings"); + assertThat(library.latest().version()).isEqualTo(0); + assertThat(library.version(0).functions().stream().map(CelFunctionDecl::name)) + .containsExactly("cel.@block"); + assertThat(library.version(0).macros().stream().map(CelMacro::getFunction)) + .containsExactly("bind"); + } + + private enum BindingTestCase { + BOOL_LITERAL("cel.bind(t, true, t)"), + STRING_CONCAT("cel.bind(msg, \"hello\", msg + msg + msg) == \"hellohellohello\""), + NESTED_BINDS("cel.bind(t1, true, cel.bind(t2, true, t1 && t2))"), + NESTED_BINDS_SPECIFIER_ONLY( + "cel.bind(x, cel.bind(x, \"a\", x + x), x + \":\" + x) == \"aa:aa\""), + NESTED_BINDS_SPECIFIER_AND_VALUE( + "cel.bind(x, cel.bind(x, \"a\", x + x), cel.bind(y, x + x, y + \":\" + y)) ==" + + " \"aaaa:aaaa\""), + BIND_WITH_EXISTS_TRUE( + "cel.bind(valid_elems, [1, 2, 3], [3, 4, 5].exists(e, e in valid_elems))"), + BIND_WITH_EXISTS_FALSE("cel.bind(valid_elems, [1, 2, 3], ![4, 5].exists(e, e in valid_elems))"), + BIND_WITH_MAP("[1,2,3].map(x, cel.bind(y, x + x, [y, y])) == [[2, 2], [4, 4], [6, 6]]"), + BIND_OPTIONAL_LIST("cel.bind(r0, optional.none(), [?r0, ?r0]) == []"); + + private final String source; + + BindingTestCase(String source) { + this.source = source; + } + } + + @Test + public void binding_success(@TestParameter BindingTestCase testCase) throws Exception { + boolean evaluatedResult = (boolean) eval(testCase.source); + + assertThat(evaluatedResult).isTrue(); + } + + @Test + @TestParameters("{expr: 'false.bind(false, false, false)'}") + public void binding_nonCelNamespace_success(String expr) throws Exception { + Cel customCel = + runtimeFlavor + .builder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .addCompilerLibraries(CelExtensions.bindings()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "bind", + CelOverloadDecl.newMemberOverload( + "bool_bind_bool_bool_bool", + SimpleType.BOOL, + SimpleType.BOOL, + SimpleType.BOOL, + SimpleType.BOOL, + SimpleType.BOOL))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "bind", + CelFunctionBinding.from( + "bool_bind_bool_bool_bool", + Arrays.asList(Boolean.class, Boolean.class, Boolean.class, Boolean.class), + (args) -> true))) + .build(); + + boolean result = (boolean) eval(customCel, expr); + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expr: 'cel.bind(bad.name, true, bad.name)'}") + public void binding_throwsCompilationException(String expr) throws Exception { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("cel.bind() variable name must be a simple identifier"); + } + + @Test + @SuppressWarnings("Immutable") // Test only + public void lazyBinding_bindingVarNeverReferenced() throws Exception { + + AtomicInteger invocation = new AtomicInteger(); + Cel customCel = + runtimeFlavor + .builder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .setStandardMacros(CelStandardMacro.HAS) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .addCompilerLibraries(CelExtensions.bindings()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "get_true", + CelOverloadDecl.newGlobalOverload("get_true_overload", SimpleType.BOOL))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "get_true", + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + }))) + .build(); + boolean result = + (boolean) + eval( + customCel, + "cel.bind(t, get_true(), has(msg.single_int64) ? t : false)", + ImmutableMap.of("msg", TestAllTypes.getDefaultInstance())); + + assertThat(result).isFalse(); + assertThat(invocation.get()).isEqualTo(0); + } + + @Test + public void lazyBinding_throwsEvaluationException() throws Exception { + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval(cel, "cel.bind(t, 1 / 0, t)")); + + assertThat(e).hasMessageThat().contains("/ by zero"); + assertThat(e).hasCauseThat().isInstanceOf(CelDivideByZeroException.class); + } + + @Test + @SuppressWarnings("Immutable") // Test only + public void lazyBinding_accuInitEvaluatedOnce() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + Cel customCel = + runtimeFlavor + .builder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .addCompilerLibraries(CelExtensions.bindings()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "get_true", + CelOverloadDecl.newGlobalOverload("get_true_overload", SimpleType.BOOL))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "get_true", + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + }))) + .build(); + boolean result = (boolean) eval(customCel, "cel.bind(t, get_true(), t && t && t && t)"); + + assertThat(result).isTrue(); + assertThat(invocation.get()).isEqualTo(1); + } + + @Test + @SuppressWarnings("Immutable") // Test only + public void lazyBinding_withNestedBinds() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + Cel customCel = + runtimeFlavor + .builder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .addCompilerLibraries(CelExtensions.bindings()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "get_true", + CelOverloadDecl.newGlobalOverload("get_true_overload", SimpleType.BOOL))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "get_true", + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + }))) + .build(); + boolean result = + (boolean) + eval( + customCel, + "cel.bind(t1, get_true(), cel.bind(t2, get_true(), t1 && t2 && t1 && t2))"); + + assertThat(result).isTrue(); + assertThat(invocation.get()).isEqualTo(2); + } + + @Test + @SuppressWarnings({"Immutable", "unchecked"}) // Test only + public void lazyBinding_boundAttributeInComprehension() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + Cel customCel = + runtimeFlavor + .builder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .setStandardMacros(CelStandardMacro.MAP) + .addCompilerLibraries(CelExtensions.bindings()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "get_true", + CelOverloadDecl.newGlobalOverload("get_true_overload", SimpleType.BOOL))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "get_true", + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + }))) + .build(); + + List result = + (List) eval(customCel, "cel.bind(x, get_true(), [1,2,3].map(y, y < 0 || x))"); + + assertThat(result).containsExactly(true, true, true); + assertThat(invocation.get()).isEqualTo(1); + } + + @Test + @SuppressWarnings({"Immutable"}) // Test only + public void lazyBinding_boundAttributeInNestedComprehension() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + Cel customCel = + runtimeFlavor + .builder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .setStandardMacros(CelStandardMacro.EXISTS) + .addCompilerLibraries(CelExtensions.bindings()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "get_true", + CelOverloadDecl.newGlobalOverload("get_true_overload", SimpleType.BOOL))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "get_true", + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + }))) + .build(); + + boolean result = + (boolean) + eval( + customCel, + "cel.bind(x, get_true(), [1,2,3].exists(unused, x && " + + "['a','b','c'].exists(unused_2, x)))"); + + assertThat(result).isTrue(); + assertThat(invocation.get()).isEqualTo(1); + } + + +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelComprehensionsExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelComprehensionsExtensionsTest.java new file mode 100644 index 000000000..42dc3e07d --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelComprehensionsExtensionsTest.java @@ -0,0 +1,369 @@ +// Copyright 2025 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth.assertWithMessage; +import static org.junit.Assert.assertThrows; + +import com.google.common.base.Throwables; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.exceptions.CelAttributeNotFoundException; +import dev.cel.common.exceptions.CelDivideByZeroException; +import dev.cel.common.exceptions.CelIndexOutOfBoundsException; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeParamType; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelStandardMacro; +import dev.cel.parser.CelUnparser; +import dev.cel.parser.CelUnparserFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.testing.CelRuntimeFlavor; +import org.junit.Assume; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** Test for {@link CelExtensions#comprehensions()} */ +@RunWith(TestParameterInjector.class) +public class CelComprehensionsExtensionsTest extends CelExtensionTestBase { + + private static final CelOptions CEL_OPTIONS = + CelOptions.current() + .enableHeterogeneousNumericComparisons(true) + // Enable macro call population for unparsing + .populateMacroCalls(true) + .build(); + + @Override + protected Cel newCelEnv() { + return runtimeFlavor + .builder() + .setOptions(CEL_OPTIONS) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addCompilerLibraries(CelExtensions.comprehensions()) + .addCompilerLibraries(CelExtensions.lists()) + .addCompilerLibraries(CelExtensions.strings()) + .addCompilerLibraries(CelOptionalLibrary.INSTANCE, CelExtensions.bindings()) + .addRuntimeLibraries(CelOptionalLibrary.INSTANCE) + .addRuntimeLibraries(CelExtensions.lists()) + .addRuntimeLibraries(CelExtensions.strings()) + .addRuntimeLibraries(CelExtensions.comprehensions()) + .build(); + } + + private static final CelUnparser UNPARSER = CelUnparserFactory.newUnparser(); + + @Test + public void library() { + CelExtensionLibrary library = + CelExtensions.getExtensionLibrary("comprehensions", CelOptions.DEFAULT); + assertThat(library.name()).isEqualTo("comprehensions"); + assertThat(library.latest().version()).isEqualTo(0); + assertThat(library.version(0).functions().stream().map(CelFunctionDecl::name)).isEmpty(); + assertThat(library.version(0).macros().stream().map(CelMacro::getFunction)) + .containsAtLeast( + "all", "exists", "exists_one", "transformList", "transformMap", "transformMapEntry"); + } + + @Test + public void allMacro_twoVarComprehension_success( + @TestParameter({ + // list.all() + "[1, 2, 3, 4].all(i, v, i < 5 && v > 0)", + "[1, 2, 3, 4].all(i, v, i < v)", + "[1, 2, 3, 4].all(i, v, i > v) == false", + "cel.bind(listA, [1, 2, 3, 4], cel.bind(listB, [1, 2, 3, 4, 5], listA.all(i, v," + + " listB[?i].hasValue() && listB[i] == v)))", + "cel.bind(listA, [1, 2, 3, 4, 5, 6], cel.bind(listB, [1, 2, 3, 4, 5], listA.all(i, v," + + " listB[?i].hasValue() && listB[i] == v))) == false", + // map.all() + "{'hello': 'world', 'hello!': 'world'}.all(k, v, k.startsWith('hello') && v ==" + + " 'world')", + "{'hello': 'world', 'hello!': 'worlds'}.all(k, v, k.startsWith('hello') &&" + + " v.endsWith('world')) == false", + "{'a': 1, 'b': 2}.all(k, v, k.startsWith('a') && v == 1) == false", + }) + String expr) + throws Exception { + assertThat(eval(expr)).isEqualTo(true); + } + + @Test + public void existsMacro_twoVarComprehension_success( + @TestParameter({ + // list.exists() + "[1, 2, 3, 4].exists(i, v, i > 2 && v < 5)", + "[10, 1, 30].exists(i, v, i == v)", + "[].exists(i, v, true) == false", + "cel.bind(l, ['hello', 'world', 'hello!', 'worlds'], l.exists(i, v," + + " v.startsWith('hello') && l[?(i+1)].optMap(next," + + " next.endsWith('world')).orValue(false)))", + // map.exists() + "{'hello': 'world', 'hello!': 'worlds'}.exists(k, v, k.startsWith('hello') &&" + + " v.endsWith('world'))", + "{}.exists(k, v, true) == false", + "{'a': 1, 'b': 2}.exists(k, v, v == 3) == false", + "{'a': 'b', 'c': 'c'}.exists(k, v, k == v)" + }) + String expr) + throws Exception { + assertThat(eval(expr)).isEqualTo(true); + } + + @Test + public void exists_oneMacro_twoVarComprehension_success( + @TestParameter({ + // list.exists_one() + "[0, 5, 6].exists_one(i, v, i == v)", + "[0, 1, 5].exists_one(i, v, i == v) == false", + "[10, 11, 12].exists_one(i, v, i == v) == false", + "cel.bind(l, ['hello', 'world', 'hello!', 'worlds'], l.exists_one(i, v," + + " v.startsWith('hello') && l[?(i+1)].optMap(next," + + " next.endsWith('world')).orValue(false)))", + "cel.bind(l, ['hello', 'goodbye', 'hello!', 'goodbye'], l.exists_one(i, v," + + " v.startsWith('hello') && l[?(i+1)].optMap(next, next ==" + + " 'goodbye').orValue(false))) == false", + // map.exists_one() + "{'hello': 'world', 'hello!': 'worlds'}.exists_one(k, v, k.startsWith('hello') &&" + + " v.endsWith('world'))", + "{'hello': 'world', 'hello!': 'wow, world'}.exists_one(k, v, k.startsWith('hello') &&" + + " v.endsWith('world')) == false", + "{'a': 1, 'b': 1}.exists_one(k, v, v == 2) == false" + }) + String expr) + throws Exception { + assertThat(eval(expr)).isEqualTo(true); + } + + @Test + public void transformListMacro_twoVarComprehension_success( + @TestParameter({ + // list.transformList() + "[1, 2, 3].transformList(i, v, (i * v) + v) == [1, 4, 9]", + "[1, 2, 3].transformList(i, v, i % 2 == 0, (i * v) + v) == [1, 9]", + "[1, 2, 3].transformList(i, v, i > 0 && v < 3, (i * v) + v) == [4]", + "[1, 2, 3].transformList(i, v, i % 2 == 0, (i * v) + v) == [1, 9]", + "[1, 2, 3].transformList(i, v, (i * v) + v) == [1, 4, 9]", + "[-1, -2, -3].transformList(i, v, [1, 2].transformList(i, v, i + v)) == [[1, 3], [1," + + " 3], [1, 3]]", + // map.transformList() + "{'greeting': 'hello', 'farewell': 'goodbye'}.transformList(k, _, k).sort() ==" + + " ['farewell', 'greeting']", + "{'greeting': 'hello', 'farewell': 'goodbye'}.transformList(_, v, v).sort() ==" + + " ['goodbye', 'hello']" + }) + String expr) + throws Exception { + assertThat(eval(expr)).isEqualTo(true); + } + + @Test + public void transformMapMacro_twoVarComprehension_success( + @TestParameter({ + // list.transformMap() + "['Hello', 'world'].transformMap(i, v, [v.lowerAscii()]) == {0: ['hello'], 1:" + + " ['world']}", + "['world', 'Hello'].transformMap(i, v, [v.lowerAscii()]).transformList(k, v," + + " v).flatten().sort() == ['hello', 'world']", + "[1, 2, 3].transformMap(indexVar, valueVar, (indexVar * valueVar) + valueVar) == {0:" + + " 1, 1: 4, 2: 9}", + "[1, 2, 3].transformMap(indexVar, valueVar, indexVar % 2 == 0, (indexVar * valueVar)" + + " + valueVar) == {0: 1, 2: 9}", + // map.transformMap() + "{'greeting': 'hello'}.transformMap(k, v, v + '!') == {'greeting': 'hello!'}", + "dyn({'greeting': 'hello'}).transformMap(k, v, v + '!') == {'greeting': 'hello!'}", + "{'hello': 'world', 'goodbye': 'cruel world'}.transformMap(k, v, v.startsWith('world')," + + " v + '!') == {'hello': 'world!'}", + "{}.transformMap(k, v, v + '!') == {}" + }) + String expr) + throws Exception { + assertThat(eval(expr)).isEqualTo(true); + } + + @Test + public void transformMapEntryMacro_twoVarComprehension_success( + @TestParameter({ + // list.transformMapEntry() + "'key1:value1 key2:value2 key3:value3'.split(' ').transformMapEntry(i, v," + + " cel.bind(entry, v.split(':'),entry.size() == 2 ? {entry[0]: entry[1]} : {})) ==" + + " {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}", + "'key1:value1:extra key2:value2 key3'.split(' ').transformMapEntry(i, v," + + " cel.bind(entry, v.split(':'), {?entry[0]: entry[?1]})) == {'key1': 'value1'," + + " 'key2': 'value2'}", + // map.transformMapEntry() + "{'hello': 'world', 'greetings': 'tacocat'}.transformMapEntry(k, v, {}) == {}", + "{'a': 1, 'b': 2}.transformMapEntry(k, v, {k: v}) == {'a': 1, 'b': 2}", + "{'a': 1, 'b': 2}.transformMapEntry(k, v, {k + '_new': v * 2}) == {'a_new': 2," + + " 'b_new': 4}", + "{'a': 1, 'b': 2, 'c': 3}.transformMapEntry(k, v, v % 2 == 1, {k: v * 10}) == {'a': 10," + + " 'c': 30}", + "{'a': 1, 'b': 2}.transformMapEntry(k, v, k == 'a', {k + '_filtered': v}) ==" + + " {'a_filtered': 1}", + }) + String expr) + throws Exception { + assertThat(eval(expr)).isEqualTo(true); + } + + @Test + public void comprehension_onTypeParam_success() throws Exception { + Assume.assumeFalse(isParseOnly); + Cel customCel = + runtimeFlavor + .builder() + .setOptions(CEL_OPTIONS) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addCompilerLibraries(CelExtensions.comprehensions()) + .addVar("items", TypeParamType.create("T")) + .build(); + + CelAbstractSyntaxTree ast = customCel.compile("items.all(i, v, v > 0)").getAst(); + + assertThat(ast.getResultType()).isEqualTo(SimpleType.BOOL); + } + + @Test + public void unparseAST_twoVarComprehension( + @TestParameter({ + "cel.bind(listA, [1, 2, 3, 4], cel.bind(listB, [1, 2, 3, 4, 5], listA.all(i, v," + + " listB[?i].hasValue() && listB[i] == v)))", + "[1, 2, 3, 4].exists(i, v, i > 2 && v < 5)", + "{\"a\": 1, \"b\": 1}.exists_one(k, v, v == 2) == false", + "[1, 2, 3].transformList(i, v, i > 0 && v < 3, i * v + v) == [4]", + "[1, 2, 2].transformList(i, v, i / 2 == 1)", + "{\"a\": \"b\", \"c\": \"d\"}.exists_one(k, v, k == \"b\" || v == \"b\")", + "{\"a\": \"b\", \"c\": \"d\"}.exists(k, v, k == \"b\" || v == \"b\")", + "[null, null, \"hello\", string].all(i, v, i == 0 || type(v) != int)" + }) + String expr) + throws Exception { + CelAbstractSyntaxTree ast = isParseOnly ? cel.parse(expr).getAst() : cel.compile(expr).getAst(); + String unparsed = UNPARSER.unparse(ast); + assertThat(unparsed).isEqualTo(expr); + } + + @Test + @TestParameters( + "{expr: '[].exists_one(i.j, k, i.j < k)', err: 'The argument must be a simple name'}") + @TestParameters( + "{expr: '[].exists_one(i, [k], i < [k])', err: 'The argument must be a simple name'}") + @TestParameters( + "{expr: '1.exists_one(j, j < 5)', err: 'cannot be range of a comprehension (must be list," + + " map, or dynamic)'}") + @TestParameters( + "{expr: '1.exists_one(j, k, j < k)', err: 'cannot be range of a comprehension (must be list," + + " map, or dynamic)'}") + @TestParameters( + "{expr: '[].transformList(__result__, i, __result__ < i)', err: 'The iteration variable" + + " __result__ overwrites accumulator variable'}") + @TestParameters( + "{expr: '[].exists(__result__, i, __result__ < i)', err: 'The iteration variable __result__" + + " overwrites accumulator variable'}") + @TestParameters( + "{expr: '[].exists(j, __result__, __result__ < j)', err: 'The iteration variable __result__" + + " overwrites accumulator variable'}") + @TestParameters( + "{expr: 'no_such_var.all(i, v, v > 0)', err: \"undeclared reference to 'no_such_var'\"}") + @TestParameters( + "{expr: '{}.transformMap(i.j, k, i.j + k)', err: 'argument must be a simple name'}") + @TestParameters( + "{expr: '{}.transformMap(i, k.j, i + k.j)', err: 'argument must be a simple name'}") + @TestParameters( + "{expr: '{}.transformMapEntry(j, i.k, {j: i.k})', err: 'argument must be a simple name'}") + @TestParameters( + "{expr: '{}.transformMapEntry(i.j, k, {k: i.j})', err: 'argument must be a simple name'}") + @TestParameters( + "{expr: '{}.transformMapEntry(j, k, \"bad filter\", {k: j})', err: 'no matching overload'}") + @TestParameters( + "{expr: '[1, 2].transformList(i, v, v % 2 == 0 ? [v] : v)', err: 'no matching overload'}") + @TestParameters( + "{expr: \"{'hello': 'world', 'greetings': 'tacocat'}.transformMapEntry(k, v, []) == {}\"," + + " err: 'no matching overload'}") + public void twoVarComprehension_compilerErrors(String expr, String err) throws Exception { + Assume.assumeFalse(isParseOnly); + CelValidationResult result = cel.compile(expr); + CelValidationException e = assertThrows(CelValidationException.class, () -> result.getAst()); + + assertThat(e).hasMessageThat().contains(err); + } + + @Test + @TestParameters( + "{expr: \"['a:1', 'b:2', 'a:3'].transformMapEntry(i, v, cel.bind(p, v.split(':'), {p[0]:" + + " p[1]})) == {'a': '3', 'b': '2'}\", err: \"insert failed: key 'a' already exists\"}") + @TestParameters( + "{expr: '[1, 1].transformMapEntry(i, v, {v: i})', err: \"insert failed: key '1' already" + + " exists\"}") + @TestParameters( + "{expr: \"{'a': 65, 'b': 65u}.transformMapEntry(i, v, {v: i})\", err: \"insert failed: key" + + " '65' already exists\"}") + @TestParameters( + "{expr: \"{'a': 2, 'b': 2.0}.transformMapEntry(i, v, {v: i})\", err: \"insert failed: key" + + " '2.0' already exists\"}") + public void twoVarComprehension_keyCollision_runtimeError(String expr, String err) + throws Exception { + // Planner does not allow decimals for map keys + Assume.assumeFalse(runtimeFlavor.equals(CelRuntimeFlavor.PLANNER) && expr.contains("2.0")); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> eval(expr)); + Throwable cause = + Throwables.getCausalChain(e).stream() + .filter(IllegalArgumentException.class::isInstance) + .filter(t -> t.getMessage() != null && t.getMessage().contains(err)) + .findFirst() + .orElse(null); + + assertWithMessage( + "Expected IllegalArgumentException with message containing '%s' in cause chain", err) + .that(cause) + .isNotNull(); + } + + @Test + public void twoVarComprehension_arithmeticException_runtimeError() throws Exception { + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval("[0].all(i, k, i/k < k)")); + assertThat(e).hasCauseThat().isInstanceOf(CelDivideByZeroException.class); + assertThat(e).hasCauseThat().hasMessageThat().contains("/ by zero"); + } + + @Test + public void twoVarComprehension_outOfBounds_runtimeError() throws Exception { + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval("[1, 2].exists(i, v, [0][v] > 0)")); + assertThat(e).hasCauseThat().isInstanceOf(CelIndexOutOfBoundsException.class); + assertThat(e).hasCauseThat().hasMessageThat().contains("Index out of bounds: 1"); + } + + @Test + public void mutableMapValue_select_missingKeyException() throws Exception { + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, () -> eval("cel.bind(my_map, {'a': 1}, my_map.b)")); + assertThat(e).hasCauseThat().isInstanceOf(CelAttributeNotFoundException.class); + assertThat(e).hasCauseThat().hasMessageThat().contains("key 'b' is not present in map."); + } + + +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelEncoderExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelEncoderExtensionsTest.java new file mode 100644 index 000000000..afeaa9105 --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelEncoderExtensionsTest.java @@ -0,0 +1,124 @@ +// Copyright 2023 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.ISO_8859_1; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.bundle.Cel; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelEvaluationException; +import org.junit.Assume; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelEncoderExtensionsTest extends CelExtensionTestBase { + private static final CelOptions CEL_OPTIONS = + CelOptions.current().enableHeterogeneousNumericComparisons(true).build(); + + @Override + protected Cel newCelEnv() { + return runtimeFlavor + .builder() + .setOptions(CEL_OPTIONS) + .addCompilerLibraries(CelExtensions.encoders(CEL_OPTIONS)) + .addRuntimeLibraries(CelExtensions.encoders(CEL_OPTIONS)) + .addVar("stringVar", SimpleType.STRING) + .build(); + } + + @Test + public void library() { + CelExtensionLibrary library = + CelExtensions.getExtensionLibrary("encoders", CelOptions.DEFAULT); + assertThat(library.name()).isEqualTo("encoders"); + assertThat(library.latest().version()).isEqualTo(0); + assertThat(library.version(0).functions().stream().map(CelFunctionDecl::name)) + .containsExactly("base64.decode", "base64.encode"); + assertThat(library.version(0).macros()).isEmpty(); + } + + @Test + public void encode_success() throws Exception { + String encodedBytes = (String) eval("base64.encode(b'hello')"); + + assertThat(encodedBytes).isEqualTo("aGVsbG8="); + } + + @Test + public void decode_success() throws Exception { + CelByteString decodedBytes = (CelByteString) eval("base64.decode('aGVsbG8=')"); + + assertThat(decodedBytes.size()).isEqualTo(5); + assertThat(new String(decodedBytes.toByteArray(), ISO_8859_1)).isEqualTo("hello"); + } + + @Test + public void decode_withoutPadding_success() throws Exception { + CelByteString decodedBytes = (CelByteString) eval("base64.decode('aGVsbG8')"); + + assertThat(decodedBytes.size()).isEqualTo(5); + assertThat(new String(decodedBytes.toByteArray(), ISO_8859_1)).isEqualTo("hello"); + } + + @Test + public void roundTrip_success() throws Exception { + String encodedString = (String) eval("base64.encode(b'Hello World!')"); + CelByteString decodedBytes = + (CelByteString) + eval("base64.decode(stringVar)", ImmutableMap.of("stringVar", encodedString)); + + assertThat(new String(decodedBytes.toByteArray(), ISO_8859_1)).isEqualTo("Hello World!"); + } + + @Test + public void encode_invalidParam_throwsCompilationException() { + Assume.assumeFalse(isParseOnly); + CelValidationException e = + assertThrows( + CelValidationException.class, () -> cel.compile("base64.encode('hello')").getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'base64.encode'"); + } + + @Test + public void decode_invalidParam_throwsCompilationException() { + Assume.assumeFalse(isParseOnly); + CelValidationException e = + assertThrows( + CelValidationException.class, () -> cel.compile("base64.decode(b'aGVsbG8=')").getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'base64.decode'"); + } + + @Test + public void decode_malformedBase64Char_throwsEvaluationException() throws Exception { + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval("base64.decode('z!')")); + + assertThat(e).hasMessageThat().contains("failed with arg(s) 'z!'"); + assertThat(e).hasCauseThat().hasMessageThat().contains("Illegal base64 character"); + } + + +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelExtensionTestBase.java b/extensions/src/test/java/dev/cel/extensions/CelExtensionTestBase.java new file mode 100644 index 000000000..3a509b003 --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelExtensionTestBase.java @@ -0,0 +1,66 @@ +// 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.extensions; + +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameter; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelException; +import dev.cel.testing.CelRuntimeFlavor; +import java.util.Map; +import org.junit.Assume; +import org.junit.Before; + +/** + * Abstract base class for extension tests to facilitate executing tests with both legacy and + * planner runtime, along with parsed-only and checked expression evaluations for the planner. + */ +abstract class CelExtensionTestBase { + @TestParameter CelRuntimeFlavor runtimeFlavor; + @TestParameter boolean isParseOnly; + + @Before + public void setUpBase() { + // Legacy runtime does not support parsed-only evaluation. + Assume.assumeFalse(runtimeFlavor.equals(CelRuntimeFlavor.LEGACY) && isParseOnly); + this.cel = newCelEnv(); + } + + protected Cel cel; + + /** + * Subclasses must implement this to provide a Cel instance configured with the specific + * extensions being tested. + */ + protected abstract Cel newCelEnv(); + + protected Object eval(String expr) throws CelException { + return eval(cel, expr, ImmutableMap.of()); + } + + protected Object eval(String expr, Map variables) throws CelException { + return eval(cel, expr, variables); + } + + protected Object eval(Cel cel, String expr) throws CelException { + return eval(cel, expr, ImmutableMap.of()); + } + + protected Object eval(Cel cel, String expr, Map variables) throws CelException { + CelAbstractSyntaxTree ast = isParseOnly ? cel.parse(expr).getAst() : cel.compile(expr).getAst(); + return cel.createProgram(ast).eval(variables); + } +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java new file mode 100644 index 000000000..31c7d65c8 --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java @@ -0,0 +1,200 @@ +// Copyright 2023 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationException; +import dev.cel.extensions.CelStringExtensions.Function; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelExtensionsTest { + + @Test + public void addAllStringExtensions_success() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelExtensions.strings()) + .addRuntimeLibraries(CelExtensions.strings()) + .build(); + String allStringExtExpr = + "'test'.substring(2) == 'st' && 'hello'.charAt(1) == 'e' && 'hello'.indexOf('o') == 4 &&" + + " 'hello'.lastIndexOf('l') == 3 && 'HELLO'.lowerAscii() == 'hello' &&" + + " 'hello'.replace('he', 'we') == 'wello' && 'hello'.upperAscii() == 'HELLO' && '" + + " hello '.trim() == 'hello' && ['he','llo'].join() == 'hello' && 'hi'.split('') ==" + + " ['h','i']"; + + boolean evaluatedResult = + (boolean) cel.createProgram(cel.compile(allStringExtExpr).getAst()).eval(); + + assertThat(evaluatedResult).isTrue(); + } + + @Test + public void addSubsetOfStringExtensions_success() throws Exception { + CelStringExtensions extensions = CelExtensions.strings(Function.SUBSTRING, Function.CHAR_AT); + Cel cel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(extensions) + .addRuntimeLibraries(extensions) + .build(); + + boolean evaluatedResult = + (boolean) + cel.createProgram( + cel.compile("'test'.substring(2) == 'st' && 'hello'.charAt(1) == 'e'").getAst()) + .eval(); + + assertThat(evaluatedResult).isTrue(); + } + + @Test + public void addStringExtensionsForRuntimeOnly_throwsValidationException() { + Cel cel = CelFactory.standardCelBuilder().addRuntimeLibraries(CelExtensions.strings()).build(); + + CelValidationException exception = + assertThrows( + CelValidationException.class, () -> cel.compile("'abcd'.substring(1, 3)").getAst()); + + assertThat(exception).hasMessageThat().contains("undeclared reference to 'substring'"); + } + + @Test + public void addStringExtensionsForCompilerOnly_throwsEvaluationException() throws Exception { + Cel cel = CelFactory.standardCelBuilder().addCompilerLibraries(CelExtensions.strings()).build(); + + CelRuntime.Program program = cel.createProgram(cel.compile("'abcd'.substring(1, 3)").getAst()); + CelEvaluationException exception = assertThrows(CelEvaluationException.class, program::eval); + + assertThat(exception) + .hasMessageThat() + .contains( + "No matching overload for function 'substring'. Overload candidates:" + + " string_substring_int_int"); + } + + @Test + public void addAllMathExtensions_success() throws Exception { + CelOptions celOptions = CelOptions.current().build(); + Cel cel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelExtensions.math(celOptions)) + .addRuntimeLibraries(CelExtensions.math(celOptions)) + .build(); + String allMathExtExpr = "math.greatest(1, 2.0) == 2.0 && math.least(1, 2.0) == 1"; + + boolean evaluatedResult = + (boolean) cel.createProgram(cel.compile(allMathExtExpr).getAst()).eval(); + + assertThat(evaluatedResult).isTrue(); + } + + @Test + public void addSubsetOfMathExtensions_success() throws Exception { + CelOptions celOptions = CelOptions.current().build(); + Cel cel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelExtensions.math(celOptions, CelMathExtensions.Function.MAX)) + .addRuntimeLibraries(CelExtensions.math(celOptions, CelMathExtensions.Function.MAX)) + .build(); + + boolean evaluatedResult = + (boolean) cel.createProgram(cel.compile("math.greatest(1, 2.0) == 2.0").getAst()).eval(); + + assertThat(evaluatedResult).isTrue(); + assertThrows(CelValidationException.class, () -> cel.compile("math.least(1,2)").getAst()); + } + + @Test + public void addEncoderExtension_success() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelExtensions.encoders()) + .addRuntimeLibraries(CelExtensions.encoders()) + .build(); + + boolean evaluatedResult = + (boolean) + cel.createProgram(cel.compile("base64.decode('aGVsbG8=') == b'hello'").getAst()).eval(); + + assertThat(evaluatedResult).isTrue(); + } + + @Test + public void getAllFunctionNames() { + assertThat(CelExtensions.getAllFunctionNames()) + .containsExactly( + "math.@max", + "math.@min", + "math.ceil", + "math.floor", + "math.round", + "math.trunc", + "math.isFinite", + "math.isNaN", + "math.isInf", + "math.abs", + "math.sign", + "math.bitAnd", + "math.bitOr", + "math.bitXor", + "math.bitNot", + "math.bitShiftLeft", + "math.bitShiftRight", + "math.sqrt", + "charAt", + "indexOf", + "join", + "lastIndexOf", + "lowerAscii", + "strings.quote", + "replace", + "split", + "substring", + "trim", + "upperAscii", + "sets.contains", + "sets.equivalent", + "sets.intersects", + "base64.decode", + "base64.encode", + "slice", + "flatten", + "lists.range", + "distinct", + "reverse", + "sort", + "lists.@sortByAssociatedKeys", + "regex.replace", + "regex.extract", + "regex.extractAll", + "value", + "hasValue", + "optional.none", + "optional.of", + "optional.unwrap", + "optional.ofNonZeroValue", + "cel.@mapInsert"); + } +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelListsExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelListsExtensionsTest.java new file mode 100644 index 000000000..4520f81ba --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelListsExtensionsTest.java @@ -0,0 +1,323 @@ +// Copyright 2024 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSortedMultiset; +import com.google.common.collect.ImmutableSortedSet; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.common.CelContainer; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.SimpleType; +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; + +@RunWith(TestParameterInjector.class) +public class CelListsExtensionsTest extends CelExtensionTestBase { + + @Override + protected Cel newCelEnv() { + return runtimeFlavor + .builder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addCompilerLibraries(CelExtensions.lists()) + .addRuntimeLibraries(CelExtensions.lists()) + .setContainer(CelContainer.ofName("cel.expr.conformance.test")) + .addMessageTypes(SimpleTest.getDescriptor()) + .addVar("non_list", SimpleType.DYN) + .build(); + } + + @Test + public void functionList_byVersion() { + assertThat(CelExtensions.lists(0).functions().stream().map(f -> f.name())) + .containsExactly("slice"); + assertThat(CelExtensions.lists(1).functions().stream().map(f -> f.name())) + .containsExactly("slice", "flatten"); + assertThat(CelExtensions.lists(2).functions().stream().map(f -> f.name())) + .containsExactly( + "slice", + "flatten", + "lists.range", + "distinct", + "reverse", + "sort", + "lists.@sortByAssociatedKeys"); + } + + @Test + public void macroList_byVersion() { + assertThat(CelExtensions.lists(0).macros().stream().map(f -> f.getFunction())).isEmpty(); + assertThat(CelExtensions.lists(1).macros().stream().map(f -> f.getFunction())).isEmpty(); + assertThat(CelExtensions.lists(2).macros().stream().map(f -> f.getFunction())) + .containsExactly("sortBy"); + } + + @Test + @TestParameters("{expression: '[1,2,3,4].slice(0, 4)', expected: '[1,2,3,4]'}") + @TestParameters("{expression: '[1,2,3,4].slice(0, 0)', expected: '[]'}") + @TestParameters("{expression: '[1,2,3,4].slice(1, 1)', expected: '[]'}") + @TestParameters("{expression: '[1,2,3,4].slice(4, 4)', expected: '[]'}") + @TestParameters("{expression: '[1,2,3,4].slice(1, 3)', expected: '[2, 3]'}") + @TestParameters("{expression: 'non_list.slice(1, 3)', expected: '[2, 3]'}") + public void slice_success(String expression, String expected) throws Exception { + Object result = + eval(cel, expression, ImmutableMap.of("non_list", ImmutableSortedSet.of(4L, 1L, 3L, 2L))); + + assertThat(result).isEqualTo(eval(cel, expected)); + } + + @Test + @TestParameters( + "{expression: '[1,2,3,4].slice(3, 0)', " + + "expectedError: 'Start index must be less than or equal to end index'}") + @TestParameters("{expression: '[1,2,3,4].slice(0, 10)', expectedError: 'List is length 4'}") + @TestParameters( + "{expression: '[1,2,3,4].slice(-5, 10)', " + + "expectedError: 'Negative indexes not supported'}") + @TestParameters( + "{expression: '[1,2,3,4].slice(-5, -3)', " + + "expectedError: 'Negative indexes not supported'}") + public void slice_throws(String expression, String expectedError) throws Exception { + assertThat(assertThrows(CelEvaluationException.class, () -> eval(cel, expression))) + .hasCauseThat() + .hasMessageThat() + .contains(expectedError); + } + + @Test + @TestParameters("{expression: '[].flatten() == []'}") + @TestParameters("{expression: '[[1, 2]].flatten().exists(i, i == 1)'}") + @TestParameters("{expression: '[[], [[]], [[[]]]].flatten() == [[], [[]]]'}") + @TestParameters("{expression: '[1,[2,[3,4]]].flatten() == [1,2,[3,4]]'}") + @TestParameters("{expression: '[1,2,[],[],[3,4]].flatten() == [1,2,3,4]'}") + @TestParameters("{expression: '[1,[2,3],[[4,5]], [[[6,7]]]].flatten() == [1,2,3,[4,5],[[6,7]]]'}") + @TestParameters("{expression: 'dyn([1]).flatten() == [1]'}") + @TestParameters("{expression: 'dyn([{1: 2}]).flatten() == [{1: 2}]'}") + @TestParameters("{expression: 'dyn([1,2,3,4]).flatten() == [1,2,3,4]'}") + public void flattenSingleLevel_success(String expression) throws Exception { + boolean result = (boolean) eval(cel, expression); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expression: '[1,2,3,4].flatten(1) == [1,2,3,4]'}") + @TestParameters("{expression: '[1,[2,[3,[4]]]].flatten(0) == [1,[2,[3,[4]]]]'}") + @TestParameters("{expression: '[1,[2,[3,[4]]]].flatten(2) == [1,2,3,[4]]'}") + @TestParameters("{expression: '[1,[2,[3,4]]].flatten(2) == [1,2,3,4]'}") + @TestParameters("{expression: '[[], [[]], [[[]]]].flatten(2) == [[]]'}") + @TestParameters("{expression: '[[], [[]], [[[]]]].flatten(3) == []'}") + @TestParameters("{expression: '[[], [[]], [[[]]]].flatten(4) == []'}") + // The overload with the depth accepts and returns a List(dyn), so the following is permitted. + @TestParameters("{expression: '[1].flatten(1) == [1]'}") + public void flatten_withDepthValue_success(String expression) throws Exception { + boolean result = (boolean) eval(cel, expression); + + assertThat(result).isTrue(); + } + + @Test + public void flatten_negativeDepth_throws() { + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval(cel, "[1,2,3,4].flatten(-1)")); + + if (runtimeFlavor.equals(CelRuntimeFlavor.PLANNER)) { + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :17: Function 'flatten' failed"); + } else { + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :17: Function 'list_flatten_list_int' failed"); + } + assertThat(e).hasCauseThat().hasMessageThat().isEqualTo("Level must be non-negative"); + } + + @Test + @TestParameters("{expression: '[1].flatten()'}") + @TestParameters("{expression: '[{1: 2}].flatten()'}") + @TestParameters("{expression: '[1,2,3,4].flatten()'}") + public void flattenSingleLevel_listIsSingleLevel_throws(String expression) { + // This is a type-checking failure. + Assume.assumeFalse(isParseOnly); + // Note: Java lacks the capability of conditionally disabling type guards + // due to the lack of full-fledged dynamic dispatch. + assertThrows(CelValidationException.class, () -> cel.compile(expression).getAst()); + } + + @Test + @TestParameters("{expression: 'lists.range(9) == [0,1,2,3,4,5,6,7,8]'}") + @TestParameters("{expression: 'lists.range(0) == []'}") + @TestParameters("{expression: 'lists.range(-1) == []'}") + public void range_success(String expression) throws Exception { + boolean result = (boolean) eval(cel, expression); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expression: '[].distinct()', expected: '[]'}") + @TestParameters("{expression: '[].distinct()', expected: '[]'}") + @TestParameters("{expression: '[1].distinct()', expected: '[1]'}") + @TestParameters("{expression: '[-2, 5, -2, 1, 1, 5, -2, 1].distinct()', expected: '[-2, 5, 1]'}") + @TestParameters( + "{expression: '[-2, 5, -2, 1, 1, 5, -2, 1, 5, -2, -2, 1].distinct()', " + + "expected: '[-2, 5, 1]'}") + @TestParameters( + "{expression: '[\"c\", \"a\", \"a\", \"b\", \"a\", \"b\", \"c\", \"c\"].distinct()'," + + " expected: '[\"c\", \"a\", \"b\"]'}") + @TestParameters( + "{expression: '[1, 2.0, \"c\", 3, \"c\", 1].distinct()', " + + "expected: '[1, 2.0, \"c\", 3]'}") + @TestParameters("{expression: '[1, 1.0, 2, 2u].distinct()', expected: '[1, 2]'}") + @TestParameters("{expression: '[[1], [1], [2]].distinct()', expected: '[[1], [2]]'}") + @TestParameters( + "{expression: '[SimpleTest{name: \"a\"}, SimpleTest{name: \"b\"}, SimpleTest{name: \"a\"}]" + + ".distinct()', " + + "expected: '[SimpleTest{name: \"a\"}, SimpleTest{name: \"b\"}]'}") + @TestParameters("{expression: 'non_list.distinct()', expected: '[1, 2, 3, 4]'}") + public void distinct_success(String expression, String expected) throws Exception { + Object result = + eval( + cel, + expression, + ImmutableMap.of( + "non_list", ImmutableSortedMultiset.of(1L, 2L, 3L, 4L, 4L, 1L, 3L, 2L))); + + assertThat(result).isEqualTo(eval(cel, expected)); + } + + @Test + @TestParameters("{expression: '[5,1,2,3].reverse()', expected: '[3,2,1,5]'}") + @TestParameters("{expression: '[].reverse()', expected: '[]'}") + @TestParameters("{expression: '[1].reverse()', expected: '[1]'}") + @TestParameters( + "{expression: '[\"are\", \"you\", \"as\", \"bored\", \"as\", \"I\", \"am\"].reverse()', " + + "expected: '[\"am\", \"I\", \"as\", \"bored\", \"as\", \"you\", \"are\"]'}") + @TestParameters( + "{expression: '[false, true, true].reverse().reverse()', expected: '[false, true, true]'}") + @TestParameters("{expression: 'non_list.reverse()', expected: '[4, 3, 2, 1]'}") + public void reverse_success(String expression, String expected) throws Exception { + Object result = + eval(cel, expression, ImmutableMap.of("non_list", ImmutableSortedSet.of(4L, 1L, 3L, 2L))); + + assertThat(result).isEqualTo(eval(cel, expected)); + } + + @Test + @TestParameters("{expression: '[].sort()', expected: '[]'}") + @TestParameters("{expression: '[1].sort()', expected: '[1]'}") + @TestParameters("{expression: '[4, 3, 2, 1].sort()', expected: '[1, 2, 3, 4]'}") + @TestParameters( + "{expression: '[\"d\", \"a\", \"b\", \"c\"].sort()', " + + "expected: '[\"a\", \"b\", \"c\", \"d\"]'}") + public void sort_success(String expression, String expected) throws Exception { + Object result = eval(cel, expression); + + assertThat(result).isEqualTo(eval(cel, expected)); + } + + @Test + @TestParameters("{expression: '[3.0, 2, 1u].sort()', expected: '[1u, 2, 3.0]'}") + @TestParameters("{expression: '[4, 3, 2, 1].sort()', expected: '[1, 2, 3, 4]'}") + public void sort_success_heterogeneousNumbers(String expression, String expected) + throws Exception { + Object result = eval(cel, expression); + + assertThat(result).isEqualTo(eval(cel, expected)); + } + + @Test + @TestParameters( + "{expression: '[\"d\", 3, 2, \"c\"].sort()', " + + "expectedError: 'List elements must have the same type'}") + @TestParameters( + "{expression: '[SimpleTest{name: \"a\"}, SimpleTest{name: \"b\"}].sort()', " + + "expectedError: 'List elements must be comparable'}") + public void sort_throws(String expression, String expectedError) throws Exception { + assertThat(assertThrows(CelEvaluationException.class, () -> eval(cel, expression))) + .hasCauseThat() + .hasMessageThat() + .contains(expectedError); + } + + @Test + @TestParameters("{expression: '[].sortBy(e, e)', expected: '[]'}") + @TestParameters("{expression: '[\"a\"].sortBy(e, e)', expected: '[\"a\"]'}") + @TestParameters( + "{expression: '[-3, 1, -5, -2, 4].sortBy(e, -(e * e))', " + "expected: '[-5, 4, -3, -2, 1]'}") + @TestParameters( + "{expression: '[-3, 1, -5, -2, 4].map(e, e * 2).sortBy(e, -(e * e)) ', " + + "expected: '[-10, 8, -6, -4, 2]'}") + @TestParameters("{expression: 'lists.range(3).sortBy(e, -e) ', " + "expected: '[2, 1, 0]'}") + @TestParameters( + "{expression: '[\"a\", \"c\", \"b\", \"first\"].sortBy(e, e == \"first\" ? \"\" : e)', " + + "expected: '[\"first\", \"a\", \"b\", \"c\"]'}") + @TestParameters( + "{expression: '[SimpleTest{name: \"baz\"}," + + " SimpleTest{name: \"foo\"}," + + " SimpleTest{name: \"bar\"}].sortBy(e, e.name)', " + + "expected: '[SimpleTest{name: \"bar\"}," + + " SimpleTest{name: \"baz\"}," + + " SimpleTest{name: \"foo\"}]'}") + public void sortBy_success(String expression, String expected) throws Exception { + Object result = eval(cel, expression); + + assertThat(result).isEqualTo(eval(cel, expected)); + } + + @Test + @TestParameters( + "{expression: 'lists.range(3).sortBy(-e, e)', " + + "expectedError: 'variable name must be a simple identifier'}") + @TestParameters( + "{expression: 'lists.range(3).sortBy(e.foo, e)', " + + "expectedError: 'variable name must be a simple identifier'}") + public void sortBy_throws_validationException(String expression, String expectedError) + throws Exception { + CelValidationResult result = cel.compile(expression); + assertThat(assertThrows(CelValidationException.class, () -> result.getAst())) + .hasMessageThat() + .contains(expectedError); + } + + @Test + @TestParameters( + "{expression: '[[1, 2], [\"a\", \"b\"]].sortBy(e, e[0])', " + + "expectedError: 'List elements must have the same type'}") + @TestParameters( + "{expression: '[SimpleTest{name: \"a\"}, SimpleTest{name: \"b\"}].sortBy(e, e)', " + + "expectedError: 'List elements must be comparable'}") + public void sortBy_throws_evaluationException(String expression, String expectedError) + throws Exception { + assertThat(assertThrows(CelEvaluationException.class, () -> eval(cel, expression))) + .hasCauseThat() + .hasMessageThat() + .contains(expectedError); + } + + +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelLiteExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelLiteExtensionsTest.java new file mode 100644 index 000000000..c78eb9e58 --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelLiteExtensionsTest.java @@ -0,0 +1,48 @@ +// Copyright 2025 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.extensions; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelLiteRuntime; +import dev.cel.runtime.CelLiteRuntimeFactory; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelLiteExtensionsTest { + + @Test + public void addSetsExtensions() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries(CelExtensions.sets(CelOptions.DEFAULT)) + .build(); + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .addLibraries(CelLiteExtensions.sets(CelOptions.DEFAULT)) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("sets.contains([1, 1], [1])").getAst(); + + boolean result = (boolean) runtime.createProgram(ast).eval(); + + assertThat(result).isTrue(); + } +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelMathExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelMathExtensionsTest.java new file mode 100644 index 000000000..68c80dedb --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelMathExtensionsTest.java @@ -0,0 +1,1129 @@ +// Copyright 2023 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.testing.CelRuntimeFlavor; +import java.util.Map; +import org.junit.Assume; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelMathExtensionsTest { + @TestParameter private CelRuntimeFlavor runtimeFlavor; + @TestParameter private boolean isParseOnly; + + private Cel cel; + + @Before + public void setUp() { + // Legacy runtime does not support parsed-only evaluation mode. + Assume.assumeFalse(runtimeFlavor.equals(CelRuntimeFlavor.LEGACY) && isParseOnly); + this.cel = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableHeterogeneousNumericComparisons( + runtimeFlavor.equals(CelRuntimeFlavor.PLANNER)) + .build()) + .addCompilerLibraries(CelExtensions.math()) + .addRuntimeLibraries(CelExtensions.math()) + .build(); + } + + @Test + @TestParameters("{expr: 'math.greatest(-5)', expectedResult: -5}") + @TestParameters("{expr: 'math.greatest(5)', expectedResult: 5}") + @TestParameters("{expr: 'math.greatest(1, 1)', expectedResult: 1}") + @TestParameters("{expr: 'math.greatest(1, 1.0)', expectedResult: 1}") + @TestParameters("{expr: 'math.greatest(1, 1u)', expectedResult: 1}") + @TestParameters("{expr: 'math.greatest(-3, 3)', expectedResult: 3}") + @TestParameters("{expr: 'math.greatest(9, 10)', expectedResult: 10}") + @TestParameters("{expr: 'math.greatest(15, 14)', expectedResult: 15}") + @TestParameters( + "{expr: 'math.greatest(1, 9223372036854775807)', expectedResult: 9223372036854775807}") + @TestParameters( + "{expr: 'math.greatest(9223372036854775807, 1)', expectedResult: 9223372036854775807}") + @TestParameters("{expr: 'math.greatest(-9223372036854775808, 1)', expectedResult: 1}") + @TestParameters("{expr: 'math.greatest(1, -9223372036854775808)', expectedResult: 1}") + @TestParameters("{expr: 'math.greatest(1, 1, 1)', expectedResult: 1}") + @TestParameters("{expr: 'math.greatest(3, 1, 10)', expectedResult: 10}") + @TestParameters("{expr: 'math.greatest(1, 5, 2)', expectedResult: 5}") + @TestParameters("{expr: 'math.greatest(-1, 1, 0)', expectedResult: 1}") + @TestParameters("{expr: 'math.greatest(dyn(1), 1, 1.0)', expectedResult: 1}") + @TestParameters("{expr: 'math.greatest(5, 1.0, 3u)', expectedResult: 5}") + @TestParameters("{expr: 'math.greatest(5.4, 10, 3u, -5.0, 3.5)', expectedResult: 10}") + @TestParameters( + "{expr: 'math.greatest(5.4, 10, 3u, -5.0, 9223372036854775807)', expectedResult:" + + " 9223372036854775807}") + @TestParameters( + "{expr: 'math.greatest(9223372036854775807, 10, 3u, -5.0, 0)', expectedResult:" + + " 9223372036854775807}") + @TestParameters("{expr: 'math.greatest([5.4, 10, 3u, -5.0, 3.5])', expectedResult: 10}") + @TestParameters( + "{expr: 'math.greatest([dyn(5.4), dyn(10), dyn(3u), dyn(-5.0), dyn(3.5)])', expectedResult:" + + " 10}") + public void greatest_intResult_success(String expr, long expectedResult) throws Exception { + Object result = eval(expr); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.greatest(-5.0)', expectedResult: -5.0}") + @TestParameters("{expr: 'math.greatest(5.0)', expectedResult: 5.0}") + @TestParameters("{expr: 'math.greatest(1.0, 1.0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.greatest(1.0, 1)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.greatest(1.0, 1u)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.greatest(-3, 3.0)', expectedResult: 3.0}") + @TestParameters("{expr: 'math.greatest(9, 10.0)', expectedResult: 10.0}") + @TestParameters("{expr: 'math.greatest(15.0, 14)', expectedResult: 15.0}") + @TestParameters("{expr: 'math.greatest(14, 15.0)', expectedResult: 15.0}") + @TestParameters("{expr: 'math.greatest(15.0, 14u)', expectedResult: 15.0}") + @TestParameters("{expr: 'math.greatest(14u, 15.0)', expectedResult: 15.0}") + @TestParameters("{expr: 'math.greatest(1, 1.797693e308)', expectedResult: 1.797693e308}") + @TestParameters("{expr: 'math.greatest(1.797693e308, 1)', expectedResult: 1.797693e308}") + @TestParameters("{expr: 'math.greatest(-1.797693e308, 1.0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.greatest(1.0, -1.797693e308)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.greatest(1.0, 1.0, 1.0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.greatest(3.0, 1.0, 10.0)', expectedResult: 10.0}") + @TestParameters("{expr: 'math.greatest(1.0, 5.0, 2.0)', expectedResult: 5.0}") + @TestParameters("{expr: 'math.greatest(-1.0, 1.0, 0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.greatest(dyn(1.0), 1.0, 1.0)', expectedResult: 1}") + @TestParameters("{expr: 'math.greatest(5.0, 1.0, 3u)', expectedResult: 5.0}") + @TestParameters("{expr: 'math.greatest(5.4, 10.0, 3u, -5.0, 3.5)', expectedResult: 10}") + @TestParameters( + "{expr: 'math.greatest(5.4, 10, 3u, -5.0, 1.797693e308)', expectedResult:" + " 1.797693e308}") + @TestParameters( + "{expr: 'math.greatest(1.797693e308, 10, 3u, -5.0, 0)', expectedResult:" + " 1.797693e308}") + @TestParameters("{expr: 'math.greatest([5.4, 10.0, 3u, -5.0, 3.5])', expectedResult: 10}") + @TestParameters( + "{expr: 'math.greatest([dyn(5.4), dyn(10.0), dyn(3u), dyn(-5.0), dyn(3.5)])', expectedResult:" + + " 10.0}") + public void greatest_doubleResult_success(String expr, double expectedResult) throws Exception { + Object result = eval(expr); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.greatest(1.0, 1u)', expectedResult: '1.0'}") + @TestParameters("{expr: 'math.greatest(15.0, 14u)', expectedResult: '15.0'}") + @TestParameters("{expr: 'math.greatest(14u, 15.0)', expectedResult: '15.0'}") + @TestParameters("{expr: 'math.greatest(1u, 1.797693e308)', expectedResult: '1.797693e308'}") + @TestParameters("{expr: 'math.greatest(1.797693e308, 1u)', expectedResult: '1.797693e308'}") + @TestParameters("{expr: 'math.greatest(-1.797693e308, 1.0)', expectedResult: '1.0'}") + @TestParameters("{expr: 'math.greatest(5.0, 1.0, 3u)', expectedResult: '5.0'}") + @TestParameters("{expr: 'math.greatest(5.0, 1.0, dyn(3u))', expectedResult: '5.0'}") + @TestParameters("{expr: 'math.greatest(5.4, 10.0, 3u, -5.0, 3.5)', expectedResult: '10'}") + @TestParameters( + "{expr: 'math.greatest(5.4, 10, 3u, -5.0, 1.797693e308)', expectedResult: '1.797693e308'}") + @TestParameters( + "{expr: 'math.greatest(1.797693e308, 10, 3u, -5.0, 0)', expectedResult: '1.797693e308'}") + @TestParameters("{expr: 'math.greatest([5.4, 10.0, 3u, -5.0, 3.5])', expectedResult: '10'}") + @TestParameters( + "{expr: 'math.greatest([dyn(5.4), dyn(10.0), dyn(3u), dyn(-5.0), dyn(3.5)])', expectedResult:" + + " '10.0'}") + public void greatest_doubleResult_withUnsignedLongsEnabled_success( + String expr, double expectedResult) throws Exception { + CelOptions celOptions = CelOptions.DEFAULT; + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(celOptions) + .addLibraries(CelExtensions.math()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setOptions(celOptions) + .addLibraries(CelExtensions.math()) + .build(); + + CelAbstractSyntaxTree ast = celCompiler.compile(expr).getAst(); + double result = (double) celRuntime.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.greatest(5u)', expectedResult: '5'}") + @TestParameters( + "{expr: 'math.greatest(18446744073709551615u)', expectedResult: '18446744073709551615'}") + @TestParameters("{expr: 'math.greatest(1u, 1.0)', expectedResult: '1'}") + @TestParameters("{expr: 'math.greatest(1u, 1)', expectedResult: '1'}") + @TestParameters("{expr: 'math.greatest(1u, 1u)', expectedResult: '1'}") + @TestParameters("{expr: 'math.greatest(3u, 3.0)', expectedResult: '3'}") + @TestParameters("{expr: 'math.greatest(9u, 10u)', expectedResult: '10'}") + @TestParameters("{expr: 'math.greatest(15u, 14u)', expectedResult: '15'}") + @TestParameters( + "{expr: 'math.greatest(1, 18446744073709551615u)', expectedResult: '18446744073709551615'}") + @TestParameters( + "{expr: 'math.greatest(18446744073709551615u, 1)', expectedResult: '18446744073709551615'}") + @TestParameters("{expr: 'math.greatest(1u, 1, 1)', expectedResult: '1'}") + @TestParameters("{expr: 'math.greatest(3u, 1u, 10u)', expectedResult: '10'}") + @TestParameters("{expr: 'math.greatest(1u, 5u, 2u)', expectedResult: '5'}") + @TestParameters("{expr: 'math.greatest(-1, 1u, 0u)', expectedResult: '1'}") + @TestParameters("{expr: 'math.greatest(dyn(1u), 1, 1.0)', expectedResult: '1'}") + @TestParameters("{expr: 'math.greatest(5u, 1.0, 3u)', expectedResult: '5'}") + @TestParameters("{expr: 'math.greatest(5.4, 10u, 3u, -5.0, 3.5)', expectedResult: '10'}") + @TestParameters( + "{expr: 'math.greatest(5.4, 10, 3u, -5.0, 18446744073709551615u)', expectedResult:" + + " '18446744073709551615'}") + @TestParameters( + "{expr: 'math.greatest(18446744073709551615u, 10, 3u, -5.0, 0)', expectedResult:" + + " '18446744073709551615'}") + @TestParameters("{expr: 'math.greatest([5.4, 10u, 3, -5.0, 3.5])', expectedResult: '10'}") + @TestParameters( + "{expr: 'math.greatest([dyn(5.4), dyn(10u), dyn(3u), dyn(-5.0), dyn(3.5)])', expectedResult:" + + " '10'}") + public void greatest_unsignedLongResult_withUnsignedLongType_success( + String expr, String expectedResult) throws Exception { + CelOptions celOptions = CelOptions.DEFAULT; + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(celOptions) + .addLibraries(CelExtensions.math()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setOptions(celOptions) + .addLibraries(CelExtensions.math()) + .build(); + + CelAbstractSyntaxTree ast = celCompiler.compile(expr).getAst(); + UnsignedLong result = (UnsignedLong) celRuntime.createProgram(ast).eval(); + + assertThat(result).isEqualTo(UnsignedLong.valueOf(expectedResult)); + } + + @Test + public void greatest_noArgs_throwsCompilationException() { + Assume.assumeFalse(isParseOnly); + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile("math.greatest()").getAst()); + + assertThat(e).hasMessageThat().contains("math.greatest() requires at least one argument"); + } + + @Test + @TestParameters("{expr: 'math.greatest(''test'')'}") + @TestParameters("{expr: 'math.greatest({})'}") + @TestParameters("{expr: 'math.greatest([])'}") + public void greatest_invalidSingleArg_throwsCompilationException(String expr) { + Assume.assumeFalse(isParseOnly); + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("math.greatest() invalid single argument value"); + } + + @Test + @TestParameters("{expr: 'math.greatest(1, true)'}") + @TestParameters("{expr: 'math.greatest(1, 2, ''test'')'}") + @TestParameters("{expr: 'math.greatest([1, false])'}") + @TestParameters("{expr: 'math.greatest([1, 2, true])'}") + @TestParameters("{expr: 'math.greatest([1, {}, 2])'}") + @TestParameters("{expr: 'math.greatest([1, [], 2])'}") + public void greatest_invalidArgs_throwsCompilationException(String expr) { + Assume.assumeFalse(isParseOnly); + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e) + .hasMessageThat() + .contains("math.greatest() simple literal arguments must be numeric"); + } + + @Test + @TestParameters("{expr: 'math.greatest(1, 2, dyn(''test''))'}") + @TestParameters("{expr: 'math.greatest([1, dyn(false)])'}") + @TestParameters("{expr: 'math.greatest([1, 2, dyn(true)])'}") + @TestParameters("{expr: 'math.greatest([1, dyn({}), 2])'}") + @TestParameters("{expr: 'math.greatest([1, dyn([]), 2])'}") + public void greatest_invalidDynArgs_throwsRuntimeException(String expr) throws Exception { + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> eval(expr)); + + assertThat(e).hasMessageThat().contains("failed with arg(s)"); + } + + @Test + public void greatest_listVariableIsEmpty_throwsRuntimeException() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries(CelExtensions.math()) + .addVar("listVar", ListType.create(SimpleType.INT)) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("math.greatest(listVar)").getAst(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> cel.createProgram(ast).eval(ImmutableMap.of("listVar", ImmutableList.of()))); + + assertThat(e).hasMessageThat().contains("failed with arg(s)"); + assertThat(e) + .hasCauseThat() + .hasMessageThat() + .contains("math.@max(list) argument must not be empty"); + } + + @Test + @TestParameters("{expr: '100.greatest(1) == 1'}") + @TestParameters("{expr: 'dyn(100).greatest(1) == 1'}") + public void greatest_nonMathNamespace_success(String expr) throws Exception { + Cel cel = + runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.math()) + .addRuntimeLibraries(CelExtensions.math()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "greatest", + CelOverloadDecl.newMemberOverload( + "int_greatest_int", SimpleType.INT, SimpleType.INT, SimpleType.INT))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "greatest", + CelFunctionBinding.from( + "int_greatest_int", Long.class, Long.class, (arg1, arg2) -> arg2))) + .build(); + + boolean result = (boolean) eval(cel, expr); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expr: 'math.least(-5)', expectedResult: -5}") + @TestParameters("{expr: 'math.least(5)', expectedResult: 5}") + @TestParameters("{expr: 'math.least(1, 1)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(1, 1.0)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(1, 1u)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(-3, 3)', expectedResult: -3}") + @TestParameters("{expr: 'math.least(3, -3)', expectedResult: -3}") + @TestParameters("{expr: 'math.least(9, 10)', expectedResult: 9}") + @TestParameters("{expr: 'math.least(15, 14)', expectedResult: 14}") + @TestParameters( + "{expr: 'math.least(1, -9223372036854775808)', expectedResult: -9223372036854775808}") + @TestParameters( + "{expr: 'math.least(-9223372036854775808, 1)', expectedResult: -9223372036854775808}") + @TestParameters("{expr: 'math.least(9223372036854775807, 1)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(1, 9223372036854775807)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(1, 1, 1)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(3, -1, 10)', expectedResult: -1}") + @TestParameters("{expr: 'math.least(1, 5, 2)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(-1, 1, 0)', expectedResult: -1}") + @TestParameters("{expr: 'math.least(dyn(1), 1, 1.0)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(-5, 1.0, 3u)', expectedResult: -5}") + @TestParameters("{expr: 'math.least(5.4, -10, 3u, -5.0, 3.5)', expectedResult: -10}") + @TestParameters( + "{expr: 'math.least(5.4, 10, 3u, -5.0, -9223372036854775808)', expectedResult:" + + " -9223372036854775808}") + @TestParameters( + "{expr: 'math.least(-9223372036854775808, 10, 3u, -5.0, 0)', expectedResult:" + + " -9223372036854775808}") + @TestParameters("{expr: 'math.least([5.4, -10, 3u, -5.0, 3.5])', expectedResult: -10}") + @TestParameters("{expr: 'math.least(1, 9223372036854775807u)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(9223372036854775807u, 1)', expectedResult: 1}") + @TestParameters("{expr: 'math.least(9223372036854775807, 10, 3u, 5.0, 0)', expectedResult: 0}") + @TestParameters( + "{expr: 'math.least([dyn(5.4), dyn(-10), dyn(3u), dyn(-5.0), dyn(3.5)])', expectedResult:" + + " -10}") + public void least_intResult_success(String expr, long expectedResult) throws Exception { + Object result = eval(expr); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.least(-5.0)', expectedResult: -5.0}") + @TestParameters("{expr: 'math.least(5.0)', expectedResult: 5.0}") + @TestParameters("{expr: 'math.least(1.0, 1.0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(1.0, 1)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(1.0, 1u)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(3, -3.0)', expectedResult: -3.0}") + @TestParameters("{expr: 'math.least(9, -10.0)', expectedResult: -10.0}") + @TestParameters("{expr: 'math.least(15, 14.0)', expectedResult: 14.0}") + @TestParameters("{expr: 'math.least(15, 14.0)', expectedResult: 14.0}") + @TestParameters("{expr: 'math.least(13.0, 14u)', expectedResult: 13.0}") + @TestParameters("{expr: 'math.least(14u, 13.0)', expectedResult: 13.0}") + @TestParameters("{expr: 'math.least(1, -1.797693e308)', expectedResult: -1.797693e308}") + @TestParameters("{expr: 'math.least(-1.797693e308, 1)', expectedResult: -1.797693e308}") + @TestParameters("{expr: 'math.least(1.797693e308, 1.0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(1.0, 1.797693e308)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(1.0, 1.0, 1.0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(3.0, 1.0, 10.0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(1.0, 5.0, 2.0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(-1.0, 1.0, 0)', expectedResult: -1.0}") + @TestParameters("{expr: 'math.least(dyn(1.0), 1.0, 1.0)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(5.0, 1.0, 3u)', expectedResult: 1.0}") + @TestParameters("{expr: 'math.least(5.4, 10.0, 3u, -5.0, 3.5)', expectedResult: -5.0}") + @TestParameters( + "{expr: 'math.least(5.4, 10, 3u, -5.0, -1.797693e308)', expectedResult: -1.797693e308}") + @TestParameters( + "{expr: 'math.least(-1.797693e308, 10, 3u, -5.0, 0)', expectedResult: -1.797693e308}") + @TestParameters("{expr: 'math.least([5.4, 10.0, 3u, -5.0, 3.5])', expectedResult: -5.0}") + @TestParameters( + "{expr: 'math.least([dyn(5.4), dyn(10.0), dyn(3u), dyn(-5.0), dyn(3.5)])', expectedResult:" + + " -5.0}") + public void least_doubleResult_success(String expr, double expectedResult) throws Exception { + Object result = eval(expr); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.least(1.0, 1u)', expectedResult: '1.0'}") + @TestParameters("{expr: 'math.least(13.0, 14u)', expectedResult: '13.0'}") + @TestParameters("{expr: 'math.least(14u, 13.0)', expectedResult: '13.0'}") + @TestParameters("{expr: 'math.least(1u, -1.797693e308)', expectedResult: '-1.797693e308'}") + @TestParameters("{expr: 'math.least(-1.797693e308, 1u)', expectedResult: '-1.797693e308'}") + @TestParameters("{expr: 'math.least(1.797693e308, 1.0)', expectedResult: '1.0'}") + @TestParameters("{expr: 'math.least(5.0, 1.0, 3u)', expectedResult: '1.0'}") + @TestParameters("{expr: 'math.least(5.0, 1.0, dyn(3u))', expectedResult: '1.0'}") + @TestParameters("{expr: 'math.least(5.4, 10.0, 3u, -5.0, 3.5)', expectedResult: '-5.0'}") + @TestParameters( + "{expr: 'math.least(5.4, 10, 3u, -5.0, -1.797693e308)', expectedResult: '-1.797693e308'}") + @TestParameters( + "{expr: 'math.least(-1.797693e308, 10, 3u, -5.0, 0)', expectedResult: '-1.797693e308'}") + @TestParameters("{expr: 'math.least([5.4, 10.0, 3u, -5.0, 3.5])', expectedResult: '-5.0'}") + @TestParameters( + "{expr: 'math.least([dyn(5.4), dyn(10.0), dyn(3u), dyn(-5.0), dyn(3.5)])', expectedResult:" + + " '-5.0'}") + public void least_doubleResult_withUnsignedLongsEnabled_success( + String expr, double expectedResult) throws Exception { + CelOptions celOptions = CelOptions.current().enableUnsignedLongs(true).build(); + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(celOptions) + .addLibraries(CelExtensions.math()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setOptions(celOptions) + .addLibraries(CelExtensions.math()) + .build(); + + CelAbstractSyntaxTree ast = celCompiler.compile(expr).getAst(); + double result = (double) celRuntime.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.least(9, 1u, 0u)', expectedResult: '0'}") + @TestParameters("{expr: 'math.least(dyn(1u), 1, 1.0)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(5.0, 1u, 3u)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(5.4, 1u, 3u, 9, 3.5)', expectedResult: '1'}") + @TestParameters( + "{expr: 'math.least(5.4, 10, 3u, 5.0, 9223372036854775807)', expectedResult: '3'}") + @TestParameters("{expr: 'math.least([5.4, 10, 3u, 5.0, 3.5])', expectedResult: '3'}") + @TestParameters( + "{expr: 'math.least([dyn(5.4), dyn(10), dyn(3u), dyn(5.0), dyn(3.5)])', expectedResult: '3'}") + @TestParameters( + "{expr: 'math.least(18446744073709551615u)', expectedResult: '18446744073709551615'}") + @TestParameters("{expr: 'math.least(1u, 1.0)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(1u, 1u)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(1u, 1u)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(3u, 3.0)', expectedResult: '3'}") + @TestParameters("{expr: 'math.least(9u, 10u)', expectedResult: '9'}") + @TestParameters("{expr: 'math.least(15u, 14u)', expectedResult: '14'}") + @TestParameters("{expr: 'math.least(15, 14u)', expectedResult: '14'}") + @TestParameters("{expr: 'math.least(14u, 15)', expectedResult: '14'}") + @TestParameters("{expr: 'math.least(1u, 18446744073709551615u)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(18446744073709551615u, 1u)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(1u, 1, 1)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(3u, 1u, 10u)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(1u, 5u, 2u)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(4, 1u, 0u)', expectedResult: '0'}") + @TestParameters("{expr: 'math.least(dyn(1u), 1u, 1.0)', expectedResult: '1'}") + @TestParameters("{expr: 'math.least(5u, 1.0, 0u)', expectedResult: '0'}") + @TestParameters("{expr: 'math.least(5.4, 10u, 3u, 5.0, 3.5)', expectedResult: '3'}") + @TestParameters( + "{expr: 'math.least(5.4, 10, 3u, 0u, 18446744073709551615u)', expectedResult: '0'}") + @TestParameters( + "{expr: 'math.least(18446744073709551615u, 10, 3u, 5.0, 0u)', expectedResult: '0'}") + @TestParameters("{expr: 'math.least([5.4, 10u, 3u, 5.0, 3.5])', expectedResult: '3'}") + @TestParameters( + "{expr: 'math.least([dyn(5.4), dyn(10u), dyn(3u), dyn(5.0), dyn(3.5)])', expectedResult:" + + " '3'}") + public void least_unsignedLongResult_withUnsignedLongType_success( + String expr, String expectedResult) throws Exception { + CelOptions celOptions = CelOptions.current().build(); + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(celOptions) + .addLibraries(CelExtensions.math()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setOptions(celOptions) + .addLibraries(CelExtensions.math()) + .build(); + + CelAbstractSyntaxTree ast = celCompiler.compile(expr).getAst(); + UnsignedLong result = (UnsignedLong) celRuntime.createProgram(ast).eval(); + + assertThat(result).isEqualTo(UnsignedLong.valueOf(expectedResult)); + } + + @Test + public void least_noArgs_throwsCompilationException() { + Assume.assumeFalse(isParseOnly); + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile("math.least()").getAst()); + + assertThat(e).hasMessageThat().contains("math.least() requires at least one argument"); + } + + @Test + @TestParameters("{expr: 'math.least(''test'')'}") + @TestParameters("{expr: 'math.least({})'}") + @TestParameters("{expr: 'math.least([])'}") + public void least_invalidSingleArg_throwsCompilationException(String expr) { + Assume.assumeFalse(isParseOnly); + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("math.least() invalid single argument value"); + } + + @Test + @TestParameters("{expr: 'math.least(1, true)'}") + @TestParameters("{expr: 'math.least(1, 2, ''test'')'}") + @TestParameters("{expr: 'math.least([1, false])'}") + @TestParameters("{expr: 'math.least([1, 2, true])'}") + @TestParameters("{expr: 'math.least([1, {}, 2])'}") + @TestParameters("{expr: 'math.least([1, [], 2])'}") + public void least_invalidArgs_throwsCompilationException(String expr) { + Assume.assumeFalse(isParseOnly); + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e) + .hasMessageThat() + .contains("math.least() simple literal arguments must be numeric"); + } + + @Test + @TestParameters("{expr: 'math.least(1, 2, dyn(''test''))'}") + @TestParameters("{expr: 'math.least([1, dyn(false)])'}") + @TestParameters("{expr: 'math.least([1, 2, dyn(true)])'}") + @TestParameters("{expr: 'math.least([1, dyn({}), 2])'}") + @TestParameters("{expr: 'math.least([1, dyn([]), 2])'}") + public void least_invalidDynArgs_throwsRuntimeException(String expr) throws Exception { + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> eval(expr)); + + assertThat(e).hasMessageThat().contains("failed with arg(s)"); + } + + @Test + public void least_listVariableIsEmpty_throwsRuntimeException() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries(CelExtensions.math()) + .addVar("listVar", ListType.create(SimpleType.INT)) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("math.least(listVar)").getAst(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> cel.createProgram(ast).eval(ImmutableMap.of("listVar", ImmutableList.of()))); + + assertThat(e).hasMessageThat().contains("failed with arg(s)"); + assertThat(e) + .hasCauseThat() + .hasMessageThat() + .contains("math.@min(list) argument must not be empty"); + } + + @Test + @TestParameters("{expr: '100.least(1) == 1'}") + @TestParameters("{expr: 'dyn(100).least(1) == 1'}") + public void least_nonMathNamespace_success(String expr) throws Exception { + Cel cel = + runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.math()) + .addRuntimeLibraries(CelExtensions.math()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "least", + CelOverloadDecl.newMemberOverload( + "int_least", SimpleType.INT, SimpleType.INT, SimpleType.INT))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "least", + CelFunctionBinding.from( + "int_least", Long.class, Long.class, (arg1, arg2) -> arg2))) + .build(); + + boolean result = (boolean) eval(cel, expr); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expr: 'math.isNaN(0.0/0.0)', expectedResult: true}") + @TestParameters("{expr: 'math.isNaN(1.0/1.0)', expectedResult: false}") + @TestParameters("{expr: 'math.isNaN(12.031)', expectedResult: false}") + @TestParameters("{expr: 'math.isNaN(-1.0/0.0)', expectedResult: false}") + @TestParameters("{expr: 'math.isNaN(math.round(0.0/0.0))', expectedResult: true}") + @TestParameters("{expr: 'math.isNaN(math.sign(0.0/0.0))', expectedResult: true}") + @TestParameters("{expr: 'math.isNaN(math.sqrt(-4))', expectedResult: true}") + public void isNaN_success(String expr, boolean expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.isNaN()'}") + @TestParameters("{expr: 'math.isNaN(1)'}") + @TestParameters("{expr: 'math.isNaN(9223372036854775807)'}") + @TestParameters("{expr: 'math.isNaN(1u)'}") + public void isNaN_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.isNaN'"); + } + + @Test + @TestParameters("{expr: 'math.isFinite(1.0/1.5)', expectedResult: true}") + @TestParameters("{expr: 'math.isFinite(15312.2121)', expectedResult: true}") + @TestParameters("{expr: 'math.isFinite(1.0/0.0)', expectedResult: false}") + @TestParameters("{expr: 'math.isFinite(0.0/0.0)', expectedResult: false}") + public void isFinite_success(String expr, boolean expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.isFinite()'}") + @TestParameters("{expr: 'math.isFinite(1)'}") + @TestParameters("{expr: 'math.isFinite(9223372036854775807)'}") + @TestParameters("{expr: 'math.isFinite(1u)'}") + public void isFinite_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.isFinite'"); + } + + @Test + @TestParameters("{expr: 'math.isInf(1.0/0.0)', expectedResult: true}") + @TestParameters("{expr: 'math.isInf(-1.0/0.0)', expectedResult: true}") + @TestParameters("{expr: 'math.isInf(0.0/0.0)', expectedResult: false}") + @TestParameters("{expr: 'math.isInf(10.0)', expectedResult: false}") + public void isInf_success(String expr, boolean expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.isInf()'}") + @TestParameters("{expr: 'math.isInf(1)'}") + @TestParameters("{expr: 'math.isInf(9223372036854775807)'}") + @TestParameters("{expr: 'math.isInf(1u)'}") + public void isInf_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.isInf'"); + } + + @Test + @TestParameters("{expr: 'math.ceil(1.2)' , expectedResult: 2.0}") + @TestParameters("{expr: 'math.ceil(54.78)' , expectedResult: 55.0}") + @TestParameters("{expr: 'math.ceil(-2.2)' , expectedResult: -2.0}") + @TestParameters("{expr: 'math.ceil(20.0)' , expectedResult: 20.0}") + @TestParameters("{expr: 'math.ceil(0.0/0.0)' , expectedResult: NaN}") + public void ceil_success(String expr, double expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.ceil()'}") + @TestParameters("{expr: 'math.ceil(1)'}") + @TestParameters("{expr: 'math.ceil(9223372036854775807)'}") + @TestParameters("{expr: 'math.ceil(1u)'}") + public void ceil_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.ceil'"); + } + + @Test + @TestParameters("{expr: 'math.floor(1.2)' , expectedResult: 1.0}") + @TestParameters("{expr: 'math.floor(-5.2)' , expectedResult: -6.0}") + @TestParameters("{expr: 'math.floor(0.0/0.0)' , expectedResult: NaN}") + @TestParameters("{expr: 'math.floor(50.0)' , expectedResult: 50.0}") + public void floor_success(String expr, double expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.floor()'}") + @TestParameters("{expr: 'math.floor(1)'}") + @TestParameters("{expr: 'math.floor(9223372036854775807)'}") + @TestParameters("{expr: 'math.floor(1u)'}") + public void floor_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.floor'"); + } + + @Test + @TestParameters("{expr: 'math.round(1.2)' , expectedResult: 1.0}") + @TestParameters("{expr: 'math.round(1.5)' , expectedResult: 2.0}") + @TestParameters("{expr: 'math.round(-1.5)' , expectedResult: -2.0}") + @TestParameters("{expr: 'math.round(-1.2)' , expectedResult: -1.0}") + @TestParameters("{expr: 'math.round(-1.6)' , expectedResult: -2.0}") + // Discriminating tie cases: confirm "ties round away from zero" (HALF_UP), not + // banker's rounding (HALF_EVEN). 1.5/-1.5 above don't distingish the two because + // their nearest-even neighbor (2/-2) is also the away-from-zero neighbor. + @TestParameters("{expr: 'math.round(0.5)' , expectedResult: 1.0}") + @TestParameters("{expr: 'math.round(2.5)' , expectedResult: 3.0}") + @TestParameters("{expr: 'math.round(-0.5)' , expectedResult: -1.0}") + @TestParameters("{expr: 'math.round(-2.5)' , expectedResult: -3.0}") + @TestParameters("{expr: 'math.round(0.0/0.0)' , expectedResult: NaN}") + @TestParameters("{expr: 'math.round(1.0/0.0)' , expectedResult: Infinity}") + @TestParameters("{expr: 'math.round(-1.0/0.0)' , expectedResult: -Infinity}") + public void round_success(String expr, double expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.round()'}") + @TestParameters("{expr: 'math.round(1)'}") + @TestParameters("{expr: 'math.round(9223372036854775807)'}") + @TestParameters("{expr: 'math.round(1u)'}") + public void round_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.round'"); + } + + @Test + @TestParameters("{expr: 'math.trunc(-1.3)' , expectedResult: -1.0}") + @TestParameters("{expr: 'math.trunc(1.3)' , expectedResult: 1.0}") + @TestParameters("{expr: 'math.trunc(0.0/0.0)' , expectedResult: NaN}") + @TestParameters("{expr: 'math.trunc(1.0/0.0)' , expectedResult: Infinity}") + @TestParameters("{expr: 'math.trunc(-1.0/0.0)' , expectedResult: -Infinity}") + public void trunc_success(String expr, double expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.trunc()'}") + @TestParameters("{expr: 'math.trunc(1)'}") + @TestParameters("{expr: 'math.trunc()'}") + @TestParameters("{expr: 'math.trunc(1u)'}") + public void trunc_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.trunc'"); + } + + @Test + @TestParameters("{expr: 'math.abs(1)', expectedResult: 1}") + @TestParameters("{expr: 'math.abs(-1657643)', expectedResult: 1657643}") + @TestParameters("{expr: 'math.abs(-2147483648)', expectedResult: 2147483648}") + public void abs_intResult_success(String expr, long expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.abs(-234.5)' , expectedResult: 234.5}") + @TestParameters("{expr: 'math.abs(234.5)' , expectedResult: 234.5}") + @TestParameters("{expr: 'math.abs(0.0/0.0)' , expectedResult: NaN}") + @TestParameters("{expr: 'math.abs(-0.0/0.0)' , expectedResult: NaN}") + @TestParameters("{expr: 'math.abs(1.0/0.0)' , expectedResult: Infinity}") + @TestParameters("{expr: 'math.abs(-1.0/0.0)' , expectedResult: Infinity}") + public void abs_doubleResult_success(String expr, double expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + public void abs_overflow_throwsException() { + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> cel.compile("math.abs(-9223372036854775809)").getAst()); + + assertThat(e) + .hasMessageThat() + .contains("ERROR: :1:10: For input string: \"-9223372036854775809\""); + } + + @Test + @TestParameters("{expr: 'math.sign(-100)', expectedResult: -1}") + @TestParameters("{expr: 'math.sign(0)', expectedResult: 0}") + @TestParameters("{expr: 'math.sign(-0)', expectedResult: 0}") + @TestParameters("{expr: 'math.sign(11213)', expectedResult: 1}") + public void sign_intResult_success(String expr, int expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.sign(-234.5)' , expectedResult: -1.0}") + @TestParameters("{expr: 'math.sign(234.5)' , expectedResult: 1.0}") + @TestParameters("{expr: 'math.sign(0.2321)' , expectedResult: 1.0}") + @TestParameters("{expr: 'math.sign(0.0)' , expectedResult: 0.0}") + @TestParameters("{expr: 'math.sign(-0.0)' , expectedResult: 0.0}") + @TestParameters("{expr: 'math.sign(0.0/0.0)' , expectedResult: NaN}") + @TestParameters("{expr: 'math.sign(-0.0/0.0)' , expectedResult: NaN}") + @TestParameters("{expr: 'math.sign(1.0/0.0)' , expectedResult: 1.0}") + @TestParameters("{expr: 'math.sign(-1.0/0.0)' , expectedResult: -1.0}") + public void sign_doubleResult_success(String expr, double expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.sign()'}") + @TestParameters("{expr: 'math.sign(\"\")'}") + public void sign_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.sign'"); + } + + @Test + @TestParameters("{expr: 'math.bitAnd(1,2)' , expectedResult: 0}") + @TestParameters("{expr: 'math.bitAnd(1,-1)' , expectedResult: 1}") + @TestParameters( + "{expr: 'math.bitAnd(9223372036854775807,9223372036854775807)' , expectedResult:" + + " 9223372036854775807}") + public void bitAnd_signedInt_success(String expr, long expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitAnd(1u,2u)' , expectedResult: 0}") + @TestParameters("{expr: 'math.bitAnd(1u,3u)' , expectedResult: 1}") + public void bitAnd_unSignedInt_success(String expr, UnsignedLong expectedResult) + throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitAnd()'}") + @TestParameters("{expr: 'math.bitAnd(1u, 1)'}") + @TestParameters("{expr: 'math.bitAnd(1)'}") + public void bitAnd_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.bitAnd'"); + } + + @Test + public void bitAnd_maxValArg_throwsException() { + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> cel.compile("math.bitAnd(9223372036854775807,9223372036854775809)").getAst()); + + assertThat(e) + .hasMessageThat() + .contains("ERROR: :1:33: For input string: \"9223372036854775809\""); + } + + @Test + @TestParameters("{expr: 'math.bitOr(1,2)' , expectedResult: 3}") + @TestParameters("{expr: 'math.bitOr(1,-1)' , expectedResult: -1}") + public void bitOr_signedInt_success(String expr, long expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitOr(1u,2u)' , expectedResult: 3}") + @TestParameters("{expr: 'math.bitOr(1090u,3u)' , expectedResult: 1091}") + public void bitOr_unSignedInt_success(String expr, UnsignedLong expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitOr()'}") + @TestParameters("{expr: 'math.bitOr(1u, 1)'}") + @TestParameters("{expr: 'math.bitOr(1)'}") + public void bitOr_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.bitOr'"); + } + + @Test + @TestParameters("{expr: 'math.bitXor(1,2)' , expectedResult: 3}") + @TestParameters("{expr: 'math.bitXor(3,5)' , expectedResult: 6}") + public void bitXor_signedInt_success(String expr, long expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitXor(1u, 3u)' , expectedResult: 2}") + @TestParameters("{expr: 'math.bitXor(3u, 5u)' , expectedResult: 6}") + public void bitXor_unSignedInt_success(String expr, UnsignedLong expectedResult) + throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitXor()'}") + @TestParameters("{expr: 'math.bitXor(1u, 1)'}") + @TestParameters("{expr: 'math.bitXor(1)'}") + public void bitXor_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.bitXor'"); + } + + @Test + @TestParameters("{expr: 'math.bitNot(1)' , expectedResult: -2}") + @TestParameters("{expr: 'math.bitNot(0)' , expectedResult: -1}") + @TestParameters("{expr: 'math.bitNot(-1)' , expectedResult: 0}") + public void bitNot_signedInt_success(String expr, long expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitNot(1u)' , expectedResult: 18446744073709551614}") + @TestParameters("{expr: 'math.bitNot(12310u)' , expectedResult: 18446744073709539305}") + public void bitNot_unSignedInt_success(String expr, UnsignedLong expectedResult) + throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitNot()'}") + @TestParameters("{expr: 'math.bitNot(1u, 1)'}") + @TestParameters("{expr: 'math.bitNot(\"\")'}") + public void bitNot_invalidArgs_throwsException(String expr) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.compile(expr).getAst()); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'math.bitNot'"); + } + + @Test + @TestParameters("{expr: 'math.bitShiftLeft(1, 2)' , expectedResult: 4}") + @TestParameters("{expr: 'math.bitShiftLeft(12121, 11)' , expectedResult: 24823808}") + @TestParameters("{expr: 'math.bitShiftLeft(-1, 64)' , expectedResult: 0}") + public void bitShiftLeft_signedInt_success(String expr, long expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitShiftLeft(1u, 2)' , expectedResult: 4}") + @TestParameters("{expr: 'math.bitShiftLeft(2147483648u, 22)' , expectedResult: 9007199254740992}") + @TestParameters("{expr: 'math.bitShiftLeft(1u, 65)' , expectedResult: 0}") + public void bitShiftLeft_unSignedInt_success(String expr, UnsignedLong expectedResult) + throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitShiftLeft(1, -2)'}") + @TestParameters("{expr: 'math.bitShiftLeft(1u, -2)'}") + public void bitShiftLeft_invalidArgs_throwsException(String expr) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + + assertThat(e).hasMessageThat().contains("evaluation error"); + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e).hasCauseThat().hasMessageThat().contains("math.bitShiftLeft() negative offset"); + } + + @Test + @TestParameters( + "{expr: 'math.bitShiftRight(9223372036854775807, 12)' , expectedResult: 2251799813685247}") + @TestParameters("{expr: 'math.bitShiftRight(12121, 11)' , expectedResult: 5}") + @TestParameters("{expr: 'math.bitShiftRight(-1, 64)' , expectedResult: 0}") + public void bitShiftRight_signedInt_success(String expr, long expectedResult) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitShiftRight(23111u, 12)' , expectedResult: 5}") + @TestParameters("{expr: 'math.bitShiftRight(2147483648u, 22)' , expectedResult: 512}") + @TestParameters("{expr: 'math.bitShiftRight(1u, 65)' , expectedResult: 0}") + public void bitShiftRight_unSignedInt_success(String expr, UnsignedLong expectedResult) + throws Exception { + Object result = eval(expr); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expr: 'math.bitShiftRight(23111u, -212)'}") + @TestParameters("{expr: 'math.bitShiftRight(23, -212)'}") + public void bitShiftRight_invalidArgs_throwsException(String expr) throws Exception { + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> eval(expr)); + + assertThat(e).hasMessageThat().contains("evaluation error"); + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e).hasCauseThat().hasMessageThat().contains("math.bitShiftRight() negative offset"); + } + + @Test + @TestParameters("{expr: 'math.sqrt(49.0)', expectedResult: 7.0}") + @TestParameters("{expr: 'math.sqrt(82)', expectedResult: 9.055385138137417}") + @TestParameters("{expr: 'math.sqrt(25u)', expectedResult: 5.0}") + @TestParameters("{expr: 'math.sqrt(0.0/0.0)', expectedResult: NaN}") + @TestParameters("{expr: 'math.sqrt(1.0/0.0)', expectedResult: Infinity}") + @TestParameters("{expr: 'math.sqrt(-1)', expectedResult: NaN}") + public void sqrt_success(String expr, double expectedResult) throws Exception { + Object result = eval(expr); + + assertThat(result).isEqualTo(expectedResult); + } + + private Object eval(Cel cel, String expression, Map variables) throws Exception { + CelAbstractSyntaxTree ast; + if (isParseOnly) { + ast = cel.parse(expression).getAst(); + } else { + ast = cel.compile(expression).getAst(); + } + return cel.createProgram(ast).eval(variables); + } + + private Object eval(Cel celInstance, String expression) throws Exception { + return eval(celInstance, expression, ImmutableMap.of()); + } + + private Object eval(String expression) throws Exception { + return eval(this.cel, expression, ImmutableMap.of()); + } +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelNativeTypesExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelNativeTypesExtensionsTest.java new file mode 100644 index 000000000..0b378f0d7 --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelNativeTypesExtensionsTest.java @@ -0,0 +1,1473 @@ +// 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +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.CelContainer; +import dev.cel.common.CelValidationException; +import dev.cel.common.exceptions.CelAttributeNotFoundException; +import dev.cel.common.exceptions.CelInvalidArgumentException; +import dev.cel.common.types.CelType; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.CelValueProvider; +import dev.cel.common.values.StructValue; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import java.time.Duration; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelNativeTypesExtensionsTest { + + @TestParameter boolean isParseOnly; + + private static final CelNativeTypesExtensions NATIVE_TYPE_EXTENSIONS = + CelExtensions.nativeTypes( + TestAllTypesPublicFieldsPojo.class, + TestPrivateConstructorPojo.class, + ComprehensiveTestAllTypes.class, + TestGetterSetterPojo.class, + TestMissingNoArgConstructorPojo.class, + TestPrivateFieldPojo.class, + TestDeepConversionPojo.class, + TestPrecedencePojo.class, + TestPrefixLessGetterPojo.class, + TestChildPojo.class, + TestPackagePrivatePojo.class, + TestPackagePrivateWithGetterPojo.class, + TestWildcardPojo.class, + ComprehensiveTestNestedType.class, + TestNestedSliceType.class, + TestMapVal.class, + TestCustomCollectionPojo.class, + TestNestedGenericsPojo.class, + TestNestedSimplePojo.class, + TestGetterFieldTypeMismatchPojo.class, + TestAbstractPojo.class, + TestURLPojo.class, + PojoWithEnum.class, + TestArrayPojo.class); + + private static final Cel CEL = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addCompilerLibraries(NATIVE_TYPE_EXTENSIONS) + .addRuntimeLibraries(NATIVE_TYPE_EXTENSIONS) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + + private Object eval(String expr) throws Exception { + return eval(expr, ImmutableMap.of()); + } + + private Object eval(String expr, Map variables) throws Exception { + CelAbstractSyntaxTree ast = isParseOnly ? CEL.parse(expr).getAst() : CEL.compile(expr).getAst(); + return CEL.createProgram(ast).eval(variables); + } + + @Test + public void nativeTypes_createStructAndSelect() throws Exception { + Object result = + eval( + "TestAllTypesPublicFieldsPojo{boolVal:" + + " true, stringVal: 'hello'}.stringVal == 'hello'"); + + assertThat(result).isEqualTo(true); + } + + @Test + public void nativeTypes_createNestedStruct() throws Exception { + Object result = + eval( + "TestAllTypesPublicFieldsPojo{nestedVal:" + + " TestNestedType{value:" + + " 'nested'}}.nestedVal.value == 'nested'"); + + assertThat(result).isEqualTo(true); + } + + @Test + public void nativeTypes_resolveVariableWithNestedField() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addVar( + "pojo", + StructTypeReference.create(TestAllTypesPublicFieldsPojo.class.getCanonicalName())) + .addCompilerLibraries(NATIVE_TYPE_EXTENSIONS) + .addRuntimeLibraries(NATIVE_TYPE_EXTENSIONS) + .build(); + CelAbstractSyntaxTree ast = + isParseOnly + ? cel.parse("pojo.nestedVal.value == 'nested'").getAst() + : cel.compile("pojo.nestedVal.value == 'nested'").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + TestAllTypesPublicFieldsPojo pojo = new TestAllTypesPublicFieldsPojo(); + TestNestedType nested = new TestNestedType(); + nested.value = "nested"; + pojo.nestedVal = nested; + + Object result = program.eval(ImmutableMap.of("pojo", pojo)); + + assertThat(result).isEqualTo(true); + } + + @Test + public void nativeTypes_createStructWithComplexTypes() throws Exception { + assertThat( + eval( + "TestAllTypesPublicFieldsPojo{" + + " durationVal: duration('5s')," + + " listVal: ['a', 'b']," + + " mapVal: {'key': 'value'}" + + "}.durationVal == duration('5s')")) + .isEqualTo(true); + } + + @Test + public void nativeTypes_transitiveDiscoveryThroughMap() throws Exception { + PojoWithCustomMap pojo = new PojoWithCustomMap(); + HashMap map = new HashMap<>(); + TestNestedType nested = new TestNestedType(); + nested.value = "hello"; + map.put("key", nested); + pojo.mapVal = map; + + CelNativeTypesExtensions extensions = + CelNativeTypesExtensions.nativeTypes(PojoWithCustomMap.class); + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addVar("pojo", StructTypeReference.create(PojoWithCustomMap.class.getCanonicalName())) + .addCompilerLibraries(extensions) + .addRuntimeLibraries(extensions) + .build(); + + CelAbstractSyntaxTree ast = cel.compile("pojo.mapVal['key'].value == 'hello'").getAst(); + Object result = cel.createProgram(ast).eval(ImmutableMap.of("pojo", pojo)); + + assertThat(result).isEqualTo(true); + } + + @Test + public void nativeTypes_createStructWithOptionalField() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addCompilerLibraries( + CelExtensions.nativeTypes(TestRefValFieldType.class), CelExtensions.optional()) + .addRuntimeLibraries( + CelExtensions.nativeTypes(TestRefValFieldType.class), CelExtensions.optional()) + .build(); + CelAbstractSyntaxTree ast = + cel.parse( + "TestRefValFieldType{optionalName: optional.of('my name')}.optionalName.orValue('')" + + " == 'my name'") + .getAst(); + CelRuntime.Program program = cel.createProgram(ast); + + Object result = program.eval(); + + assertThat(result).isEqualTo(true); + } + + @Test + public void nativeTypes_createComprehensiveStruct() throws Exception { + String expr = + "ComprehensiveTestAllTypes{\n" + + " nestedVal: ComprehensiveTestNestedType{nestedMapVal: {1: false}},\n" + + " boolVal: true,\n" + + " bytesVal: b'hello',\n" + + " durationVal: duration('5s'),\n" + + " doubleVal: 1.5,\n" + + " floatVal: 2.5,\n" + + " int32Val: 10,\n" + + " int64Val: 20,\n" + + " stringVal: 'hello world',\n" + + " timestampVal: timestamp('2011-08-06T01:23:45Z'),\n" + + " uint32Val: 100,\n" + + " uint64Val: 200,\n" + + " listVal: [\n" + + " ComprehensiveTestNestedType{\n" + + " nestedListVal:['goodbye', 'cruel', 'world'],\n" + + " nestedMapVal: {42: true},\n" + + " customName: 'name'\n" + + " }\n" + + " ],\n" + + " arrayVal: [\n" + + " ComprehensiveTestNestedType{\n" + + " nestedListVal:['goodbye', 'cruel', 'world'],\n" + + " nestedMapVal: {42: true},\n" + + " customName: 'name'\n" + + " }\n" + + " ],\n" + + " mapVal: {'map-key': ComprehensiveTestAllTypes{boolVal: true}},\n" + + " customSliceVal: [TestNestedSliceType{value: 'none'}],\n" + + " customMapVal: {'even': TestMapVal{value: 'more'}},\n" + + " customName: 'name'\n" + + "}"; + + CelAbstractSyntaxTree ast = CEL.parse(expr).getAst(); + CelRuntime.Program program = CEL.createProgram(ast); + Object result = program.eval(); + + // Construct expected output + ComprehensiveTestAllTypes expected = new ComprehensiveTestAllTypes(); + expected.boolVal = true; + expected.bytesVal = "hello".getBytes(UTF_8); + expected.durationVal = Duration.ofSeconds(5); + expected.doubleVal = 1.5; + expected.floatVal = 2.5f; + expected.int32Val = 10; + expected.int64Val = 20; + expected.stringVal = "hello world"; + expected.timestampVal = Instant.parse("2011-08-06T01:23:45Z"); + expected.uint32Val = 100; + expected.uint64Val = 200; + expected.customName = "name"; + + ComprehensiveTestNestedType nested1 = new ComprehensiveTestNestedType(); + nested1.nestedMapVal = ImmutableMap.of(1L, false); + expected.nestedVal = nested1; + + ComprehensiveTestNestedType nested2 = new ComprehensiveTestNestedType(); + nested2.nestedListVal = ImmutableList.of("goodbye", "cruel", "world"); + nested2.nestedMapVal = ImmutableMap.of(42L, true); + nested2.customName = "name"; + expected.listVal = ImmutableList.of(nested2); + expected.arrayVal = ImmutableList.of(nested2); + + ComprehensiveTestAllTypes mapValElement = new ComprehensiveTestAllTypes(); + mapValElement.boolVal = true; + expected.mapVal = ImmutableMap.of("map-key", mapValElement); + + TestNestedSliceType sliceElem = new TestNestedSliceType(); + sliceElem.value = "none"; + expected.customSliceVal = ImmutableList.of(sliceElem); + + TestMapVal mapValElem = new TestMapVal(); + mapValElem.value = "more"; + expected.customMapVal = ImmutableMap.of("even", mapValElem); + + assertThat(result).isEqualTo(expected); + } + + @Test + public void nativeTypes_staticErrors() throws Exception { + // undeclared reference + CelValidationException e = + assertThrows(CelValidationException.class, () -> CEL.compile("UnknownType{}").getAst()); + assertThat(e).hasMessageThat().contains("reference"); + + // undefined field + e = + assertThrows( + CelValidationException.class, + () -> CEL.compile("ComprehensiveTestAllTypes{undefinedField: true}").getAst()); + assertThat(e).hasMessageThat().contains("undefined field"); + } + + @Test + public void nativeTypes_anonymousClass_throwsException() { + Object anon = new Object() {}; + + Class clazz = anon.getClass(); + IllegalArgumentException exception = + assertThrows(IllegalArgumentException.class, () -> CelExtensions.nativeTypes(clazz)); + assertThat(exception).hasMessageThat().contains("Anonymous or local classes are not supported"); + } + + @Test + public void nativeTypes_createStruct_privateConstructor() throws Exception { + TestPrivateConstructorPojo result = + (TestPrivateConstructorPojo) eval("TestPrivateConstructorPojo{value:" + " 'hello'}"); + + assertThat(result.value).isEqualTo("hello"); + } + + @Test + public void nativeTypes_precedence_getterOverField() throws Exception { + assertThat(eval("TestPrecedencePojo{}.value")).isEqualTo("hello"); + } + + @Test + public void nativeTypes_protoPrecedence() throws Exception { + CelValueProvider customProvider = + (structType, fields) -> { + if (structType.equals("cel.expr.conformance.proto3.TestAllTypes")) { + return Optional.of("POJO_WINS"); + } + return Optional.empty(); + }; + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .setValueProvider(customProvider) + .addMessageTypes(TestAllTypes.getDescriptor()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("cel.expr.conformance.proto3.TestAllTypes{}").getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isNotEqualTo("POJO_WINS"); + assertThat(result).isInstanceOf(TestAllTypes.class); + } + + @Test + public void nativeTypes_createWithSetterAndSelectWithGetter() throws Exception { + assertThat(eval("TestGetterSetterPojo{value: 'hello', active: true}.value == 'hello'")) + .isEqualTo(true); + } + + @Test + public void nativeTypes_missingNoArgConstructor_throws() throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> eval("TestMissingNoArgConstructorPojo{value: 'hello'}")); + + assertThat(exception).hasMessageThat().contains("No public no-argument constructor found"); + } + + @Test + public void nativeTypes_createWithDeepConversion() throws Exception { + TestDeepConversionPojo pojo = + (TestDeepConversionPojo) + eval("TestDeepConversionPojo{ints: [1, 2], floats: {'a': 1.0, 'b': 2.0}}"); + assertThat(pojo.ints.get(0)).isEqualTo(1); + assertThat(pojo.floats).containsEntry("a", 1.0f); + } + + @Test + public void nativeTypes_wildcardList_success() throws Exception { + assertThat(eval("TestWildcardPojo{values: ['hello']}.values[0] == 'hello'")).isEqualTo(true); + } + + @Test + public void nativeTypes_unsupportedTypeSet_throwsOnRegistration() throws Exception { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> CelExtensions.nativeTypes(TestUnsupportedSetPojo.class)); + assertThat(e).hasMessageThat().contains("Unsupported type for property 'strings'"); + } + + @Test + public void nativeTypes_arrayType_construction() throws Exception { + String expr = + "TestArrayPojo{" + + " strings: ['a', 'b']," + + " ints: [1, 2]," + + " nesteds: [TestNestedType{value: 'nested'}]," + + " matrix: [[1, 2], [3, 4]]," + + " nestedMatrix: [[TestNestedType{value: 'm1'}], [TestNestedType{value: 'm2'}]]," + + " byteArrays: [b'foo', b'bar']" + + "}"; + + TestArrayPojo pojo = (TestArrayPojo) eval(expr); + + assertThat(pojo.strings).isEqualTo(new String[] {"a", "b"}); + assertThat(pojo.ints).isEqualTo(new int[] {1, 2}); + assertThat(pojo.nesteds).hasLength(1); + assertThat(pojo.nesteds[0].value).isEqualTo("nested"); + assertThat(pojo.matrix).hasLength(2); + assertThat(pojo.matrix[0]).isEqualTo(new int[] {1, 2}); + assertThat(pojo.matrix[1]).isEqualTo(new int[] {3, 4}); + assertThat(pojo.nestedMatrix).hasLength(2); + assertThat(pojo.nestedMatrix[0][0].value).isEqualTo("m1"); + assertThat(pojo.nestedMatrix[1][0].value).isEqualTo("m2"); + assertThat(pojo.byteArrays).hasLength(2); + assertThat(pojo.byteArrays[0]).isEqualTo("foo".getBytes(UTF_8)); + assertThat(pojo.byteArrays[1]).isEqualTo("bar".getBytes(UTF_8)); + } + + @Test + public void nativeTypes_arrayType_selection() throws Exception { + CelNativeTypesExtensions extensions = CelExtensions.nativeTypes(TestArrayPojo.class); + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addCompilerLibraries(extensions) + .addRuntimeLibraries(extensions) + .addVar("pojo", StructTypeReference.create(TestArrayPojo.class.getCanonicalName())) + .build(); + String expr = + "pojo.strings[1] == 'b'" + + " && pojo.ints[0] == 1" + + " && pojo.nesteds[0].value == 'nested'" + + " && pojo.matrix[1][0] == 3" + + " && pojo.nestedMatrix[1][0].value == 'm2'" + + " && pojo.byteArrays[1] == b'bar'"; + CelAbstractSyntaxTree ast = cel.compile(expr).getAst(); + CelRuntime.Program program = cel.createProgram(ast); + + TestArrayPojo input = new TestArrayPojo(); + input.strings = new String[] {"a", "b"}; + input.ints = new int[] {1, 2}; + TestNestedType nested = new TestNestedType(); + nested.value = "nested"; + input.nesteds = new TestNestedType[] {nested}; + input.matrix = new int[][] {{1, 2}, {3, 4}}; + TestNestedType m1 = new TestNestedType(); + m1.value = "m1"; + TestNestedType m2 = new TestNestedType(); + m2.value = "m2"; + input.nestedMatrix = new TestNestedType[][] {{m1}, {m2}}; + input.byteArrays = new byte[][] {"foo".getBytes(UTF_8), "bar".getBytes(UTF_8)}; + + assertThat(program.eval(ImmutableMap.of("pojo", input))).isEqualTo(true); + } + + @Test + public void nativeTypes_arrayWithNullElement_throws() throws Exception { + CelNativeTypesExtensions extensions = CelExtensions.nativeTypes(TestArrayPojo.class); + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addCompilerLibraries(extensions) + .addRuntimeLibraries(extensions) + .addVar("pojo", StructTypeReference.create(TestArrayPojo.class.getCanonicalName())) + .build(); + CelAbstractSyntaxTree ast = cel.compile("pojo.strings").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + + TestArrayPojo input = new TestArrayPojo(); + input.strings = new String[] {"a", null, "c"}; + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, () -> program.eval(ImmutableMap.of("pojo", input))); + assertThat(e).hasCauseThat().isInstanceOf(CelInvalidArgumentException.class); + assertThat(e).hasCauseThat().hasMessageThat().contains("Element at index 1 is null."); + } + + @Test + public void nativeTypes_packagePrivateClass_fieldAccess_success() throws Exception { + assertThat(eval("TestPackagePrivatePojo{value: 'hello'}.value == 'hello'")).isEqualTo(true); + } + + @Test + public void nativeTypes_packagePrivateClass_methodAccess_success() throws Exception { + assertThat(eval("TestPackagePrivateWithGetterPojo{value: 'hello'}.value == 'hello'")) + .isEqualTo(true); + } + + @Test + public void nativeTypes_privateField_notExposed() throws Exception { + CelNativeTypesExtensions extensions = CelExtensions.nativeTypes(TestPrivateFieldPojo.class); + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> compiler.compile("TestPrivateFieldPojo{secret: 'hello'}").getAst()); + assertThat(e).hasMessageThat().contains("undefined field"); + } + + @Test + public void nativeTypes_inheritance_success() throws Exception { + // Accessing child's prefix-less getter + assertThat(eval("TestChildPojo{}.childValue")).isEqualTo("child"); + // Accessing parent's standard getter + assertThat(eval("TestChildPojo{}.standardValue")).isEqualTo("standard"); + // Accessing parent's prefix-less getter + assertThat(eval("TestChildPojo{}.parentValue")).isEqualTo("parent"); + } + + @Test + public void nativeTypes_standardType_cannotBeConstructedAsStruct() throws Exception { + CelValidationException e = + assertThrows( + CelValidationException.class, () -> CEL.compile("java.lang.String{}").getAst()); + assertThat(e).hasMessageThat().contains("undeclared reference"); + } + + @Test + public void nativeTypes_doubleMapKey_throwsOnRegistration() throws Exception { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> CelExtensions.nativeTypes(TestDoubleMapKeyPojo.class)); + assertThat(e).hasCauseThat().hasMessageThat().contains("Decimals are not allowed as map keys"); + } + + @Test + public void nativeTypes_optionalCustomStruct_registered() throws Exception { + CelNativeTypesExtensions extensions = CelExtensions.nativeTypes(TestOptionalUrlPojo.class); + CelNativeTypesExtensions.NativeTypeRegistry registry = extensions.getRegistry(); + + Optional type = registry.findType(TestURLPojo.class.getCanonicalName()); + + assertThat(type).isPresent(); + } + + @Test + public void nativeTypes_abstractClass_throwsOnConstruction() throws Exception { + CelAbstractSyntaxTree ast = CEL.parse("TestAbstractPojo{}").getAst(); + CelRuntime.Program program = CEL.createProgram(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> program.eval()); + assertThat(e).hasMessageThat().contains("Failed to create instance of"); + assertThat(e).hasCauseThat().isInstanceOf(InstantiationException.class); + } + + @Test + public void nativeTypes_nestedList_registered() throws Exception { + CelNativeTypesExtensions extensions = + CelExtensions.nativeTypes(TestAllTypesPublicFieldsPojo.class); + CelNativeTypesExtensions.NativeTypeRegistry registry = extensions.getRegistry(); + + Optional type = + registry.findType(TestAllTypesPublicFieldsPojo.class.getCanonicalName()); + + assertThat(type).isPresent(); + StructType structType = (StructType) type.get(); + assertThat(structType.findField("nestedListVal")).isPresent(); + } + + @Test + public void nativeTypes_invalidGetters_notRegistered() throws Exception { + ImmutableSet properties = + CelNativeTypesExtensions.NativeTypeScanner.getProperties( + TestAllTypesPublicFieldsPojo.class); + + assertThat(properties).doesNotContain("invalidParam"); + assertThat(properties).doesNotContain("invalidString"); + } + + @Test + public void nativeTypes_celByteString_success() throws Exception { + assertThat(eval("TestAllTypesPublicFieldsPojo{}.celBytesVal" + " == b'\\x01\\x02\\x03'")) + .isEqualTo(true); + } + + @Test + public void nativeTypes_celByteString_construction_success() throws Exception { + assertThat( + eval( + "dev.cel.extensions.CelNativeTypesExtensionsTest.TestAllTypesPublicFieldsPojo{celBytesVal:" + + " b'\\x01\\x02\\x03'}.celBytesVal == b'\\x01\\x02\\x03'")) + .isEqualTo(true); + } + + @Test + public void nativeTypes_singleLetterGetter_success() throws Exception { + Object result = eval("TestAllTypesPublicFieldsPojo{}.a == 'a'"); + assertThat(result).isEqualTo(true); + } + + @Test + public void nativeTypes_getterNamedGet_rejected() throws Exception { + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> CEL.compile("TestAllTypesPublicFieldsPojo{}.get").getAst()); + assertThat(e).hasMessageThat().contains("undefined field 'get'"); + } + + @Test + public void nativeTypes_circularReference_success() throws Exception { + CelNativeTypesExtensions extensions = CelExtensions.nativeTypes(TestCircularA.class); + CelNativeTypesExtensions.NativeTypeRegistry registry = extensions.getRegistry(); + + Optional typeA = registry.findType(TestCircularA.class.getCanonicalName()); + Optional typeB = registry.findType(TestCircularB.class.getCanonicalName()); + + assertThat(typeA).isPresent(); + assertThat(typeB).isPresent(); + } + + @Test + public void nativeTypes_specialDecapitalization_success() throws Exception { + Object result = eval("dev.cel.extensions.CelNativeTypesExtensionsTest.TestURLPojo{}.URL"); + + assertThat(result).isEqualTo("https://google.com"); + } + + @Test + public void nativeTypes_prefixLessGetter_success() throws Exception { + CelNativeTypesExtensions extensions = CelExtensions.nativeTypes(TestPrefixLessGetterPojo.class); + CelRuntime celRuntime = + CelRuntimeFactory.plannerRuntimeBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + CelAbstractSyntaxTree valueAst = + celCompiler + .compile( + "dev.cel.extensions.CelNativeTypesExtensionsTest.TestPrefixLessGetterPojo{}.value") + .getAst(); + CelAbstractSyntaxTree nameAst = + celCompiler + .compile( + "dev.cel.extensions.CelNativeTypesExtensionsTest.TestPrefixLessGetterPojo{}.name") + .getAst(); + CelRuntime.Program valueProgram = celRuntime.createProgram(valueAst); + CelRuntime.Program nameProgram = celRuntime.createProgram(nameAst); + + Object valueResult = valueProgram.eval(); + Object nameResult = nameProgram.eval(); + + assertThat(valueResult).isEqualTo("hello"); + assertThat(nameResult).isEqualTo("my_name"); + } + + @Test + public void nativeTypes_isGetter_success() throws Exception { + CelNativeTypesExtensions extensions = CelExtensions.nativeTypes(TestGetterSetterPojo.class); + CelRuntime celRuntime = + CelRuntimeFactory.plannerRuntimeBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + CelAbstractSyntaxTree ast = + celCompiler + .compile( + "dev.cel.extensions.CelNativeTypesExtensionsTest.TestGetterSetterPojo{active:" + + " true}.active") + .getAst(); + CelRuntime.Program program = celRuntime.createProgram(ast); + + Object result = program.eval(); + + assertThat(result).isEqualTo(true); + } + + @Test + public void nativeTypes_selectUndefinedField_parsedOnly_throwsException() throws Exception { + + CelNativeTypesExtensions extensions = + CelExtensions.nativeTypes(TestAllTypesPublicFieldsPojo.class); + + CelRuntime celRuntime = + CelRuntimeFactory.plannerRuntimeBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + + CelAbstractSyntaxTree ast = celCompiler.parse("pojo.undefinedField").getAst(); + CelRuntime.Program program = celRuntime.createProgram(ast); + + TestAllTypesPublicFieldsPojo pojo = new TestAllTypesPublicFieldsPojo(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, () -> program.eval(ImmutableMap.of("pojo", pojo))); + assertThat(e).hasCauseThat().isInstanceOf(CelAttributeNotFoundException.class); + } + + @Test + public void nativeTypes_createWithUint_fromUnsignedLong() throws Exception { + CelNativeTypesExtensions extensions = + CelExtensions.nativeTypes(TestAllTypesPublicFieldsPojo.class); + CelRuntime celRuntime = + CelRuntimeFactory.plannerRuntimeBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + CelAbstractSyntaxTree ast = + celCompiler + .compile( + "dev.cel.extensions.CelNativeTypesExtensionsTest.TestAllTypesPublicFieldsPojo{uintVal:" + + " 42u}") + .getAst(); + CelRuntime.Program program = celRuntime.createProgram(ast); + + TestAllTypesPublicFieldsPojo pojo = (TestAllTypesPublicFieldsPojo) program.eval(); + assertThat(pojo.uintVal).isEqualTo(UnsignedLong.fromLongBits(42L)); + } + + @Test + public void nativeTypes_mapJavaTypeToCelType_allSupportedTypes() throws Exception { + CelNativeTypesExtensions extensions = + CelExtensions.nativeTypes(TestAllTypesPublicFieldsPojo.class); + CelNativeTypesExtensions.NativeTypeRegistry registry = extensions.getRegistry(); + + Optional type = + registry.findType(TestAllTypesPublicFieldsPojo.class.getCanonicalName()); + + assertThat(type).isPresent(); + assertThat(type.get()).isInstanceOf(StructType.class); + StructType structType = (StructType) type.get(); + + assertThat(structType.findField("boolVal").map(StructType.Field::type)) + .hasValue(SimpleType.BOOL); + assertThat(structType.findField("boolObjVal").map(StructType.Field::type)) + .hasValue(SimpleType.BOOL); + assertThat(structType.findField("int32Val").map(StructType.Field::type)) + .hasValue(SimpleType.INT); + assertThat(structType.findField("intObjVal").map(StructType.Field::type)) + .hasValue(SimpleType.INT); + assertThat(structType.findField("int64Val").map(StructType.Field::type)) + .hasValue(SimpleType.INT); + assertThat(structType.findField("longObjVal").map(StructType.Field::type)) + .hasValue(SimpleType.INT); + assertThat(structType.findField("uintVal").map(StructType.Field::type)) + .hasValue(SimpleType.UINT); + assertThat(structType.findField("floatVal").map(StructType.Field::type)) + .hasValue(SimpleType.DOUBLE); + assertThat(structType.findField("floatObjVal").map(StructType.Field::type)) + .hasValue(SimpleType.DOUBLE); + assertThat(structType.findField("doubleVal").map(StructType.Field::type)) + .hasValue(SimpleType.DOUBLE); + assertThat(structType.findField("doubleObjVal").map(StructType.Field::type)) + .hasValue(SimpleType.DOUBLE); + assertThat(structType.findField("stringVal").map(StructType.Field::type)) + .hasValue(SimpleType.STRING); + assertThat(structType.findField("bytesVal").map(StructType.Field::type)) + .hasValue(SimpleType.BYTES); + assertThat(structType.findField("durationVal").map(StructType.Field::type)) + .hasValue(SimpleType.DURATION); + assertThat(structType.findField("timestampVal").map(StructType.Field::type)) + .hasValue(SimpleType.TIMESTAMP); + + assertThat(structType.findField("listVal").map(StructType.Field::type).get()) + .isInstanceOf(ListType.class); + ListType listType = + (ListType) structType.findField("listVal").map(StructType.Field::type).get(); + assertThat(listType.elemType()).isEqualTo(SimpleType.STRING); + + assertThat(structType.findField("mapIntVal").map(StructType.Field::type).get()) + .isInstanceOf(MapType.class); + MapType mapType = (MapType) structType.findField("mapIntVal").map(StructType.Field::type).get(); + assertThat(mapType.keyType()).isEqualTo(SimpleType.STRING); + assertThat(mapType.valueType()).isEqualTo(SimpleType.INT); + + assertThat(structType.findField("optionalVal").map(StructType.Field::type).get()) + .isInstanceOf(OptionalType.class); + OptionalType optionalType = + (OptionalType) structType.findField("optionalVal").map(StructType.Field::type).get(); + assertThat(optionalType.parameters().get(0)).isEqualTo(SimpleType.STRING); + } + + @Test + public void nativeTypes_mapJavaTypeToCelType_customCollectionSubclasses() throws Exception { + CelNativeTypesExtensions extensions = CelExtensions.nativeTypes(TestCustomCollectionPojo.class); + CelNativeTypesExtensions.NativeTypeRegistry registry = extensions.getRegistry(); + + Optional type = registry.findType(TestCustomCollectionPojo.class.getCanonicalName()); + StructType structType = (StructType) type.get(); + + assertThat(structType.findField("customList").map(StructType.Field::type)) + .hasValue(ListType.create(SimpleType.STRING)); + assertThat(structType.findField("customMap").map(StructType.Field::type)) + .hasValue(MapType.create(SimpleType.STRING, SimpleType.INT)); + } + + @Test + public void nativeTypes_objectMethods_notExposed() throws Exception { + CelNativeTypesExtensions extensions = + CelExtensions.nativeTypes(TestAllTypesPublicFieldsPojo.class); + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addLibraries(extensions) + .build(); + + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> compiler.compile("TestAllTypesPublicFieldsPojo{}.toString").getAst()); + assertThat(e).hasMessageThat().contains("undefined field"); + } + + @Test + public void nativeTypes_nullSafeTraversal() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addCompilerLibraries(NATIVE_TYPE_EXTENSIONS) + .addRuntimeLibraries(NATIVE_TYPE_EXTENSIONS) + .addVar( + "pojo", + StructTypeReference.create(TestAllTypesPublicFieldsPojo.class.getCanonicalName())) + .build(); + + TestAllTypesPublicFieldsPojo pojo = new TestAllTypesPublicFieldsPojo(); + ImmutableMap vars = ImmutableMap.of("pojo", pojo); + + assertThat(cel.createProgram(cel.compile("pojo.stringVal").getAst()).eval(vars)).isEqualTo(""); + assertThat(cel.createProgram(cel.compile("pojo.int64Val").getAst()).eval(vars)).isEqualTo(0L); + assertThat(cel.createProgram(cel.compile("pojo.nestedVal.value").getAst()).eval(vars)) + .isEqualTo(""); + assertThat(cel.createProgram(cel.compile("size(pojo.arrayVal) == 0").getAst()).eval(vars)) + .isEqualTo(true); + CelAbstractSyntaxTree abstractPojoAst = cel.compile("pojo.abstractPojo.value").getAst(); + CelRuntime.Program abstractPojoProgram = cel.createProgram(abstractPojoAst); + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> abstractPojoProgram.eval(vars)); + assertThat(e).hasMessageThat().contains("Failed to instantiate default instance"); + } + + @Test + public void nativeTypes_presenceTest() throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addCompilerLibraries(NATIVE_TYPE_EXTENSIONS) + .addRuntimeLibraries(NATIVE_TYPE_EXTENSIONS) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addVar( + "pojo", + StructTypeReference.create(TestAllTypesPublicFieldsPojo.class.getCanonicalName())) + .build(); + + TestAllTypesPublicFieldsPojo pojo = new TestAllTypesPublicFieldsPojo(); + ImmutableMap nullVars = ImmutableMap.of("pojo", pojo); + + TestAllTypesPublicFieldsPojo pojoWithValues = new TestAllTypesPublicFieldsPojo(); + pojoWithValues.stringVal = "hello"; + ImmutableMap valueVars = ImmutableMap.of("pojo", pojoWithValues); + + boolean hasPopulatedString = + (boolean) cel.createProgram(cel.compile("has(pojo.stringVal)").getAst()).eval(valueVars); + assertThat(hasPopulatedString).isTrue(); + + boolean hasNullString = + (boolean) cel.createProgram(cel.compile("has(pojo.stringVal)").getAst()).eval(nullVars); + assertThat(hasNullString).isFalse(); + + assertThrows( + CelValidationException.class, () -> cel.compile("has(pojo.nonExistentField)").getAst()); + } + + @Test + public void nativeTypes_zeroValue_collections_comprehensions() throws Exception { + assertThat(eval("TestAllTypesPublicFieldsPojo{}.listVal.filter(x, true) == []")) + .isEqualTo(true); + assertThat(eval("TestAllTypesPublicFieldsPojo{}.listVal.map(x, x + 'foo') == []")) + .isEqualTo(true); + assertThat(eval("TestAllTypesPublicFieldsPojo{}.listVal.exists(x, true)")).isEqualTo(false); + assertThat(eval("TestAllTypesPublicFieldsPojo{}.listVal.all(x, true)")).isEqualTo(true); + assertThat(eval("TestAllTypesPublicFieldsPojo{}.mapVal.exists(k, true)")).isEqualTo(false); + assertThat(eval("TestAllTypesPublicFieldsPojo{}.mapVal.all(k, true)")).isEqualTo(true); + } + + @Test + public void nativeTypes_customStructValue_optionalOfNonZeroValue() throws Exception { + CelNativeTypesExtensions extensions = + CelExtensions.nativeTypes(TestCustomStructValuePojo.class); + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addCompilerLibraries(extensions, CelExtensions.optional()) + .addRuntimeLibraries(extensions, CelExtensions.optional()) + .addVar( + "pojo", + StructTypeReference.create(TestCustomStructValuePojo.class.getCanonicalName())) + .build(); + + TestCustomStructValuePojo emptyPojo = + new TestCustomStructValuePojo(ImmutableMap.of("value", "")); + ImmutableMap emptyVars = ImmutableMap.of("pojo", emptyPojo); + boolean isEmptyNone = + (boolean) + cel.createProgram(cel.compile("!optional.ofNonZeroValue(pojo).hasValue()").getAst()) + .eval(emptyVars); + assertThat(isEmptyNone).isTrue(); + + TestCustomStructValuePojo populatedPojo = + new TestCustomStructValuePojo(ImmutableMap.of("value", "hello")); + ImmutableMap populatedVars = ImmutableMap.of("pojo", populatedPojo); + boolean isPopulatedPresent = + (boolean) + cel.createProgram(cel.compile("optional.ofNonZeroValue(pojo).hasValue()").getAst()) + .eval(populatedVars); + assertThat(isPopulatedPresent).isTrue(); + } + + @Test + public void nativeTypes_staticMembers_skipped() throws Exception { + ImmutableSet properties = + CelNativeTypesExtensions.NativeTypeScanner.getProperties(TestStaticMembersPojo.class); + + assertThat(properties).contains("instanceField"); + assertThat(properties).doesNotContain("STATIC_FIELD"); + assertThat(properties).doesNotContain("staticGetter"); + assertThat(properties).doesNotContain("staticProperty"); + } + + @Test + public void nativeTypes_deeplyNestedGenerics_discovered() throws Exception { + CelNativeTypesExtensions extensions = CelExtensions.nativeTypes(TestNestedGenericsPojo.class); + Cel cel = + CelFactory.plannerCelBuilder() + .setContainer(CelContainer.ofName("dev.cel.extensions.CelNativeTypesExtensionsTest")) + .addCompilerLibraries(extensions) + .addRuntimeLibraries(extensions) + .addVar( + "pojo", StructTypeReference.create(TestNestedGenericsPojo.class.getCanonicalName())) + .build(); + + TestNestedSimplePojo simplePojo = new TestNestedSimplePojo(); + TestNestedGenericsPojo pojo = new TestNestedGenericsPojo(); + pojo.nestedList = ImmutableList.of(ImmutableList.of(simplePojo)); + + boolean result = + (boolean) + cel.createProgram(cel.compile("pojo.nestedList[0][0].value == 'nested'").getAst()) + .eval(ImmutableMap.of("pojo", pojo)); + + assertThat(result).isTrue(); + } + + @Test + public void nativeTypes_concreteCollectionInstantiation_success() throws Exception { + TestCustomCollectionPojo result = + (TestCustomCollectionPojo) + eval("TestCustomCollectionPojo{customList: ['a', 'b'], customMap: {'key': 1}}"); + + assertThat(result).isNotNull(); + assertThat(result.customList).containsExactly("a", "b"); + assertThat(result.customMap).containsEntry("key", 1L); + } + + @Test + public void nativeTypes_getterFieldTypeMismatch_readOnly() throws Exception { + CelAbstractSyntaxTree ast = + CEL.compile("TestGetterFieldTypeMismatchPojo{mismatchField: 'hello'}").getAst(); + + CelRuntime.Program program = CEL.createProgram(ast); + CelEvaluationException exception = + assertThrows(CelEvaluationException.class, () -> program.eval(ImmutableMap.of())); + + assertThat(exception.getMessage()).contains("Failed to create instance"); + } + + public static class TestAllTypesPublicFieldsPojo { + public void doNothing() {} + + public String getA() { + return "a"; + } + + public String get() { + return "get"; + } + + public boolean boolVal; + public String stringVal; + public long int64Val; + public int int32Val; + public double doubleVal; + public float floatVal; + public byte[] bytesVal; + public String[] arrayVal; + public Duration durationVal; + public Instant timestampVal; + public TestNestedType nestedVal; + public List listVal; + public Map mapVal; + + public Boolean boolObjVal; + public Integer intObjVal; + public Long longObjVal; + public UnsignedLong uintVal; + public Float floatObjVal; + public Double doubleObjVal; + public Optional optionalVal; + public Optional optionalNestedVal; + public Map mapIntVal; + public List> nestedListVal; + public CelByteString celBytesVal = CelByteString.of(new byte[] {1, 2, 3}); + public TestAbstractPojo abstractPojo; + + public String getInvalidParam(String param) { + return "invalid"; + } + + public String isInvalidString() { + return "invalid"; + } + } + + public static class PojoWithCustomMap { + public Map mapVal; + } + + public static class TestNestedType { + public String value; + } + + static class TestPackagePrivatePojo { + public String value; + } + + static class TestPackagePrivateWithGetterPojo { + private String value; + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + } + + public static class TestPrivateConstructorPojo { + public String value; + + private TestPrivateConstructorPojo() { + this.value = "default"; + } + } + + public static class TestPrecedencePojo { + public int value = 1; + + public String getValue() { + return "hello"; + } + } + + static final class TestGetterSetterPojo { + private String value; + private boolean active; + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + public boolean isActive() { + return active; + } + + public void setActive(boolean active) { + this.active = active; + } + } + + public static final class TestUnsupportedSetPojo { + public Set strings; + } + + public static final class TestDeepConversionPojo { + public List ints; + public Map floats; + } + + public static final class TestMissingNoArgConstructorPojo { + public String value; + + public TestMissingNoArgConstructorPojo(String value) { + this.value = value; + } + } + + public static class TestRefValFieldType { + public Optional optionalName; + public int intVal; + public Instant time; + } + + public static class ComprehensiveTestNestedType { + public List nestedListVal; + public Map nestedMapVal; + public String customName; + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ComprehensiveTestNestedType)) { + return false; + } + ComprehensiveTestNestedType that = (ComprehensiveTestNestedType) o; + return Objects.equals(nestedListVal, that.nestedListVal) + && Objects.equals(nestedMapVal, that.nestedMapVal) + && Objects.equals(customName, that.customName); + } + + @Override + public int hashCode() { + return Objects.hash(nestedListVal, nestedMapVal, customName); + } + } + + public static class TestNestedSliceType { + public String value; + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof TestNestedSliceType)) { + return false; + } + TestNestedSliceType that = (TestNestedSliceType) o; + return Objects.equals(value, that.value); + } + + @Override + public int hashCode() { + return Objects.hashCode(value); + } + } + + public static class TestMapVal { + public String value; + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof TestMapVal)) { + return false; + } + TestMapVal that = (TestMapVal) o; + return Objects.equals(value, that.value); + } + + @Override + public int hashCode() { + return Objects.hashCode(value); + } + } + + public static class ComprehensiveTestAllTypes { + public ComprehensiveTestNestedType nestedVal; + public ComprehensiveTestNestedType nestedStructVal; + public boolean boolVal; + public byte[] bytesVal; + public Duration durationVal; + public double doubleVal; + public float floatVal; + public int int32Val; + public long int64Val; + public String stringVal; + public Instant timestampVal; + public long uint32Val; + public long uint64Val; + public List listVal; + public List arrayVal; + public byte[] bytesArrayVal; + public Map mapVal; + public List customSliceVal; + public Map customMapVal; + public String customName; + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ComprehensiveTestAllTypes)) { + return false; + } + ComprehensiveTestAllTypes that = (ComprehensiveTestAllTypes) o; + return boolVal == that.boolVal + && doubleVal == that.doubleVal + && floatVal == that.floatVal + && int32Val == that.int32Val + && int64Val == that.int64Val + && uint32Val == that.uint32Val + && uint64Val == that.uint64Val + && Objects.equals(nestedVal, that.nestedVal) + && Objects.equals(nestedStructVal, that.nestedStructVal) + && Arrays.equals(bytesVal, that.bytesVal) + && Objects.equals(durationVal, that.durationVal) + && Objects.equals(stringVal, that.stringVal) + && Objects.equals(timestampVal, that.timestampVal) + && Objects.equals(listVal, that.listVal) + && Objects.equals(arrayVal, that.arrayVal) + && Arrays.equals(bytesArrayVal, that.bytesArrayVal) + && Objects.equals(mapVal, that.mapVal) + && Objects.equals(customSliceVal, that.customSliceVal) + && Objects.equals(customMapVal, that.customMapVal) + && Objects.equals(customName, that.customName); + } + + @Override + public int hashCode() { + int result = + Objects.hash( + nestedVal, + nestedStructVal, + boolVal, + durationVal, + doubleVal, + floatVal, + int32Val, + int64Val, + stringVal, + timestampVal, + uint32Val, + uint64Val, + listVal, + arrayVal, + mapVal, + customSliceVal, + customMapVal, + customName); + result = 31 * result + Arrays.hashCode(bytesVal); + result = 31 * result + Arrays.hashCode(bytesArrayVal); + return result; + } + } + + public static final class TestPrivateFieldPojo { + // Intentionally unread to test private fields are not exposed + @SuppressWarnings("UnusedVariable") + private String secret; + } + + public static class TestPrefixLessGetterPojo { + private String value = "hello"; + private String name = "my_name"; + + public String value() { + return value; + } + + public String name() { + return name; + } + } + + public static class TestParentPojo { + private String parentValue = "parent"; + private String standardValue = "standard"; + + public String parentValue() { + return parentValue; + } + + public String getStandardValue() { + return standardValue; + } + } + + public static class TestChildPojo extends TestParentPojo { + private String childValue = "child"; + + public String childValue() { + return childValue; + } + } + + // Intentionally violating style guide to test special decapitalization. + @SuppressWarnings("IdentifierName") + public static class TestURLPojo { + public String getURL() { + return "https://google.com"; + } + } + + public static class TestDoubleMapKeyPojo { + public Map map; + } + + public static class TestWildcardPojo { + public List values; + } + + public static class TestArrayPojo { + public String[] strings; + public int[] ints; + public TestNestedType[] nesteds; + public int[][] matrix; + public TestNestedType[][] nestedMatrix; + public byte[][] byteArrays; + } + + public static class TestOptionalUrlPojo { + public Optional optionalUrl; + } + + public abstract static class TestAbstractPojo { + public String value; + } + + public static class TestCircularA { + public TestCircularB b; + } + + public static class TestCircularB { + public TestCircularA a; + } + + public static class CustomListImplementation extends ArrayList {} + + public static class CustomMapImplementation extends HashMap {} + + public static class TestCustomCollectionPojo { + public CustomListImplementation customList; + public CustomMapImplementation customMap; + } + + @SuppressWarnings("Immutable") + static final class TestCustomStructValuePojo extends StructValue { + private final ImmutableMap fields; + + public TestCustomStructValuePojo(ImmutableMap fields) { + this.fields = fields; + } + + @Override + public Object value() { + return this; + } + + @Override + public boolean isZeroValue() { + for (Object val : fields.values()) { + if (val != null && !val.equals("") && !val.equals(0L)) { + return false; + } + } + return true; + } + + @Override + public CelType celType() { + return StructTypeReference.create(TestCustomStructValuePojo.class.getCanonicalName()); + } + + @Override + public Optional find(String field) { + return Optional.ofNullable(fields.get(field)); + } + + @Override + public Object select(String field) { + Object val = fields.get(field); + if (val == null) { + throw new NoSuchElementException("Field not found: " + field); + } + return val; + } + } + + public static class TestStaticMembersPojo { + public static final String STATIC_FIELD = "static_value"; + + public static String getStaticGetter() { + return "static_getter_value"; + } + + public static String staticProperty() { + return "static_property_value"; + } + + public String instanceField = "instance_value"; + } + + public static class TestNestedGenericsPojo { + public List> nestedList; + public Map> nestedMap; + } + + public static class TestNestedSimplePojo { + public String value = "nested"; + } + + public static class TestGetterFieldTypeMismatchPojo { + public int mismatchField = 10; + + public String getMismatchField() { + return "mismatch"; + } + } + + public enum TestEnum { + FOO, + BAR; + } + + public static class PojoWithEnum { + private TestEnum enumVal = TestEnum.FOO; + + public TestEnum getEnumVal() { + return enumVal; + } + + public void setEnumVal(TestEnum val) { + this.enumVal = val; + } + } + + @Test + public void nativeTypes_enumSafelyIgnored() throws Exception { + assertThat(eval("PojoWithEnum{}.enumVal")).isNotNull(); + } + +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelOptionalLibraryTest.java b/extensions/src/test/java/dev/cel/extensions/CelOptionalLibraryTest.java new file mode 100644 index 000000000..2ba12910f --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelOptionalLibraryTest.java @@ -0,0 +1,1748 @@ +// Copyright 2023 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.DoubleValue; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelBuilder; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelVarDecl; +import dev.cel.common.types.CelType; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; +import dev.cel.compiler.CelCompiler; +import dev.cel.expr.conformance.proto3.NestedTestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedMessage; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelAttributePattern; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.InterpreterUtil; +import dev.cel.runtime.PartialVars; +import java.time.Duration; +import java.time.Instant; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +@SuppressWarnings({"unchecked", "SingleTestParameter"}) +public class CelOptionalLibraryTest { + + private enum TestMode { + PLANNER_PARSE_ONLY, + PLANNER_CHECKED, + LEGACY_CHECKED + } + + @TestParameter TestMode testMode; + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum ConstantTestCases { + INT("5", "0", SimpleType.INT, 5L), + STRING("'hello'", "''", SimpleType.STRING, "hello"), + DOUBLE("5.2", "0.0", SimpleType.DOUBLE, 5.2d), + UINT("5u", "0u", SimpleType.UINT, UnsignedLong.valueOf(5)), + BOOL("true", "false", SimpleType.BOOL, true), + BYTES("b'abc'", "b''", SimpleType.BYTES, CelByteString.copyFromUtf8("abc")), + DURATION("duration('180s')", "duration('0s')", SimpleType.DURATION, Duration.ofMinutes(3)), + TIMESTAMP( + "timestamp(1685552643)", + "timestamp(0)", + SimpleType.TIMESTAMP, + Instant.ofEpochSecond(1685552643)); + + private final String sourceWithNonZeroValue; + private final String sourceWithZeroValue; + private final CelType type; + private final Object value; + + ConstantTestCases( + String sourceWithNonZeroValue, String sourceWithZeroValue, CelType type, Object value) { + this.sourceWithNonZeroValue = sourceWithNonZeroValue; + this.sourceWithZeroValue = sourceWithZeroValue; + this.type = type; + this.value = value; + } + } + + private CelBuilder newCelBuilder() { + return newCelBuilder(Integer.MAX_VALUE); + } + + private CelBuilder newCelBuilder(int version) { + CelBuilder celBuilder; + switch (testMode) { + case PLANNER_PARSE_ONLY: + case PLANNER_CHECKED: + celBuilder = CelFactory.plannerCelBuilder(); + break; + case LEGACY_CHECKED: + celBuilder = CelFactory.standardCelBuilder(); + break; + default: + throw new IllegalArgumentException("Unknown test mode: " + testMode); + } + + return celBuilder + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addRuntimeLibraries(CelExtensions.optional(version)) + .addCompilerLibraries(CelExtensions.optional(version)); + } + + @Test + public void library() { + CelExtensionLibrary library = + CelExtensions.getExtensionLibrary("optional", CelOptions.DEFAULT); + assertThat(library.name()).isEqualTo("optional"); + assertThat(library.latest().version()).isEqualTo(2); + + // Version 0 + assertThat(library.version(0).functions().stream().map(CelFunctionDecl::name)) + .containsExactly( + "optional.of", + "optional.ofNonZeroValue", + "optional.none", + "value", + "hasValue", + "optional.unwrap", + "or", + "orValue", + "_?._", + "_[?_]", + "_[_]"); + assertThat(library.version(0).macros().stream().map(CelMacro::getFunction)) + .containsExactly("optMap"); + assertThat(library.version(0).variables().stream().map(CelVarDecl::name)) + .containsExactly("optional_type"); + + // Version 1 + assertThat(library.version(1).functions().stream().map(CelFunctionDecl::name)) + .containsExactly( + "optional.of", + "optional.ofNonZeroValue", + "optional.none", + "value", + "hasValue", + "optional.unwrap", + "or", + "orValue", + "_?._", + "_[?_]", + "_[_]"); + assertThat(library.version(1).macros().stream().map(CelMacro::getFunction)) + .containsExactly("optMap", "optFlatMap"); + assertThat(library.version(1).variables().stream().map(CelVarDecl::name)) + .containsExactly("optional_type"); + + // Version 2 + assertThat(library.version(2).functions().stream().map(CelFunctionDecl::name)) + .containsExactly( + "optional.of", + "optional.ofNonZeroValue", + "optional.none", + "value", + "hasValue", + "optional.unwrap", + "or", + "orValue", + "_?._", + "_[?_]", + "_[_]", + "first", + "last"); + assertThat(library.version(2).macros().stream().map(CelMacro::getFunction)) + .containsExactly("optMap", "optFlatMap"); + assertThat(library.version(2).variables().stream().map(CelVarDecl::name)) + .containsExactly("optional_type"); + } + + @Test + public void optionalOf_constant_success(@TestParameter ConstantTestCases testCase) + throws Exception { + Cel cel = newCelBuilder().setResultType(OptionalType.create(testCase.type)).build(); + String expression = String.format("optional.of(%s)", testCase.sourceWithNonZeroValue); + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isInstanceOf(Optional.class); + assertThat(result).isEqualTo(Optional.of(testCase.value)); + } + + @Test + public void optionalType_runtimeEquality(@TestParameter ConstantTestCases testCase) + throws Exception { + Cel cel = + newCelBuilder() + .addVar("a", OptionalType.create(testCase.type)) + .addVar("b", OptionalType.create(testCase.type)) + .setResultType(SimpleType.BOOL) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "a == b"); + + boolean result = + (boolean) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "a", + testCase.sourceWithNonZeroValue, + "b", + testCase.sourceWithNonZeroValue)); + + assertThat(result).isTrue(); + } + + @Test + public void optionalType_adaptsIntegerToLong_success() throws Exception { + Cel cel = newCelBuilder().addVar("a", OptionalType.create(SimpleType.INT)).build(); + CelAbstractSyntaxTree ast = compile(cel, "a"); + + Optional result = + (Optional) cel.createProgram(ast).eval(ImmutableMap.of("a", Optional.of(5))); + + assertThat(result).hasValue(5L); + } + + @Test + public void optionalType_adaptsFloatToLong_success() throws Exception { + Cel cel = newCelBuilder().addVar("a", OptionalType.create(SimpleType.DOUBLE)).build(); + CelAbstractSyntaxTree ast = compile(cel, "a"); + + Optional result = + (Optional) cel.createProgram(ast).eval(ImmutableMap.of("a", Optional.of(5.5f))); + + assertThat(result).hasValue(5.5d); + } + + @Test + public void optionalOf_nullValue_success() throws Exception { + Cel cel = newCelBuilder().setResultType(SimpleType.DYN).build(); + String expression = "optional.of(TestAllTypes{}.single_value)"; + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isInstanceOf(Optional.class); + assertThat(result).isEqualTo(Optional.of(NullValue.NULL_VALUE)); + } + + @Test + public void optionalOfNonZeroValue_withZeroValue_returnsEmptyOptionalValue( + @TestParameter ConstantTestCases testCase) throws Exception { + Cel cel = newCelBuilder().setResultType(OptionalType.create(testCase.type)).build(); + String expression = String.format("optional.ofNonZeroValue(%s)", testCase.sourceWithZeroValue); + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isInstanceOf(Optional.class); + assertThat(result).isEqualTo(Optional.empty()); + } + + @Test + public void optionalOfNonZeroValue_withNonZeroValue_returnsOptionalValue( + @TestParameter ConstantTestCases testCase) throws Exception { + Cel cel = newCelBuilder().setResultType(OptionalType.create(testCase.type)).build(); + String expression = + String.format("optional.ofNonZeroValue(%s)", testCase.sourceWithNonZeroValue); + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isInstanceOf(Optional.class); + assertThat(result).isEqualTo(Optional.of(testCase.value)); + } + + @Test + public void optionalOfNonZeroValue_withNullValue_returnsEmptyOptionalValue() throws Exception { + Cel cel = newCelBuilder().setResultType(SimpleType.DYN).build(); + CelAbstractSyntaxTree ast = + compile(cel, "optional.ofNonZeroValue(TestAllTypes{}.single_value)"); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isInstanceOf(Optional.class); + assertThat(result).isEqualTo(Optional.empty()); + } + + @Test + public void optionalOfNonZeroValue_withEmptyMessage_returnsEmptyOptionalValue() throws Exception { + Cel cel = newCelBuilder().setResultType(SimpleType.DYN).build(); + CelAbstractSyntaxTree ast = compile(cel, "optional.ofNonZeroValue(TestAllTypes{})"); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isInstanceOf(Optional.class); + assertThat(result).isEqualTo(Optional.empty()); + } + + @Test + public void optionalNone_success() throws Exception { + Cel cel = newCelBuilder().setResultType(SimpleType.DYN).build(); + CelAbstractSyntaxTree ast = compile(cel, "optional.none()"); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isInstanceOf(Optional.class); + assertThat(result).isEqualTo(Optional.empty()); + } + + @Test + public void optionalValue_success(@TestParameter ConstantTestCases testCase) throws Exception { + Cel cel = newCelBuilder().setResultType(testCase.type).build(); + String expression = String.format("optional.of(%s).value()", testCase.sourceWithNonZeroValue); + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(testCase.value); + } + + @Test + public void optionalValue_whenOptionalValueEmpty_throws() throws Exception { + Cel cel = newCelBuilder().build(); + CelAbstractSyntaxTree ast = compile(cel, "optional.none().value()"); + + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + } + + @Test + public void optionalHasValue_whenOptionalValuePresent_returnsTrue( + @TestParameter ConstantTestCases testCase) throws Exception { + Cel cel = newCelBuilder().setResultType(SimpleType.BOOL).build(); + String expression = + String.format("optional.of(%s).hasValue()", testCase.sourceWithNonZeroValue); + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(true); + } + + @Test + public void optionalHasValue_whenOptionalValueEmpty_returnsFalse( + @TestParameter ConstantTestCases testCase) throws Exception { + Cel cel = newCelBuilder().setResultType(SimpleType.BOOL).build(); + String expression = + String.format("optional.ofNonZeroValue(%s).hasValue()", testCase.sourceWithZeroValue); + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(false); + } + + @Test + public void optionalOr_success() throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .addVar("y", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + CelRuntime.Program program = cel.createProgram(compile(cel, "x.or(y)")); + + Object resultLhs = program.eval(ImmutableMap.of("x", Optional.of(5), "y", Optional.empty())); + Object resultRhs = program.eval(ImmutableMap.of("x", Optional.empty(), "y", Optional.of(10))); + + assertThat(resultLhs).isEqualTo(Optional.of(5L)); + assertThat(resultRhs).isEqualTo(Optional.of(10L)); + } + + @Test + public void optionalOr_shortCircuits() throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "errorFunc", + CelOverloadDecl.newGlobalOverload( + "error_overload", OptionalType.create(SimpleType.INT)))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "errorFunc", + CelFunctionBinding.from( + "error_overload", + ImmutableList.of(), + val -> { + throw new IllegalStateException( + "This function should not have been called!"); + }))) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + CelRuntime.Program program = cel.createProgram(compile(cel, "x.or(errorFunc())")); + + Object resultLhs = program.eval(ImmutableMap.of("x", Optional.of(5))); + + assertThat(resultLhs).isEqualTo(Optional.of(5L)); + } + + @Test + public void optionalOr_producesNonOptionalValue_throws() throws Exception { + Cel cel = newCelBuilder().addVar("x", OptionalType.create(SimpleType.INT)).build(); + + CelAbstractSyntaxTree ast = compile(cel, "x.or(optional.of(10))"); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> cel.createProgram(ast).eval(ImmutableMap.of("x", 5L))); + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :4: No matching overload for function 'or'."); + } + + @Test + public void optionalOrValue_lhsHasValue_success(@TestParameter ConstantTestCases testCase) + throws Exception { + Cel cel = newCelBuilder().setResultType(testCase.type).build(); + String expression = + String.format( + "optional.of(%s).orValue(%s)", + testCase.sourceWithNonZeroValue, testCase.sourceWithZeroValue); + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(testCase.value); + } + + @Test + public void optionalOrValue_shortCircuits() throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "errorFunc", + CelOverloadDecl.newGlobalOverload("error_overload", SimpleType.INT))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "errorFunc", + CelFunctionBinding.from( + "error_overload", + ImmutableList.of(), + val -> { + throw new IllegalStateException( + "This function should not have been called!"); + }))) + .setResultType(SimpleType.INT) + .build(); + CelRuntime.Program program = cel.createProgram(compile(cel, "x.orValue(errorFunc())")); + + Object resultLhs = program.eval(ImmutableMap.of("x", Optional.of(5))); + + assertThat(resultLhs).isEqualTo(5); + } + + @Test + public void optionalOrValue_rhsHasValue_success(@TestParameter ConstantTestCases testCase) + throws Exception { + Cel cel = newCelBuilder().setResultType(testCase.type).build(); + String expression = + String.format("optional.none().orValue(%s)", testCase.sourceWithNonZeroValue); + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(testCase.value); + } + + @Test + @TestParameters("{source: optional.of(5).orValue(optional.of(10))}") + @TestParameters("{source: optional.of(5).orValue(optional.none())}") + @TestParameters("{source: 5.orValue(optional.of(10))}") + @TestParameters("{source: 5.orValue(optional.none())}") + public void optionalOrValue_unmatchingTypes_throwsCompilationException(String source) { + if (testMode.equals(TestMode.PLANNER_PARSE_ONLY)) { + return; + } + Cel cel = newCelBuilder().build(); + + CelValidationException e = + assertThrows(CelValidationException.class, () -> compile(cel, source)); + assertThat(e).hasMessageThat().contains("found no matching overload for 'orValue'"); + } + + @Test + public void optionalOrValue_producesNonOptionalValue_throws() throws Exception { + Cel cel = newCelBuilder().addVar("x", OptionalType.create(SimpleType.INT)).build(); + + CelAbstractSyntaxTree ast = compile(cel, "x.orValue(10)"); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> cel.createProgram(ast).eval(ImmutableMap.of("x", 5))); + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :9: No matching overload for function 'orValue'."); + } + + @Test + @TestParameters("{source: optional.ofNonZeroValue(42).or(optional.of(10)).value() == 42}") + @TestParameters("{source: optional.none().or(optional.none()).orValue(42) == 42}") + public void optionalChainedFunctions_constants_success(String source) throws Exception { + Cel cel = newCelBuilder().setResultType(SimpleType.BOOL).build(); + CelAbstractSyntaxTree ast = compile(cel, source); + + boolean result = (boolean) cel.createProgram(ast).eval(); + + assertThat(result).isTrue(); + } + + @Test + public void optionalChainedFunctions_nestedMaps_success() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .setResultType(SimpleType.STRING) + .build(); + String expression = + "optional.ofNonZeroValue('').or(optional.of(m.c['dashed-index'])).orValue('default value')"; + CelAbstractSyntaxTree ast = compile(cel, expression); + + String result = + (String) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", ImmutableMap.of("c", ImmutableMap.of("dashed-index", "goodbye")))); + + assertThat(result).isEqualTo("goodbye"); + } + + @Test + public void optionalChainedFunctions_nestedMapsInvalidAccess_throws() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .setResultType(SimpleType.STRING) + .build(); + String expression = "optional.ofNonZeroValue(m.a.z).orValue(m.c['dashed-index'])"; + CelAbstractSyntaxTree ast = compile(cel, expression); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", + ImmutableMap.of("c", ImmutableMap.of("dashed-index", "goodbye"))))); + assertThat(e).hasMessageThat().contains("key 'a' is not present in map."); + } + + @Test + public void optionalFieldSelection_onMap_returnsOptionalEmpty() throws Exception { + Cel cel = newCelBuilder().setResultType(OptionalType.create(SimpleType.INT)).build(); + CelAbstractSyntaxTree ast = compile(cel, "{'a': 2}.?x"); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(Optional.empty()); + } + + @Test + public void optionalFieldSelection_onMap_returnsOptionalValue() throws Exception { + Cel cel = newCelBuilder().setResultType(OptionalType.create(SimpleType.INT)).build(); + CelAbstractSyntaxTree ast = compile(cel, "{'a': 2}.?a"); + + Optional result = (Optional) cel.createProgram(ast).eval(); + + assertThat(result).hasValue(2L); + } + + @Test + public void optionalFieldSelection_onMap_chained_returnsSinglyWrappedOptional() throws Exception { + Cel cel = newCelBuilder().setResultType(OptionalType.create(SimpleType.STRING)).build(); + CelAbstractSyntaxTree ast = compile(cel, "{'foo': {'bar': 'baz'}}.?foo.?bar"); + + Optional result = (Optional) cel.createProgram(ast).eval(); + + assertThat(result).hasValue("baz"); + } + + @Test + public void optionalFieldSelection_onProtoMessage_returnsOptionalEmpty() throws Exception { + Cel cel = + newCelBuilder() + .setResultType(OptionalType.create(SimpleType.INT)) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "msg.?single_int32"); + + Optional result = + (Optional) + cel.createProgram(ast).eval(ImmutableMap.of("msg", TestAllTypes.getDefaultInstance())); + + assertThat(result).isEmpty(); + } + + @Test + public void optionalFieldSelection_onProtoMessage_chained_returnsSinglyWrappedOptional() + throws Exception { + Cel cel = + newCelBuilder() + .setResultType(OptionalType.create(SimpleType.INT)) + .addVar( + "msg", StructTypeReference.create(NestedTestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "msg.?payload.?single_int32"); + + Optional result = + (Optional) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "msg", + NestedTestAllTypes.newBuilder() + .setPayload(TestAllTypes.newBuilder().setSingleInt32(5).build()) + .build())); + + assertThat(result).hasValue(5L); + } + + @Test + public void optionalFieldSelection_onProtoMessage_returnsOptionalValue() throws Exception { + Cel cel = + newCelBuilder() + .setResultType(OptionalType.create(SimpleType.INT)) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "msg.?single_int32"); + + Optional result = + (Optional) + cel.createProgram(ast) + .eval(ImmutableMap.of("msg", TestAllTypes.newBuilder().setSingleInt32(5).build())); + + assertThat(result).hasValue(5L); + } + + @Test + public void optionalFieldSelection_onProtoMessage_listValue() throws Exception { + Cel cel = newCelBuilder().build(); + CelAbstractSyntaxTree ast = + compile( + cel, "optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string.value()"); + + List result = (List) cel.createProgram(ast).eval(); + + assertThat(result).containsExactly("foo"); + } + + @Test + public void optionalFieldSelection_onProtoMessage_indexValue() throws Exception { + Cel cel = newCelBuilder().build(); + CelAbstractSyntaxTree ast = + compile( + cel, "optional.of(TestAllTypes{repeated_string: ['foo']}).?repeated_string[0].value()"); + + String result = (String) cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo("foo"); + } + + @Test + public void optionalFieldSelection_onProtoMessage_chainedSuccess() throws Exception { + Cel cel = + newCelBuilder() + .setResultType(OptionalType.create(SimpleType.INT)) + .addVar( + "m", + MapType.create( + SimpleType.STRING, + MapType.create( + SimpleType.STRING, + StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())))) + .build(); + CelAbstractSyntaxTree ast = + compile(cel, "m.?c.missing.or(m.?c['dashed-index']).value().?single_int32"); + + Optional result = + (Optional) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", + ImmutableMap.of( + "c", + ImmutableMap.of( + "dashed-index", + TestAllTypes.newBuilder().setSingleInt32(5).build())))); + + assertThat(result).hasValue(5L); + } + + @Test + public void optionalFieldSelection_indexerOnProtoMessage_typeCheck_throwsException() { + if (testMode.equals(TestMode.PLANNER_PARSE_ONLY)) { + return; + } + Cel cel = + newCelBuilder() + .setResultType(OptionalType.create(SimpleType.INT)) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + + CelValidationException e = + assertThrows(CelValidationException.class, () -> compile(cel, "msg[?single_int32]")); + + assertThat(e).hasMessageThat().contains("undeclared reference to 'single_int32'"); + } + + @Test + public void optionalFieldSelection_onProtoMessage_presenceTest() throws Exception { + Cel cel = + newCelBuilder() + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .setResultType(SimpleType.BOOL) + .build(); + CelAbstractSyntaxTree ast = + compile(cel, "!has(msg.?single_nested_message.bb) && has(msg.?standalone_message.bb)"); + + boolean result = + (boolean) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "msg", + TestAllTypes.newBuilder() + .setStandaloneMessage(NestedMessage.newBuilder().setBb(5).build()) + .build())); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{source: \"{'a': 2}.?a.hasValue()\", expectedResult: true}") + @TestParameters("{source: \"{'a': 2}.?x.hasValue()\", expectedResult: false}") + public void optionalFieldSelection_onMap_hasValueReturnsBoolean( + String source, boolean expectedResult) throws Exception { + Cel cel = newCelBuilder().setResultType(SimpleType.BOOL).build(); + CelAbstractSyntaxTree ast = compile(cel, source); + + boolean result = (boolean) cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + public void optionalFieldSelection_onMap_hasMacroReturnsTrue() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .setResultType(SimpleType.BOOL) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "has(m.?x.y)"); + + boolean result = + (boolean) + cel.createProgram(ast) + .eval(ImmutableMap.of("m", ImmutableMap.of("x", ImmutableMap.of("y", "z")))); + + assertThat(result).isTrue(); + } + + @Test + public void optionalFieldSelection_onMap_hasMacroReturnsFalse() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .setResultType(SimpleType.BOOL) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "has(m.?x.y)"); + + boolean result = (boolean) cel.createProgram(ast).eval(ImmutableMap.of("m", ImmutableMap.of())); + + assertThat(result).isFalse(); + } + + @Test + public void optionalFieldSelection_onOptionalMap_presenceTest() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "optm", + OptionalType.create( + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING)))) + .setResultType(SimpleType.BOOL) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "has(optm.c) && !has(optm.c.missing)"); + + boolean result = + (boolean) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "optm", + Optional.of( + ImmutableMap.of("c", ImmutableMap.of("dashed-index", "goodbye"))))); + + assertThat(result).isTrue(); + } + + @Test + public void optionalIndex_onOptionalMap_returnsOptionalValue() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "optm", + OptionalType.create( + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING)))) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "optm.c[?'dashed-index']"); + + Object result = + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "optm", + Optional.of(ImmutableMap.of("c", ImmutableMap.of("dashed-index", "goodbye"))))); + + assertThat(result).isEqualTo(Optional.of("goodbye")); + } + + @Test + public void optionalIndex_onOptionalMap_returnsOptionalEmpty() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "optm", + OptionalType.create( + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING)))) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "optm.c[?'dashed-index']"); + + Object result = + cel.createProgram(ast) + .eval(ImmutableMap.of("optm", Optional.of(ImmutableMap.of("c", ImmutableMap.of())))); + + assertThat(result).isEqualTo(Optional.empty()); + } + + @Test + public void optionalIndex_onMap_returnsOptionalEmpty() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "m.c[?'dashed-index']"); + + Object result = + cel.createProgram(ast).eval(ImmutableMap.of("m", ImmutableMap.of("c", ImmutableMap.of()))); + + assertThat(result).isEqualTo(Optional.empty()); + } + + @Test + public void optionalIndex_onMap_returnsOptionalValue() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "m.c[?'dashed-index']"); + + Object result = + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", ImmutableMap.of("c", ImmutableMap.of("dashed-index", "goodbye")))); + + assertThat(result).isEqualTo(Optional.of("goodbye")); + } + + @Test + @TestParameters("{source: '{?x: optional.of(1)}'}") + @TestParameters("{source: '{?1: x}'}") + @TestParameters("{source: '{?x: x}'}") + public void optionalIndex_onMapWithUnknownInput_returnsUnknownResult(String source) + throws Exception { + Cel cel = newCelBuilder().addVar("x", OptionalType.create(SimpleType.INT)).build(); + CelAbstractSyntaxTree ast = compile(cel, source); + + Object result = + cel.createProgram(ast) + .eval(PartialVars.of(CelAttributePattern.fromQualifiedIdentifier("x"))); + + assertThat(InterpreterUtil.isUnknown(result)).isTrue(); + } + + @Test + public void optionalIndex_onOptionalMapUsingFieldSelection_returnsOptionalValue() + throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "{?'key': optional.of('test')}.?key"); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(Optional.of("test")); + } + + @Test + public void optionalIndex_onList_returnsOptionalEmpty() throws Exception { + Cel cel = + newCelBuilder() + .addVar("l", ListType.create(SimpleType.STRING)) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "l[?0]"); + CelRuntime.Program program = cel.createProgram(ast); + + assertThat(program.eval(ImmutableMap.of("l", ImmutableList.of()))).isEqualTo(Optional.empty()); + } + + @Test + public void optionalIndex_onList_returnsOptionalValue() throws Exception { + Cel cel = + newCelBuilder() + .addVar("l", ListType.create(SimpleType.STRING)) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "l[?0]"); + + Object result = cel.createProgram(ast).eval(ImmutableMap.of("l", ImmutableList.of("hello"))); + + assertThat(result).isEqualTo(Optional.of("hello")); + } + + @Test + public void optionalIndex_onOptionalList_returnsOptionalEmpty() throws Exception { + Cel cel = + newCelBuilder() + .addVar("optl", OptionalType.create(ListType.create(SimpleType.STRING))) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "optl[?0]"); + CelRuntime.Program program = cel.createProgram(ast); + + assertThat(program.eval(ImmutableMap.of("optl", Optional.empty()))).isEqualTo(Optional.empty()); + assertThat(program.eval(ImmutableMap.of("optl", Optional.of(ImmutableList.of())))) + .isEqualTo(Optional.empty()); + } + + @Test + public void optionalIndex_onOptionalList_returnsOptionalValue() throws Exception { + Cel cel = + newCelBuilder() + .addVar("optl", OptionalType.create(ListType.create(SimpleType.STRING))) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "optl[?0]"); + + Object result = + cel.createProgram(ast) + .eval(ImmutableMap.of("optl", Optional.of(ImmutableList.of("hello")))); + + assertThat(result).isEqualTo(Optional.of("hello")); + } + + @Test + public void optionalIndex_onListWithUnknownInput_returnsUnknownResult() throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(ListType.create(SimpleType.INT)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "[?x]"); + + Object result = + cel.createProgram(ast) + .eval(PartialVars.of(CelAttributePattern.fromQualifiedIdentifier("x"))); + + assertThat(InterpreterUtil.isUnknown(result)).isTrue(); + } + + @Test + public void traditionalIndex_onOptionalList_returnsOptionalEmpty() throws Exception { + Cel cel = + newCelBuilder() + .addVar("optl", OptionalType.create(ListType.create(SimpleType.STRING))) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "optl[0]"); + + Object result = cel.createProgram(ast).eval(ImmutableMap.of("optl", Optional.empty())); + + assertThat(result).isEqualTo(Optional.empty()); + } + + @Test + public void optionalFieldSelect_fieldMarkedUnknown_returnsUnknownSet() throws Exception { + if (testMode.equals(TestMode.LEGACY_CHECKED)) { + // This case is not possible to setup for legacy runtime + return; + } + + Cel cel = + newCelBuilder() + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "msg.?single_int32"); + + Object result = + cel.createProgram(ast) + .eval( + PartialVars.of( + ImmutableMap.of("msg", TestAllTypes.newBuilder().setSingleInt32(42).build()), + CelAttributePattern.fromQualifiedIdentifier("msg.single_int32"))); + + assertThat(InterpreterUtil.isUnknown(result)).isTrue(); + } + + @Test + // LHS + @TestParameters("{expression: 'optx.or(optional.of(1))'}") + @TestParameters("{expression: 'optx.orValue(1)'}") + // RHS + @TestParameters("{expression: 'optional.none().or(optx)'}") + @TestParameters("{expression: 'optional.none().orValue(optx)'}") + public void optionalChainedFunctions_lhsIsUnknown_returnsUnknown(String expression) + throws Exception { + Cel cel = + newCelBuilder() + .addVar("optx", OptionalType.create(SimpleType.INT)) + .addVar("x", SimpleType.INT) + .build(); + CelAbstractSyntaxTree ast = compile(cel, expression); + + Object result = + cel.createProgram(ast) + .eval(PartialVars.of(CelAttributePattern.fromQualifiedIdentifier("optx"))); + + assertThat(InterpreterUtil.isUnknown(result)).isTrue(); + } + + @Test + // LHS + @TestParameters("{expression: 'optional.of(1/0).or(optional.of(1))'}") + @TestParameters("{expression: 'optional.of(1/0).orValue(1)'}") + // RHS + @TestParameters("{expression: 'optional.none().or(optional.of(1/0))'}") + @TestParameters("{expression: 'optional.none().orValue(1/0)'}") + public void optionalChainedFunctions_lhsIsError_returnsError(String expression) throws Exception { + Cel cel = + newCelBuilder() + .addVar("optx", OptionalType.create(SimpleType.INT)) + .addVar("x", SimpleType.INT) + .build(); + CelAbstractSyntaxTree ast = compile(cel, expression); + + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + } + + @Test + public void traditionalIndex_onOptionalList_returnsOptionalValue() throws Exception { + Cel cel = + newCelBuilder() + .addVar("optl", OptionalType.create(ListType.create(SimpleType.STRING))) + .setResultType(OptionalType.create(SimpleType.STRING)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "optl[0]"); + + Object result = + cel.createProgram(ast) + .eval(ImmutableMap.of("optl", Optional.of(ImmutableList.of("list-value")))); + + assertThat(result).isEqualTo(Optional.of("list-value")); + } + + @Test + @TestParameters("{source: \"m.?c.missing.or(m.?c['dashed-index']).orValue('').size() == 7\"}") + @TestParameters("{source: \"m.c[?'dashed-index'].orValue('default value') == 'goodbye'\"}") + @TestParameters("{source: \"m.c[?'missing-index'].orValue('default value') == 'default value'\"}") + public void optionalFieldSelection_onMap_chainedWithSelectorAndIndexer(String source) + throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .setResultType(SimpleType.BOOL) + .build(); + CelAbstractSyntaxTree ast = compile(cel, source); + + boolean result = + (boolean) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", ImmutableMap.of("c", ImmutableMap.of("dashed-index", "goodbye")))); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{source: \"optm.c.index.orValue('default value') == 'goodbye'\"}") + @TestParameters("{source: \"optm.c['index'].orValue('default value') == 'goodbye'\"}") + @TestParameters("{source: \"optm.c.missing.orValue('default value') == 'default value'\"}") + @TestParameters("{source: \"optm.c['missing'].orValue('default value') == 'default value'\"}") + public void traditionalIndexSelection_onOptionalMap_chainedOperatorSuccess(String source) + throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "optm", + OptionalType.create( + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING)))) + .setResultType(SimpleType.BOOL) + .build(); + CelAbstractSyntaxTree ast = compile(cel, source); + + boolean result = + (boolean) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "optm", + Optional.of(ImmutableMap.of("c", ImmutableMap.of("index", "goodbye"))))); + + assertThat(result).isTrue(); + } + + @Test + public void traditionalIndexSelection_onOptionalMap_orChainedList() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "optm", + OptionalType.create( + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING)))) + .addVar("optl", OptionalType.create(ListType.create(SimpleType.STRING))) + .setResultType(SimpleType.STRING) + .build(); + + CelAbstractSyntaxTree ast = compile(cel, "optm.c.missing.or(optl[0]).orValue('default value')"); + + String result = + (String) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "optm", + Optional.of(ImmutableMap.of("c", ImmutableMap.of("index", "goodbye"))), + "optl", + Optional.of(ImmutableList.of("list-value")))); + + assertThat(result).isEqualTo("list-value"); + } + + @Test + public void optionalMapCreation_valueIsEmpty_returnsEmptyMap() throws Exception { + Cel cel = newCelBuilder().build(); + CelAbstractSyntaxTree ast = compile(cel, "{?'key': optional.none()}"); + + Map result = (Map) cel.createProgram(ast).eval(); + + assertThat(result).isEmpty(); + } + + @Test + public void optionalMapCreation_valueIsPresent_returnsMap() throws Exception { + Cel cel = newCelBuilder().build(); + CelAbstractSyntaxTree ast = compile(cel, "{?'key': optional.of(5)}"); + + Map result = (Map) cel.createProgram(ast).eval(); + + assertThat(result).containsExactly("key", 5L); + } + + @Test + public void optionalMapCreation_withNestedMap_returnsNestedMap() throws Exception { + Cel cel = + newCelBuilder() + .setResultType( + MapType.create( + SimpleType.STRING, + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING)))) + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .build(); + CelAbstractSyntaxTree ast = + compile(cel, "{?'nested_map': optional.ofNonZeroValue({?'map': m.?c})}"); + + Map>> result = + (Map>>) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", ImmutableMap.of("c", ImmutableMap.of("dashed-index", "goodbye")))); + + assertThat(result) + .containsExactly( + "nested_map", ImmutableMap.of("map", ImmutableMap.of("dashed-index", "goodbye"))); + } + + @Test + public void optionalMapCreation_withNestedMapContainingEmptyValue_emptyValueStripped() + throws Exception { + Cel cel = + newCelBuilder() + .setResultType( + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .build(); + + CelAbstractSyntaxTree ast = + compile(cel, "{?'nested_map': optional.ofNonZeroValue({?'map': m.?c}), 'singleton': true}"); + + Object result = cel.createProgram(ast).eval(ImmutableMap.of("m", ImmutableMap.of())); + + assertThat(result).isEqualTo(ImmutableMap.of("singleton", true)); + } + + @Test + public void optionalMapCreation_valueIsNonOptional_typeCheck_throws() { + if (testMode.equals(TestMode.PLANNER_PARSE_ONLY)) { + return; + } + Cel cel = newCelBuilder().build(); + + CelValidationException e = + assertThrows(CelValidationException.class, () -> compile(cel, "{?'hi': 'world'}")); + + assertThat(e) + .hasMessageThat() + .contains("expected type 'optional_type(string)' but found 'string'"); + } + + @Test + public void optionalMessageCreation_fieldValueIsEmpty_returnsEmptyMessage() throws Exception { + Cel cel = + newCelBuilder() + .setResultType(StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + CelAbstractSyntaxTree ast = + compile(cel, "TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(0.0)}"); + + TestAllTypes result = (TestAllTypes) cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(TestAllTypes.getDefaultInstance()); + } + + @Test + public void optionalMessageCreation_fieldValueIsPresent_returnsMessage() throws Exception { + Cel cel = newCelBuilder().build(); + CelAbstractSyntaxTree ast = + compile(cel, "TestAllTypes{?single_double_wrapper: optional.ofNonZeroValue(5.0)}"); + + TestAllTypes result = (TestAllTypes) cel.createProgram(ast).eval(); + + assertThat(result) + .isEqualTo( + TestAllTypes.newBuilder() + .setSingleDoubleWrapper(DoubleValue.newBuilder().setValue(5.0)) + .build()); + } + + @Test + @TestParameters("{source: \"TestAllTypes{?map_string_string: m[?'nested']}\"}") + @TestParameters( + "{source: \"TestAllTypes{?map_string_string:" + + " optional.ofNonZeroValue(m[?'nested'].orValue({}))}\"}") + public void optionalMessageCreation_fieldValueContainsEmptyMap_returnsEmptyMessage(String source) + throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .build(); + CelAbstractSyntaxTree ast = compile(cel, source); + + TestAllTypes result = + (TestAllTypes) cel.createProgram(ast).eval(ImmutableMap.of("m", ImmutableMap.of())); + + assertThat(result).isEqualTo(TestAllTypes.getDefaultInstance()); + } + + @Test + public void optionalMessageCreation_fieldValueContainsMap_returnsEmptyMessage() throws Exception { + Cel cel = + newCelBuilder() + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "TestAllTypes{?map_string_string: m[?'nested']}"); + + TestAllTypes result = + (TestAllTypes) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", ImmutableMap.of("nested", ImmutableMap.of("hello", "world")))); + + assertThat(result) + .isEqualTo(TestAllTypes.newBuilder().putMapStringString("hello", "world").build()); + } + + @Test + public void optionalListCreation_allElementsAreEmpty_returnsEmptyList() throws Exception { + Cel cel = + newCelBuilder() + .setResultType(ListType.create(SimpleType.DYN)) + .addVar("m", MapType.create(SimpleType.STRING, SimpleType.DYN)) + .addVar("x", OptionalType.create(SimpleType.INT)) + .addVar("y", OptionalType.create(SimpleType.DYN)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "[?m.?c, ?x, ?y]"); + + List result = + (List) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", ImmutableMap.of(), "x", Optional.empty(), "y", Optional.empty())); + + assertThat(result).isEmpty(); + } + + @Test + public void optionalListCreation_containsEmptyElements_emptyElementsAreStripped() + throws Exception { + Cel cel = + newCelBuilder() + .setResultType(ListType.create(SimpleType.DYN)) + .addVar("m", MapType.create(SimpleType.STRING, SimpleType.DYN)) + .addVar("x", OptionalType.create(SimpleType.INT)) + .addVar("y", OptionalType.create(SimpleType.DYN)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "[?m.?c, ?x, ?y]"); + + List result = + (List) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", ImmutableMap.of(), "x", Optional.of(42), "y", Optional.empty())); + + assertThat(result).containsExactly(42L); + } + + @Test + public void optionalListCreation_containsMixedTypeElements_success() throws Exception { + Cel cel = + newCelBuilder() + .setResultType(ListType.create(SimpleType.DYN)) + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .addVar("x", OptionalType.create(SimpleType.INT)) + .addVar("y", OptionalType.create(SimpleType.DYN)) + .addVar("z", SimpleType.STRING) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "[?m.?c, ?x, ?y, z]"); + + List result = + (List) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", + ImmutableMap.of("c", ImmutableMap.of("dashed-value", "goodbye")), + "x", + Optional.of(42), + "y", + Optional.of(10), + "z", + "hello world")); + + assertThat(result) + .containsExactly(ImmutableMap.of("dashed-value", "goodbye"), 42L, 10L, "hello world"); + } + + @Test + public void + optionalListCreation_containsMixedTypeElements_typeCheck_throwsWhenHomogeneousLiteralsEnabled() { + if (testMode.equals(TestMode.PLANNER_PARSE_ONLY)) { + return; + } + Cel cel = + newCelBuilder() + .setOptions(CelOptions.current().enableHomogeneousLiterals(true).build()) + .addVar( + "m", + MapType.create( + SimpleType.STRING, MapType.create(SimpleType.STRING, SimpleType.STRING))) + .addVar("x", OptionalType.create(SimpleType.INT)) + .addVar("y", OptionalType.create(SimpleType.DYN)) + .build(); + + CelValidationException e = + assertThrows(CelValidationException.class, () -> compile(cel, "[?m.?c, ?x, ?y]")); + + assertThat(e).hasMessageThat().contains("expected type 'map(string, string)' but found 'int'"); + } + + @Test + public void optionalListCreation_withinProtoMessage_success() throws Exception { + Cel cel = + newCelBuilder() + .addVar("m", MapType.create(SimpleType.STRING, SimpleType.DYN)) + .addVar("x", OptionalType.create(SimpleType.DYN)) + .addVar("y", OptionalType.create(SimpleType.DYN)) + .setResultType(StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + String expression = + "TestAllTypes{repeated_string: ['greetings', ?m.nested.?hello], ?repeated_int32:" + + " optional.ofNonZeroValue([?x, ?y])}"; + CelAbstractSyntaxTree ast = compile(cel, expression); + + TestAllTypes result = + (TestAllTypes) + cel.createProgram(ast) + .eval( + ImmutableMap.of( + "m", ImmutableMap.of("nested", ImmutableMap.of("hello", "world")), + "x", Optional.empty(), + "y", Optional.empty())); + + assertThat(result) + .isEqualTo( + TestAllTypes.newBuilder() + .addRepeatedString("greetings") + .addRepeatedString("world") + .build()); + } + + @Test + public void optionalMapMacro_receiverIsEmpty_returnsOptionalEmpty() throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "x.optMap(y, y + 1)"); + + Optional result = + (Optional) cel.createProgram(ast).eval(ImmutableMap.of("x", Optional.empty())); + + assertThat(result).isEmpty(); + } + + @Test + public void optionalMapMacro_receiverHasValue_returnsOptionalValue() throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "x.optMap(y, y + 1)"); + + Optional result = + (Optional) cel.createProgram(ast).eval(ImmutableMap.of("x", Optional.of(42L))); + + assertThat(result).hasValue(43L); + } + + @Test + public void optionalMapMacro_withNonIdent_throws() { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + + CelValidationException e = + assertThrows(CelValidationException.class, () -> compile(cel, "x.optMap(y.z, y.z + 1)")); + + assertThat(e).hasMessageThat().contains("optMap() variable name must be a simple identifier"); + } + + @Test + public void optionalFlatMapMacro_receiverIsEmpty_returnsOptionalEmpty() throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "x.optFlatMap(y, optional.of(y + 1))"); + + Optional result = + (Optional) cel.createProgram(ast).eval(ImmutableMap.of("x", Optional.empty())); + + assertThat(result).isEmpty(); + } + + @Test + public void optionalFlatMapMacro_receiverHasValue_returnsOptionalValue() throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "x.optFlatMap(y, optional.of(y + 1))"); + + Optional result = + (Optional) cel.createProgram(ast).eval(ImmutableMap.of("x", Optional.of(42L))); + + assertThat(result).hasValue(43L); + } + + @Test + public void optionalFlatMapMacro_withOptionalOfNonZeroValue_optionalEmptyWhenValueIsZero() + throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "x.optFlatMap(y, optional.ofNonZeroValue(y - 1))"); + + Optional result = + (Optional) cel.createProgram(ast).eval(ImmutableMap.of("x", Optional.of(1L))); + + assertThat(result).isEmpty(); + } + + @Test + public void optionalFlatMapMacro_withOptionalOfNonZeroValue_optionalValueWhenValueExists() + throws Exception { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + CelAbstractSyntaxTree ast = compile(cel, "x.optFlatMap(y, optional.ofNonZeroValue(y + 1))"); + + Optional result = + (Optional) cel.createProgram(ast).eval(ImmutableMap.of("x", Optional.of(1L))); + + assertThat(result).hasValue(2L); + } + + @Test + public void optionalFlatMapMacro_mappingExprIsNonOptional_typeCheck_throws() { + if (testMode.equals(TestMode.PLANNER_PARSE_ONLY)) { + return; + } + + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + CelValidationException e = + assertThrows(CelValidationException.class, () -> compile(cel, "x.optFlatMap(y, y + 1)")); + + assertThat(e).hasMessageThat().contains("found no matching overload for '_?_:_'"); + } + + @Test + public void optionalFlatMapMacro_withNonIdent_throws() { + Cel cel = + newCelBuilder() + .addVar("x", OptionalType.create(SimpleType.INT)) + .setResultType(OptionalType.create(SimpleType.INT)) + .build(); + + CelValidationException e = + assertThrows( + CelValidationException.class, () -> compile(cel, "x.optFlatMap(y.z, y.z + 1)")); + + assertThat(e) + .hasMessageThat() + .contains("optFlatMap() variable name must be a simple identifier"); + } + + @Test + public void optionalType_typeResolution() throws Exception { + Cel cel = newCelBuilder().build(); + CelAbstractSyntaxTree ast = compile(cel, "optional_type"); + + TypeType optionalRuntimeType = (TypeType) cel.createProgram(ast).eval(); + + assertThat(optionalRuntimeType.name()).isEqualTo("type"); + assertThat(optionalRuntimeType.containingTypeName()).isEqualTo("optional_type"); + } + + @Test + public void optionalType_typeComparison() throws Exception { + Cel cel = newCelBuilder().build(); + + CelAbstractSyntaxTree ast = compile(cel, "type(optional.none()) == optional_type"); + + assertThat(cel.createProgram(ast).eval()).isEqualTo(true); + } + + @Test + @TestParameters("{expression: '[].first().hasValue() == false'}") + @TestParameters("{expression: '[\"a\",\"b\",\"c\"].first().value() == \"a\"'}") + public void listFirst_success(String expression) throws Exception { + Cel cel = newCelBuilder().build(); + boolean result = (boolean) cel.createProgram(compile(cel, expression)).eval(); + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expression: '[].last().hasValue() == false'}") + @TestParameters("{expression: '[1, 2, 3].last().value() == 3'}") + public void listLast_success(String expression) throws Exception { + Cel cel = newCelBuilder().build(); + boolean result = (boolean) cel.createProgram(compile(cel, expression)).eval(); + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expression: '[1].first()', expectedError: 'undeclared reference to ''first'''}") + @TestParameters("{expression: '[2].last()', expectedError: 'undeclared reference to ''last'''}") + public void listFirstAndLast_typeCheck_throws_earlyVersion( + String expression, String expectedError) throws Exception { + if (testMode.equals(TestMode.PLANNER_PARSE_ONLY)) { + return; + } + // Configure Cel with an earlier version of the 'optional' library, which did not support + // 'first' and 'last' + Cel cel = newCelBuilder(1).build(); + assertThat( + assertThrows( + CelValidationException.class, + () -> { + cel.createProgram(compile(cel, expression)).eval(); + })) + .hasMessageThat() + .contains(expectedError); + } + + @Test + public void optionalMapCreation_mapKeySetOnNonOptional_throws() { + String expression = "{?1: dyn(\"one\")}"; + Cel cel = newCelBuilder().build(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, () -> cel.createProgram(compile(cel, expression)).eval()); + assertThat(e) + .hasMessageThat() + .contains("Cannot initialize optional entry '1' from non-optional value one"); + } + + @Test + public void optionalListCreation_listKeySetOnNonOptional_throws() { + String expression = "[?dyn(1)]"; + Cel cel = newCelBuilder().build(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, () -> cel.createProgram(compile(cel, expression)).eval()); + assertThat(e) + .hasMessageThat() + .contains("Cannot initialize optional list element from non-optional value 1"); + } + + @Test + public void optionalMessageCreation_fieldKeySetOnNonOptional_throws() { + String expression = "TestAllTypes{?single_double_wrapper: dyn('foo')}"; + Cel cel = newCelBuilder().build(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, () -> cel.createProgram(compile(cel, expression)).eval()); + assertThat(e) + .hasMessageThat() + .contains( + "Cannot initialize optional entry 'single_double_wrapper' from non-optional value foo"); + } + + private CelAbstractSyntaxTree compile(CelCompiler compiler, String expression) + throws CelValidationException { + CelAbstractSyntaxTree ast = compiler.parse(expression).getAst(); + if (testMode.equals(TestMode.PLANNER_PARSE_ONLY)) { + return ast; + } + + return compiler.check(ast).getAst(); + } +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelProtoExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelProtoExtensionsTest.java new file mode 100644 index 000000000..f46ea5b1a --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelProtoExtensionsTest.java @@ -0,0 +1,334 @@ +// Copyright 2022 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Any; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.ExtensionRegistry; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import dev.cel.expr.conformance.proto2.TestAllTypes.NestedEnum; +import dev.cel.expr.conformance.proto2.TestAllTypesExtensions; +import dev.cel.parser.CelMacro; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelFunctionBinding; +import org.junit.Assume; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelProtoExtensionsTest extends CelExtensionTestBase { + + @Override + protected Cel newCelEnv() { + return runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.protos()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addFileTypes(TestAllTypesExtensions.getDescriptor()) + .addVar("msg", StructTypeReference.create("cel.expr.conformance.proto2.TestAllTypes")) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto2")) + .build(); + } + + private static final TestAllTypes PACKAGE_SCOPED_EXT_MSG = + TestAllTypes.newBuilder() + .setExtension(TestAllTypesExtensions.int32Ext, 1) + .setExtension( + TestAllTypesExtensions.nestedExt, TestAllTypes.newBuilder().setSingleInt32(5).build()) + .setExtension(TestAllTypesExtensions.nestedEnumExt, NestedEnum.BAR) + .setExtension( + TestAllTypesExtensions.repeatedTestAllTypes, + ImmutableList.of( + TestAllTypes.newBuilder().setSingleString("A").build(), + TestAllTypes.newBuilder().setSingleString("B").build())) + .build(); + + private static final TestAllTypes MESSAGE_SCOPED_EXT_MSG = + TestAllTypes.newBuilder() + .setExtension( + Proto2ExtensionScopedMessage.messageScopedNestedExt, + TestAllTypes.newBuilder().setSingleString("test").build()) + .setExtension(Proto2ExtensionScopedMessage.int64Ext, 1L) + .build(); + + @Test + public void library() { + CelExtensionLibrary library = + CelExtensions.getExtensionLibrary("protos", CelOptions.DEFAULT); + assertThat(library.name()).isEqualTo("protos"); + assertThat(library.latest().version()).isEqualTo(0); + assertThat(library.version(0).functions()).isEmpty(); + assertThat(library.version(0).macros().stream().map(CelMacro::getFunction)) + .containsExactly("hasExt", "getExt"); + } + + @Test + @TestParameters("{expr: 'proto.hasExt(msg, cel.expr.conformance.proto2.int32_ext)'}") + @TestParameters("{expr: 'proto.hasExt(msg, cel.expr.conformance.proto2.nested_ext)'}") + @TestParameters("{expr: 'proto.hasExt(msg, cel.expr.conformance.proto2.nested_enum_ext)'}") + @TestParameters( + "{expr: 'proto.hasExt(msg, cel.expr.conformance.proto2.repeated_test_all_types)'}") + @TestParameters("{expr: '!proto.hasExt(msg, cel.expr.conformance.proto2.test_all_types_ext)'}") + public void hasExt_packageScoped_success(String expr) throws Exception { + boolean result = (boolean) eval(expr, ImmutableMap.of("msg", PACKAGE_SCOPED_EXT_MSG)); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters( + "{expr: 'proto.hasExt(msg," + + " cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext)'}") + @TestParameters( + "{expr: 'proto.hasExt(msg," + + " cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext)'}") + @TestParameters( + "{expr: '!proto.hasExt(msg," + + " cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_repeated_test_all_types)'}") + @TestParameters( + "{expr: '!proto.hasExt(msg," + + " cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.nested_enum_ext)'}") + public void hasExt_messageScoped_success(String expr) throws Exception { + boolean result = (boolean) eval(expr, ImmutableMap.of("msg", MESSAGE_SCOPED_EXT_MSG)); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expr: 'msg.hasExt(''cel.expr.conformance.proto2.int32_ext'', 0)'}") + @TestParameters("{expr: 'dyn(msg).hasExt(''cel.expr.conformance.proto2.int32_ext'', 0)'}") + public void hasExt_nonProtoNamespace_success(String expr) throws Exception { + StructTypeReference proto2MessageTypeReference = + StructTypeReference.create("cel.expr.conformance.proto2.TestAllTypes"); + Cel customCel = + runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.protos()) + .addVar("msg", proto2MessageTypeReference) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "hasExt", + CelOverloadDecl.newMemberOverload( + "msg_hasExt", + SimpleType.BOOL, + ImmutableList.of( + proto2MessageTypeReference, SimpleType.STRING, SimpleType.INT)))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "hasExt", + CelFunctionBinding.from( + "msg_hasExt", + ImmutableList.of(TestAllTypes.class, String.class, Long.class), + (arg) -> { + TestAllTypes msg = (TestAllTypes) arg[0]; + String extensionField = (String) arg[1]; + return msg.getAllFields().keySet().stream() + .anyMatch(fd -> fd.getFullName().equals(extensionField)); + }))) + .build(); + + boolean result = + (boolean) eval(customCel, expr, ImmutableMap.of("msg", PACKAGE_SCOPED_EXT_MSG)); + + assertThat(result).isTrue(); + } + + @Test + public void hasExt_undefinedField_throwsException() { + // This is a type-checking failure + Assume.assumeFalse(isParseOnly); + CelValidationException exception = + assertThrows( + CelValidationException.class, + () -> + cel.compile("!proto.hasExt(msg, cel.expr.conformance.proto2.undefined_field)") + .getAst()); + + assertThat(exception) + .hasMessageThat() + .contains("undefined field 'cel.expr.conformance.proto2.undefined_field'"); + } + + @Test + @TestParameters("{expr: 'proto.getExt(msg, cel.expr.conformance.proto2.int32_ext) == 1'}") + @TestParameters( + "{expr: 'proto.getExt(msg, cel.expr.conformance.proto2.nested_ext) ==" + + " TestAllTypes{single_int32: 5}'}") + @TestParameters( + "{expr: 'proto.getExt(msg, cel.expr.conformance.proto2.nested_enum_ext) ==" + + " TestAllTypes.NestedEnum.BAR'}") + @TestParameters( + "{expr: 'proto.getExt(msg, cel.expr.conformance.proto2.repeated_test_all_types) ==" + + " [TestAllTypes{single_string: ''A''}, TestAllTypes{single_string: ''B''}]'}") + public void getExt_packageScoped_success(String expr) throws Exception { + boolean result = (boolean) eval(expr, ImmutableMap.of("msg", PACKAGE_SCOPED_EXT_MSG)); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters( + "{expr: 'proto.getExt(msg," + + " cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext)" + + " == TestAllTypes{single_string: ''test''}'}") + @TestParameters( + "{expr: 'proto.getExt(msg," + + " cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext) == 1'}") + public void getExt_messageScopedSuccess(String expr) throws Exception { + boolean result = (boolean) eval(expr, ImmutableMap.of("msg", MESSAGE_SCOPED_EXT_MSG)); + + assertThat(result).isTrue(); + } + + @Test + public void getExt_undefinedField_throwsException() { + // This is a type-checking failure + Assume.assumeFalse(isParseOnly); + CelValidationException exception = + assertThrows( + CelValidationException.class, + () -> + cel.compile("!proto.getExt(msg, cel.expr.conformance.proto2.undefined_field)") + .getAst()); + + assertThat(exception) + .hasMessageThat() + .contains("undefined field 'cel.expr.conformance.proto2.undefined_field'"); + } + + @Test + @TestParameters("{expr: 'msg.getExt(''cel.expr.conformance.proto2.int32_ext'', 0) == 1'}") + @TestParameters("{expr: 'dyn(msg).getExt(''cel.expr.conformance.proto2.int32_ext'', 0) == 1'}") + public void getExt_nonProtoNamespace_success(String expr) throws Exception { + StructTypeReference proto2MessageTypeReference = + StructTypeReference.create("cel.expr.conformance.proto2.TestAllTypes"); + Cel customCel = + runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.protos()) + .addVar("msg", proto2MessageTypeReference) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "getExt", + CelOverloadDecl.newMemberOverload( + "msg_getExt", + SimpleType.DYN, + ImmutableList.of( + proto2MessageTypeReference, SimpleType.STRING, SimpleType.INT)))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "getExt", + CelFunctionBinding.from( + "msg_getExt", + ImmutableList.of(TestAllTypes.class, String.class, Long.class), + (arg) -> { + TestAllTypes msg = (TestAllTypes) arg[0]; + String extensionField = (String) arg[1]; + FieldDescriptor extensionDescriptor = + msg.getAllFields().keySet().stream() + .filter(fd -> fd.getFullName().equals(extensionField)) + .findAny() + .get(); + return msg.getField(extensionDescriptor); + }))) + .build(); + + boolean result = + (boolean) eval(customCel, expr, ImmutableMap.of("msg", PACKAGE_SCOPED_EXT_MSG)); + + assertThat(result).isTrue(); + } + + @Test + public void getExt_onAnyPackedExtensionField_success() throws Exception { + ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance(); + TestAllTypesExtensions.registerAllExtensions(extensionRegistry); + Cel customCel = + runtimeFlavor + .builder() + // CEL-Internal-2 + .addCompilerLibraries(CelExtensions.protos()) + .addFileTypes(TestAllTypesExtensions.getDescriptor()) + .setExtensionRegistry(extensionRegistry) + .addVar("msg", StructTypeReference.create("cel.expr.conformance.proto2.TestAllTypes")) + .build(); + Any anyMsg = + Any.pack( + TestAllTypes.newBuilder().setExtension(TestAllTypesExtensions.int32Ext, 1).build()); + Long result = + (Long) + eval( + customCel, + "proto.getExt(msg, cel.expr.conformance.proto2.int32_ext)", + ImmutableMap.of("msg", anyMsg)); + + assertThat(result).isEqualTo(1); + } + + private enum ParseErrorTestCase { + FIELD_NOT_FULLY_QUALIFIED( + "proto.getExt(Proto2ExtensionScopedMessage{}, int64_ext)", + "ERROR: :1:46: invalid extension field\n" + + " | proto.getExt(Proto2ExtensionScopedMessage{}, int64_ext)\n" + + " | .............................................^"), + CALL( + "proto.hasExt(Proto2ExtensionScopedMessage{}, call().int64_ext)", + "ERROR: :1:52: invalid extension field\n" + + " | proto.hasExt(Proto2ExtensionScopedMessage{}, call().int64_ext)\n" + + " | ...................................................^"), + FIELD_INSIDE_PRESENCE_TEST( + "proto.getExt(Proto2ExtensionScopedMessage{}," + + " has(cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext))", + "ERROR: :1:49: invalid extension field\n" + + " | proto.getExt(Proto2ExtensionScopedMessage{}," + + " has(cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.int64_ext))\n" + + " | ................................................^"); + + private final String expr; + private final String error; + + ParseErrorTestCase(String expr, String error) { + this.expr = expr; + this.error = error; + } + } + + @Test + public void parseErrors(@TestParameter ParseErrorTestCase testcase) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> cel.parse(testcase.expr).getAst()); + + assertThat(e).hasMessageThat().isEqualTo(testcase.error); + } + + +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelRegexExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelRegexExtensionsTest.java new file mode 100644 index 000000000..97d0cc90c --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelRegexExtensionsTest.java @@ -0,0 +1,268 @@ +// Copyright 2025 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelEvaluationException; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelRegexExtensionsTest extends CelExtensionTestBase { + + @Override + protected Cel newCelEnv() { + return runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.regex()) + .addRuntimeLibraries(CelExtensions.regex()) + .build(); + } + + + @Test + public void library() { + CelExtensionLibrary library = + CelExtensions.getExtensionLibrary("regex", CelOptions.DEFAULT); + assertThat(library.name()).isEqualTo("regex"); + assertThat(library.latest().version()).isEqualTo(0); + assertThat(library.version(0).functions().stream().map(CelFunctionDecl::name)) + .containsExactly("regex.replace", "regex.extract", "regex.extractAll"); + assertThat(library.version(0).macros()).isEmpty(); + } + + @Test + @TestParameters("{target: 'abc', regex: '^', replaceStr: 'start_', res: 'start_abc'}") + @TestParameters("{target: 'abc', regex: '$', replaceStr: '_end', res: 'abc_end'}") + @TestParameters("{target: 'a-b', regex: '\\\\b', replaceStr: '|', res: '|a|-|b|'}") + @TestParameters( + "{target: 'foo bar', regex: '(fo)o (ba)r', replaceStr: '\\\\2 \\\\1', res: 'ba fo'}") + @TestParameters("{target: 'foo bar', regex: 'foo', replaceStr: '\\\\\\\\', res: '\\ bar'}") + @TestParameters("{target: 'banana', regex: 'ana', replaceStr: 'x', res: 'bxna'}") + @TestParameters("{target: 'abc', regex: 'b(.)', replaceStr: 'x\\\\1', res: 'axc'}") + @TestParameters( + "{target: 'hello world hello', regex: 'hello', replaceStr: 'hi', res: 'hi world hi'}") + @TestParameters("{target: 'ac', regex: 'a(b)?c', replaceStr: '[\\\\1]', res: '[]'}") + @TestParameters("{target: 'apple pie', regex: 'p', replaceStr: 'X', res: 'aXXle Xie'}") + @TestParameters( + "{target: 'remove all spaces', regex: '\\\\s', replaceStr: '', res: 'removeallspaces'}") + @TestParameters("{target: 'digit:99919291992', regex: '\\\\d+', replaceStr: '3', res: 'digit:3'}") + @TestParameters( + "{target: 'foo bar baz', regex: '\\\\w+', replaceStr: '(\\\\0)', res: '(foo) (bar) (baz)'}") + @TestParameters("{target: '', regex: 'a', replaceStr: 'b', res: ''}") + @TestParameters( + "{target: 'User: Alice, Age: 30', regex: 'User: (?P\\\\w+), Age: (?P\\\\d+)'," + + " replaceStr: '${name} is ${age} years old', res: '${name} is ${age} years old'}") + @TestParameters( + "{target: 'User: Alice, Age: 30', regex: 'User: (?P\\\\w+), Age: (?P\\\\d+)'," + + " replaceStr: '\\\\1 is \\\\2 years old', res: 'Alice is 30 years old'}") + @TestParameters("{target: 'hello β˜ƒ', regex: 'β˜ƒ', replaceStr: '❄', res: 'hello ❄'}") + public void replaceAll_success(String target, String regex, String replaceStr, String res) + throws Exception { + String expr = String.format("regex.replace('%s', '%s', '%s')", target, regex, replaceStr); + assertThat(eval(expr)).isEqualTo(res); + } + + @Test + public void replace_nested_success() throws Exception { + String expr = + "regex.replace(" + + " regex.replace('%(foo) %(bar) %2','%\\\\((\\\\w+)\\\\)','${\\\\1}')," + + " '%(\\\\d+)', '$\\\\1')"; + assertThat(eval(expr)).isEqualTo("${foo} ${bar} $2"); + } + + @Test + @TestParameters("{t: 'banana', re: 'a', rep: 'x', i: 0, res: 'banana'}") + @TestParameters("{t: 'banana', re: 'a', rep: 'x', i: 1, res: 'bxnana'}") + @TestParameters("{t: 'banana', re: 'a', rep: 'x', i: 2, res: 'bxnxna'}") + @TestParameters("{t: 'banana', re: 'a', rep: 'x', i: 100, res: 'bxnxnx'}") + @TestParameters("{t: 'banana', re: 'a', rep: 'x', i: -1, res: 'bxnxnx'}") + @TestParameters("{t: 'banana', re: 'a', rep: 'x', i: -100, res: 'bxnxnx'}") + @TestParameters( + "{t: 'cat-dog dog-cat cat-dog dog-cat', re: '(cat)-(dog)', rep: '\\\\2-\\\\1', i: 1," + + " res: 'dog-cat dog-cat cat-dog dog-cat'}") + @TestParameters( + "{t: 'cat-dog dog-cat cat-dog dog-cat', re: '(cat)-(dog)', rep: '\\\\2-\\\\1', i: 2, res:" + + " 'dog-cat dog-cat dog-cat dog-cat'}") + @TestParameters("{t: 'a.b.c', re: '\\\\.', rep: '-', i: 1, res: 'a-b.c'}") + @TestParameters("{t: 'a.b.c', re: '\\\\.', rep: '-', i: -1, res: 'a-b-c'}") + public void replaceCount_success(String t, String re, String rep, long i, String res) + throws Exception { + String expr = String.format("regex.replace('%s', '%s', '%s', %d)", t, re, rep, i); + assertThat(eval(expr)).isEqualTo(res); + } + + @Test + @TestParameters("{target: 'foo bar', regex: '(', replaceStr: '$2 $1'}") + @TestParameters("{target: 'foo bar', regex: '[a-z', replaceStr: '$2 $1'}") + public void replace_invalidRegex_throwsException(String target, String regex, String replaceStr) + throws Exception { + String expr = String.format("regex.replace('%s', '%s', '%s')", target, regex, replaceStr); + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval(expr)); + + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e).hasCauseThat().hasMessageThat().contains("Failed to compile regex: "); + } + + @Test + public void replace_invalidCaptureGroupReplaceStr_throwsException() throws Exception { + String expr = "regex.replace('test', '(.)', '\\\\2')"; + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval(expr)); + + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e) + .hasCauseThat() + .hasMessageThat() + .contains("Replacement string references group 2 but regex has only 1 group(s)"); + } + + @Test + public void replace_trailingBackslashReplaceStr_throwsException() throws Exception { + String expr = "regex.replace('id=123', 'id=(?P\\\\d+)', '\\\\')"; + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval(expr)); + + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e) + .hasCauseThat() + .hasMessageThat() + .contains("Invalid replacement string: \\ not allowed at end"); + } + + @Test + public void replace_invalidGroupReferenceReplaceStr_throwsException() throws Exception { + String expr = "regex.replace('id=123', 'id=(?P\\\\d+)', '\\\\a')"; + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval(expr)); + + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e) + .hasCauseThat() + .hasMessageThat() + .contains("Invalid replacement string: \\ must be followed by a digit"); + } + + @Test + @TestParameters("{target: 'hello world', regex: 'hello(.*)', expectedResult: ' world'}") + @TestParameters("{target: 'item-A, item-B', regex: 'item-(\\\\w+)', expectedResult: 'A'}") + @TestParameters("{target: 'bananana', regex: 'ana', expectedResult: 'ana'}") + @TestParameters( + "{target: 'The color is red', regex: 'The color is (\\\\w+)', expectedResult: 'red'}") + @TestParameters( + "{target: 'The color is red', regex: 'The color is \\\\w+', expectedResult: 'The color is" + + " red'}") + @TestParameters( + "{target: 'phone: 415-5551212', regex: 'phone: (\\\\d{3})?', expectedResult: '415'}") + @TestParameters("{target: 'brand', regex: 'brand', expectedResult: 'brand'}") + public void extract_success(String target, String regex, String expectedResult) throws Exception { + String expr = String.format("regex.extract('%s', '%s')", target, regex); + Object result = eval(expr); + + assertThat(result).isInstanceOf(Optional.class); + assertThat((Optional) result).hasValue(expectedResult); + } + + @Test + @TestParameters("{target: 'hello world', regex: 'goodbye (.*)'}") + @TestParameters("{target: 'HELLO', regex: 'hello'}") + @TestParameters("{target: '', regex: '\\\\w+'}") + public void extract_no_match(String target, String regex) throws Exception { + String expr = String.format("regex.extract('%s', '%s')", target, regex); + Object result = eval(expr); + + assertThat(result).isInstanceOf(Optional.class); + assertThat((Optional) result).isEmpty(); + } + + @Test + @TestParameters("{target: 'phone: 415-5551212', regex: 'phone: ((\\\\d{3})-)?'}") + @TestParameters("{target: 'testuser@testdomain', regex: '(.*)@([^.]*)'}") + public void extract_multipleCaptureGroups_throwsException(String target, String regex) + throws Exception { + String expr = String.format("regex.extract('%s', '%s')", target, regex); + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval(expr)); + + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e) + .hasCauseThat() + .hasMessageThat() + .contains("Regular expression has more than one capturing group:"); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum ExtractAllTestCase { + NO_MATCH("regex.extractAll('id:123, id:456', 'assa')", ImmutableList.of()), + NO_CAPTURE_GROUP( + "regex.extractAll('id:123, id:456', 'id:\\\\d+')", ImmutableList.of("id:123", "id:456")), + CAPTURE_GROUP( + "regex.extractAll('key=\"\", key=\"val\"', 'key=\"([^\"]*)\"')", + ImmutableList.of("", "val")), + SINGLE_NAMED_GROUP( + "regex.extractAll('testuser@testdomain', '(?P.*)@')", + ImmutableList.of("testuser")), + SINGLE_NAMED_MULTIPLE_MATCH_GROUP( + "regex.extractAll('banananana', '(ana)')", ImmutableList.of("ana", "ana")); + private final String expr; + private final ImmutableList expectedResult; + + ExtractAllTestCase(String expr, ImmutableList expectedResult) { + this.expr = expr; + this.expectedResult = expectedResult; + } + } + + @Test + public void extractAll_success(@TestParameter ExtractAllTestCase testCase) throws Exception { + Object result = eval(testCase.expr); + + assertThat(result).isEqualTo(testCase.expectedResult); + } + + @Test + @TestParameters("{target: 'phone: 415-5551212', regex: 'phone: ((\\\\d{3})-)?'}") + @TestParameters("{target: 'testuser@testdomain', regex: '(.*)@([^.]*)'}") + @TestParameters( + "{target: 'Name: John Doe, Age:321', regex: 'Name: (?P.*), Age:(?P\\\\d+)'}") + @TestParameters( + "{target: 'The user testuser belongs to testdomain', regex: 'The (user|domain)" + + " (?P.*) belongs (to) (?P.*)'}") + public void extractAll_multipleCaptureGroups_throwsException(String target, String regex) + throws Exception { + String expr = String.format("regex.extractAll('%s', '%s')", target, regex); + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> eval(expr)); + + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e) + .hasCauseThat() + .hasMessageThat() + .contains("Regular expression has more than one capturing group:"); + } + + +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelSetsExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelSetsExtensionsTest.java new file mode 100644 index 000000000..091d456f5 --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelSetsExtensionsTest.java @@ -0,0 +1,465 @@ +// Copyright 2024 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntime; +import dev.cel.testing.CelRuntimeFlavor; +import java.util.List; +import org.junit.Assume; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelSetsExtensionsTest extends CelExtensionTestBase { + private static final CelOptions CEL_OPTIONS = + CelOptions.current().enableHeterogeneousNumericComparisons(true).build(); + + @Override + protected Cel newCelEnv() { + return runtimeFlavor + .builder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setOptions(CEL_OPTIONS) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .addCompilerLibraries(CelExtensions.sets(CEL_OPTIONS)) + .addRuntimeLibraries(CelExtensions.sets(CEL_OPTIONS)) + .addVar("list", ListType.create(SimpleType.INT)) + .addVar("subList", ListType.create(SimpleType.INT)) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "new_int", + CelOverloadDecl.newGlobalOverload("new_int_int64", SimpleType.INT, SimpleType.INT))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "new_int", + CelFunctionBinding.from( + "new_int_int64", + Long.class, + // Intentionally return java.lang.Integer to test primitive type adaptation + Math::toIntExact))) + .build(); + } + + @Test + public void library() { + CelExtensionLibrary library = + CelExtensions.getExtensionLibrary("sets", CelOptions.DEFAULT); + assertThat(library.name()).isEqualTo("sets"); + assertThat(library.latest().version()).isEqualTo(0); + assertThat(library.version(0).functions().stream().map(CelFunctionDecl::name)) + .containsExactly("sets.contains", "sets.equivalent", "sets.intersects"); + assertThat(library.version(0).macros()).isEmpty(); + } + + @Test + public void contains_integerListWithSameValue_succeeds() throws Exception { + ImmutableList list = ImmutableList.of(1, 2, 3, 4); + ImmutableList subList = ImmutableList.of(1, 2, 3, 4); + assertThat( + eval("sets.contains(list, subList)", ImmutableMap.of("list", list, "subList", subList))) + .isEqualTo(true); + } + + @Test + public void contains_integerListAsExpression_succeeds() throws Exception { + assertThat(eval("sets.contains([1, 1], [1])")).isEqualTo(true); + } + + @Test + @TestParameters( + "{expression: 'sets.contains([TestAllTypes{}], [TestAllTypes{}])', expected: true}") + @TestParameters( + "{expression: 'sets.contains([TestAllTypes{single_int64: 1, single_uint64: 2u}]," + + " [TestAllTypes{single_int64: 1, single_uint64: 2u}])', expected: true}") + @TestParameters( + "{expression: 'sets.contains([TestAllTypes{single_any: [1.0, 2u, 3]}]," + + " [TestAllTypes{single_any: [1u, 2, 3.0]}])', expected: true}") + @TestParameters( + "{expression: 'sets.contains([TestAllTypes{single_int64: 1, single_uint64: 2u}]," + + " [TestAllTypes{single_int64: 2, single_uint64: 3u}])', expected: false}") + public void contains_withProtoMessage_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters("{expression: 'sets.contains([new_int(1)], [1])', expected: true}") + @TestParameters("{expression: 'sets.contains([new_int(1)], [1.0, 1u])', expected: true}") + @TestParameters("{expression: 'sets.contains([new_int(2)], [1])', expected: false}") + public void contains_withFunctionReturningInteger_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters("{list: [1, 2, 3, 4], subList: [1, 2, 3, 4], expected: true}") + @TestParameters("{list: [5, 4, 3, 2, 1], subList: [1, 2, 3], expected: true}") + @TestParameters("{list: [5, 4, 3, 2, 1], subList: [1, 1, 1, 1, 1], expected: true}") + @TestParameters("{list: [], subList: [], expected: true}") + @TestParameters("{list: [1], subList: [], expected: true}") + @TestParameters("{list: [], subList: [1], expected: false}") + @TestParameters("{list: [1], subList: [1], expected: true}") + @TestParameters("{list: [1], subList: [1, 1], expected: true}") + @TestParameters("{list: [1, 1], subList: [1, 1], expected: true}") + @TestParameters("{list: [2, 1], subList: [1], expected: true}") + @TestParameters("{list: [1, 2, 3, 4], subList: [2, 3], expected: true}") + @TestParameters("{list: [1], subList: [2], expected: false}") + @TestParameters("{list: [1], subList: [1, 2], expected: false}") + public void contains_withIntTypes_succeeds( + List list, List subList, boolean expected) throws Exception { + assertThat( + eval("sets.contains(list, subList)", ImmutableMap.of("list", list, "subList", subList))) + .isEqualTo(expected); + } + + @Test + @TestParameters("{list: [1.0], subList: [1.0, 1.0], expected: true}") + @TestParameters("{list: [1.0, 1.00], subList: [1], expected: true}") + @TestParameters("{list: [1.0], subList: [1.00], expected: true}") + @TestParameters("{list: [1.414], subList: [], expected: true}") + @TestParameters("{list: [], subList: [1.414], expected: false}") + @TestParameters("{list: [3.14, 2.71], subList: [2.71], expected: true}") + @TestParameters("{list: [3.9], subList: [3.1], expected: false}") + @TestParameters("{list: [3.2], subList: [3.1], expected: false}") + @TestParameters("{list: [2, 3.0], subList: [2, 3], expected: true}") + public void contains_withDoubleTypes_succeeds( + List list, List subList, boolean expected) throws Exception { + assertThat( + eval("sets.contains(list, subList)", ImmutableMap.of("list", list, "subList", subList))) + .isEqualTo(expected); + } + + @Test + @TestParameters("{expression: 'sets.contains([[1], [2, 3]], [[2, 3]])', expected: true}") + @TestParameters("{expression: 'sets.contains([[1], [2], [3]], [[2, 3]])', expected: false}") + @TestParameters( + "{expression: 'sets.contains([[1, 2], [2, 3]], [[1], [2, 3.0]])', expected: false}") + @TestParameters("{expression: 'sets.contains([[1], [2, 3.0]], [[2, 3]])', expected: true}") + public void contains_withNestedLists_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters("{expression: 'sets.contains([1, \"1\"], [1])', expected: true}") + @TestParameters("{expression: 'sets.contains([1], [1, \"1\"])', expected: false}") + public void contains_withMixingIntAndString_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + public void contains_withMixingIntAndString_throwsException( + @TestParameter({"sets.contains([1], [\"1\"])", "sets.contains([\"1\"], [1])"}) + String expression) + throws Exception { + Assume.assumeFalse(isParseOnly); + CelValidationResult invalidData = cel.compile(expression); + + assertThat(invalidData.getErrors()).hasSize(1); + assertThat(invalidData.getErrors().get(0).getMessage()) + .contains("found no matching overload for 'sets.contains'"); + } + + @Test + public void contains_withMixedValues_succeeds() throws Exception { + assertThat(eval("sets.contains([1, 2], [2u, 2.0])")).isEqualTo(true); + } + + @Test + @TestParameters("{expression: 'sets.contains([[1], [2, 3.0]], [[2, 3]])', expected: true}") + @TestParameters( + "{expression: 'sets.contains([[1], [2, 3.0], [[[[[5]]]]]], [[[[[[5]]]]]])', expected: true}") + @TestParameters( + "{expression: 'sets.contains([[1], [2, 3.0], [[[[[5]]]]]], [[[[[[5, 1]]]]]])', expected:" + + " false}") + @TestParameters( + "{expression: 'sets.contains([[1], [2, 3.0], [[[[[5, 1]]]]]], [[[[[[5]]]]]])', expected:" + + " false}") + @TestParameters( + "{expression: 'sets.contains([[[[[[5]]]]]], [[1], [2, 3.0], [[[[[5]]]]]])', expected: false}") + public void contains_withMultiLevelNestedList_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters("{expression: 'sets.contains([{1: 1}], [{1: 1}])', expected: true}") + @TestParameters("{expression: 'sets.contains([{1: 1}], [{1u: 1}, {1: 1.0}])', expected: true}") + @TestParameters( + "{expression: 'sets.contains([{\"a\": \"b\"}, {\"c\": \"d\"}], [{\"a\": \"b\"}])', expected:" + + " true}") + @TestParameters("{expression: 'sets.contains([{2: 1}], [{1: 1}])', expected: false}") + @TestParameters( + "{expression: 'sets.contains([{\"a\": \"b\"}], [{\"a\": \"b\"}, {\"c\": \"d\"}])', expected:" + + " false}") + public void contains_withMapValues_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters("{expression: 'sets.equivalent([], [])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([1], [1])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([1], [1, 1])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([1, 1], [1])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([[1], [2, 3]], [[1], [2, 3]])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([2, 1], [1])', expected: false}") + @TestParameters("{expression: 'sets.equivalent([1], [1, 2])', expected: false}") + @TestParameters("{expression: 'sets.equivalent([1, 2], [1, 2, 3])', expected: false}") + @TestParameters("{expression: 'sets.equivalent([1, 2], [2, 2, 2])', expected: false}") + public void equivalent_withIntTypes_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters("{expression: 'sets.equivalent([1, 2, 3], [3u, 2.0, 1])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([1], [1u, 1.0])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([1], [1u, 1.0])', expected: true}") + @TestParameters( + "{expression: 'sets.equivalent([[1.0], [2, 3]], [[1], [2, 3.0]])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([1, 2.0, 3], [1, 2])', expected: false}") + @TestParameters("{expression: 'sets.equivalent([1, 2], [2u, 2, 2.0])', expected: false}") + @TestParameters("{expression: 'sets.equivalent([1, 2], [1u, 2, 2.3])', expected: false}") + public void equivalent_withMixedTypes_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters( + "{expression: 'sets.equivalent([TestAllTypes{}, TestAllTypes{}], [TestAllTypes{}])'," + + " expected: true}") + @TestParameters( + "{expression: 'sets.equivalent([TestAllTypes{}], [TestAllTypes{}, TestAllTypes{}])'," + + " expected: true}") + @TestParameters( + "{expression: 'sets.equivalent([TestAllTypes{single_int64: 1, single_uint64: 2u}]," + + " [TestAllTypes{single_int64: 1, single_uint64: 2u}])', expected: true}") + @TestParameters( + "{expression: 'sets.equivalent([TestAllTypes{single_any: [1.0, 2u, 3]}]," + + " [TestAllTypes{single_any: [1u, 2, 3.0]}])', expected: true}") + @TestParameters( + "{expression: 'sets.equivalent([TestAllTypes{single_any: [1.0, 2u, 3]}," + + " TestAllTypes{single_any: [2,3,4]}], [TestAllTypes{single_any: [1u, 2, 3.0]}])'," + + " expected: false}") + @TestParameters( + "{expression: 'sets.equivalent([TestAllTypes{single_int64: 1, single_uint64: 2u}]," + + " [TestAllTypes{single_int64: 2, single_uint64: 3u}])', expected: false}") + public void equivalent_withProtoMessage_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters("{expression: 'sets.equivalent([{1: 1}], [{1: 1}, {1: 1}])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([{1: 1}, {1: 1}], [{1: 1}])', expected: true}") + @TestParameters("{expression: 'sets.equivalent([{1: 1}], [{1: 1u}, {1: 1.0}])', expected: true}") + @TestParameters( + "{expression: 'sets.equivalent([{1: 1}, {1u: 1}], [{1u: 1}, {1: 1.0}])', expected: true}") + @TestParameters( + "{expression: 'sets.equivalent([{\"a\": \"b\"}, {\"a\": \"b\"}], [{\"a\": \"b\"}])'," + + " expected: true}") + @TestParameters("{expression: 'sets.equivalent([{2: 1}], [{1: 1}])', expected: false}") + @TestParameters( + "{expression: 'sets.equivalent([{\"a\": \"b\"}], [{\"a\": \"b\"}, {\"c\": \"d\"}])'," + + " expected: false}") + public void equivalent_withMapValues_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters("{expression: 'sets.intersects([], [])', expected: false}") + @TestParameters("{expression: 'sets.intersects([1], [])', expected: false}") + @TestParameters("{expression: 'sets.intersects([], [1])', expected: false}") + @TestParameters("{expression: 'sets.intersects([1], [1])', expected: true}") + @TestParameters("{expression: 'sets.intersects([1], [2])', expected: false}") + @TestParameters("{expression: 'sets.intersects([1], [1, 1])', expected: true}") + @TestParameters("{expression: 'sets.intersects([1, 1], [1])', expected: true}") + @TestParameters("{expression: 'sets.intersects([2, 1], [1])', expected: true}") + @TestParameters("{expression: 'sets.intersects([1], [1, 2])', expected: true}") + @TestParameters("{expression: 'sets.intersects([1], [1.0, 2])', expected: true}") + @TestParameters("{expression: 'sets.intersects([1, 2], [2u, 2, 2.0])', expected: true}") + @TestParameters("{expression: 'sets.intersects([1, 2], [1, 2, 2.3])', expected: true}") + @TestParameters("{expression: 'sets.intersects([0, 1, 2], [1, 2, 2.3])', expected: true}") + @TestParameters("{expression: 'sets.intersects([1, 2], [1u, 2, 2.3])', expected: true}") + @TestParameters( + "{expression: 'sets.intersects([[1], [2, 3]], [[1, 2], [2, 3.0]])', expected: true}") + @TestParameters("{expression: 'sets.intersects([1], [\"1\", 2])', expected: false}") + @TestParameters("{expression: 'sets.intersects([1], [1.1, 2])', expected: false}") + @TestParameters("{expression: 'sets.intersects([1], [1.1, 2u])', expected: false}") + public void intersects_withMixedTypes_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters("{expression: 'sets.intersects([{1: 1}], [{1: 1}, {1: 1}])', expected: true}") + @TestParameters("{expression: 'sets.intersects([{1: 1}, {1: 1}], [{1: 1}])', expected: true}") + @TestParameters("{expression: 'sets.intersects([{1: 1}], [{1: 1u}, {1: 1.0}])', expected: true}") + @TestParameters( + "{expression: 'sets.intersects([{1: 1}, {1u: 1}], [{1.0: 1u}, {1u: 1.0}])', expected: true}") + @TestParameters("{expression: 'sets.intersects([{1:2}], [{1:2}, {2:3}])', expected: true}") + @TestParameters( + "{expression: 'sets.intersects([{\"a\": \"b\"}, {\"a\": \"b\"}], [{\"a\": \"b\"}])'," + + " expected: true}") + @TestParameters( + "{expression: 'sets.intersects([{\"a\": \"b\"}], [{\"c\": \"d\"}])', expected: false}") + @TestParameters("{expression: 'sets.intersects([{2: 1}], [{1: 1}])', expected: false}") + public void intersects_withMapValues_succeeds(String expression, boolean expected) + throws Exception { + // The LEGACY runtime is not spec compliant, because decimal keys are not allowed for maps. + Assume.assumeFalse( + runtimeFlavor.equals(CelRuntimeFlavor.PLANNER) && expression.contains("1.0:")); + + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + @TestParameters( + "{expression: 'sets.intersects([TestAllTypes{}, TestAllTypes{}], [TestAllTypes{}])'," + + " expected: true}") + @TestParameters( + "{expression: 'sets.intersects([TestAllTypes{}], [TestAllTypes{}, TestAllTypes{}])'," + + " expected: true}") + @TestParameters( + "{expression: 'sets.intersects([TestAllTypes{single_int64: 1, single_uint64: 2u}]," + + " [TestAllTypes{single_int64: 1, single_uint64: 2u}])', expected: true}") + @TestParameters( + "{expression: 'sets.intersects([TestAllTypes{single_any: [1.0, 2u, 3]}]," + + " [TestAllTypes{single_any: [1u, 2, 3.0]}])', expected: true}") + @TestParameters( + "{expression: 'sets.intersects([TestAllTypes{single_any: [1, 2, 3.5]}," + + " TestAllTypes{single_any: [2,3,4]}], [TestAllTypes{single_any: [1u, 2, 3.0]}])'," + + " expected: false}") + @TestParameters( + "{expression: 'sets.intersects([TestAllTypes{single_int64: 1, single_uint64: 2u}]," + + " [TestAllTypes{single_int64: 2, single_uint64: 3u}])', expected: false}") + public void intersects_withProtoMessage_succeeds(String expression, boolean expected) + throws Exception { + assertThat(eval(expression)).isEqualTo(expected); + } + + @Test + public void setsExtension_containsFunctionSubset_succeeds() throws Exception { + CelSetsExtensions setsExtensions = + CelExtensions.sets(CelOptions.DEFAULT, SetsFunction.CONTAINS); + Cel cel = + runtimeFlavor + .builder() + .addCompilerLibraries(setsExtensions) + .addRuntimeLibraries(setsExtensions) + .build(); + + Object evaluatedResult = eval(cel, "sets.contains([1, 2], [2])"); + + assertThat(evaluatedResult).isEqualTo(true); + } + + @Test + public void setsExtension_equivalentFunctionSubset_succeeds() throws Exception { + CelSetsExtensions setsExtensions = + CelExtensions.sets(CelOptions.DEFAULT, SetsFunction.EQUIVALENT); + Cel cel = + runtimeFlavor + .builder() + .addCompilerLibraries(setsExtensions) + .addRuntimeLibraries(setsExtensions) + .build(); + + Object evaluatedResult = eval(cel, "sets.equivalent([1, 1], [1])"); + + assertThat(evaluatedResult).isEqualTo(true); + } + + @Test + public void setsExtension_intersectsFunctionSubset_succeeds() throws Exception { + CelSetsExtensions setsExtensions = + CelExtensions.sets(CelOptions.DEFAULT, SetsFunction.INTERSECTS); + Cel cel = + runtimeFlavor + .builder() + .addCompilerLibraries(setsExtensions) + .addRuntimeLibraries(setsExtensions) + .build(); + + Object evaluatedResult = eval(cel, "sets.intersects([1, 1], [1])"); + + assertThat(evaluatedResult).isEqualTo(true); + } + + @Test + public void setsExtension_compileUnallowedFunction_throws() { + Assume.assumeFalse(isParseOnly); + CelSetsExtensions setsExtensions = + CelExtensions.sets(CelOptions.DEFAULT, SetsFunction.EQUIVALENT); + Cel cel = runtimeFlavor.builder().addCompilerLibraries(setsExtensions).build(); + + assertThrows( + CelValidationException.class, () -> cel.compile("sets.contains([1, 2], [2])").getAst()); + } + + @Test + public void setsExtension_evaluateUnallowedFunction_throws() throws Exception { + CelSetsExtensions setsExtensions = + CelExtensions.sets(CelOptions.DEFAULT, SetsFunction.CONTAINS, SetsFunction.EQUIVALENT); + CelSetsExtensions runtimeLibrary = + CelExtensions.sets(CelOptions.DEFAULT, SetsFunction.EQUIVALENT); + Cel cel = + runtimeFlavor + .builder() + .addCompilerLibraries(setsExtensions) + .addRuntimeLibraries(runtimeLibrary) + .build(); + + CelAbstractSyntaxTree ast = + isParseOnly + ? cel.parse("sets.contains([1, 2], [2])").getAst() + : cel.compile("sets.contains([1, 2], [2])").getAst(); + + if (runtimeFlavor.equals(CelRuntimeFlavor.PLANNER) && !isParseOnly) { + // Fails at plan time + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast)); + } else { + CelRuntime.Program program = cel.createProgram(ast); + assertThrows(CelEvaluationException.class, () -> program.eval()); + } + } + + +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelStringExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelStringExtensionsTest.java new file mode 100644 index 000000000..4b242ddcd --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelStringExtensionsTest.java @@ -0,0 +1,1477 @@ +// Copyright 2022 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.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +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.CelRuntime; +import java.util.List; +import org.junit.Assume; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelStringExtensionsTest extends CelExtensionTestBase { + + @Override + protected Cel newCelEnv() { + return runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.strings()) + .addRuntimeLibraries(CelExtensions.strings()) + .addVar("s", SimpleType.STRING) + .addVar("separator", SimpleType.STRING) + .addVar("index", SimpleType.INT) + .addVar("offset", SimpleType.INT) + .addVar("indexOfParam", SimpleType.STRING) + .addVar("beginIndex", SimpleType.INT) + .addVar("endIndex", SimpleType.INT) + .addVar("limit", SimpleType.INT) + .build(); + } + + @Test + public void library() { + CelExtensionLibrary library = + CelExtensions.getExtensionLibrary("strings", CelOptions.DEFAULT); + assertThat(library.name()).isEqualTo("strings"); + assertThat(library.latest().version()).isEqualTo(0); + assertThat(library.version(0).functions().stream().map(CelFunctionDecl::name)) + .containsExactly( + "charAt", + "indexOf", + "join", + "lastIndexOf", + "lowerAscii", + "replace", + "reverse", + "split", + "strings.quote", + "substring", + "trim", + "upperAscii"); + assertThat(library.version(0).macros()).isEmpty(); + } + + @Test + @TestParameters("{string: 'abcd', beginIndex: 0, expectedResult: 'abcd'}") + @TestParameters("{string: 'abcd', beginIndex: 1, expectedResult: 'bcd'}") + @TestParameters("{string: 'abcd', beginIndex: 2, expectedResult: 'cd'}") + @TestParameters("{string: 'abcd', beginIndex: 3, expectedResult: 'd'}") + @TestParameters("{string: 'abcd', beginIndex: 4, expectedResult: ''}") + @TestParameters("{string: '', beginIndex: 0, expectedResult: ''}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 0, expectedResult: 'πŸ˜πŸ˜‘πŸ˜¦'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 1, expectedResult: 'πŸ˜‘πŸ˜¦'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 2, expectedResult: '😦'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 3, expectedResult: ''}") + public void substring_beginIndex_success(String string, int beginIndex, String expectedResult) + throws Exception { + Object evaluatedResult = + eval("s.substring(beginIndex)", ImmutableMap.of("s", string, "beginIndex", beginIndex)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: '', expectedResult: ''}") + @TestParameters("{string: 'hello world', expectedResult: 'hello world'}") + @TestParameters("{string: 'HELLO WORLD', expectedResult: 'hello world'}") + @TestParameters("{string: 'HeLlO wOrLd', expectedResult: 'hello world'}") + @TestParameters( + "{string: 'A!@#$%^&*()-_+=?/<>.,;:''\"\\', expectedResult: 'a!@#$%^&*()-_+=?/<>.,;:''\"\\'}") + public void lowerAscii_success(String string, String expectedResult) throws Exception { + Object evaluatedResult = eval("s.lowerAscii()", ImmutableMap.of("s", string)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + // Some of these characters from Latin Extended block have a lowercase mapping. + // In CEL's String extension, we do not transform these because they are outside Latin-1 + @TestParameters("{string: 'Γ€ΓŸΓ αΈ€αΈαΈ‚αΈƒ', expectedResult: 'Γ€ΓŸΓ αΈ€αΈαΈ‚αΈƒ'}") + @TestParameters("{string: 'κ°€λ‚˜λ‹€λΌ λ§ˆλ°”μ‚¬', expectedResult: 'κ°€λ‚˜λ‹€λΌ λ§ˆλ°”μ‚¬'}") + @TestParameters("{string: 'Aκ°€Bλ‚˜Cλ‹€D라E 마Fλ°”G사H', expectedResult: 'aκ°€bλ‚˜cλ‹€d라e 마fλ°”g사h'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', expectedResult: 'πŸ˜πŸ˜‘πŸ˜¦'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', expectedResult: 'πŸ˜πŸ˜‘ 😦'}") + @TestParameters("{string: 'A😁B πŸ˜‘Cκ°€πŸ˜¦D', expectedResult: 'a😁b πŸ˜‘cκ°€πŸ˜¦d'}") + public void lowerAscii_outsideAscii_success(String string, String expectedResult) + throws Exception { + Object evaluatedResult = eval("s.lowerAscii()", ImmutableMap.of("s", string)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: '', separator: '', expectedResult: []}") + @TestParameters("{string: '', separator: ' ', expectedResult: ['']}") + @TestParameters("{string: '', separator: ' ', expectedResult: ['']}") + @TestParameters("{string: ' ', separator: '', expectedResult: [' ']}") + @TestParameters("{string: ' ', separator: ' ', expectedResult: ['','']}") + @TestParameters("{string: ' ', separator: ' ', expectedResult: [' ']}") + @TestParameters("{string: 'test', separator: '', expectedResult: ['t', 'e', 's', 't']}") + @TestParameters("{string: 'test', separator: ' ', expectedResult: ['test']}") + @TestParameters("{string: 'te st', separator: '', expectedResult: ['t', 'e', ' ', 's', 't']}") + @TestParameters("{string: 'hello world', separator: ' ', expectedResult: ['hello', 'world']}") + @TestParameters("{string: 'hello world', separator: 'hello world', expectedResult: ['', '']}") + @TestParameters( + "{string: 'hello hello hello+hello', separator: ' ', expectedResult: ['hello', 'hello'," + + " 'hello+hello']}") + @TestParameters( + "{string: 'hello hello hello+hello', separator: 'hello', expectedResult: ['', ' ', ' '," + + " '+','']}") + @TestParameters( + "{string: 'h-e_l-lo w+o-rld', separator: '-', expectedResult: ['h', 'e_l', 'lo w+o'," + + " 'rld']}") + @TestParameters( + "{string: 'The quick brown fox jumps over the lazy dog', separator: 'fox', expectedResult:" + + " ['The quick brown ', ' jumps over the lazy dog']}") + public void split_ascii_success(String string, String separator, List expectedResult) + throws Exception { + Object evaluatedResult = + eval("s.split(separator)", ImmutableMap.of("s", string, "separator", separator)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: 'κ°€λ‚˜a 닀라', separator: '', expectedResult: ['κ°€','λ‚˜','a',' ', 'λ‹€','라']}") + @TestParameters("{string: 'κ°€λ‚˜a 닀라', separator: ' ', expectedResult: ['κ°€λ‚˜a', '닀라']}") + @TestParameters("{string: 'Ξ²βˆ§Β±βŠ—βˆ‰Ξ·β–‘β‡β€°βˆ•', separator: 'βˆ‰Ξ·', expectedResult: ['Ξ²βˆ§Β±βŠ—', 'β–‘β‡β€°βˆ•']}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘πŸ˜¦', separator: '', expectedResult: ['😁','😦','πŸ˜‘','😦']}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘πŸ˜¦', separator: ' ', expectedResult: ['πŸ˜πŸ˜¦πŸ˜‘πŸ˜¦']}") + @TestParameters("{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: ' ', expectedResult: ['😁aπŸ˜¦λ‚˜πŸ˜‘', '😦']}") + @TestParameters("{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: ' ', expectedResult: ['😁aπŸ˜¦λ‚˜πŸ˜‘', '😦']}") + @TestParameters("{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: 'λ‚˜πŸ˜‘ ', expectedResult: ['😁a😦', '😦']}") + @TestParameters("{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: ' ', expectedResult: ['😁aπŸ˜¦λ‚˜πŸ˜‘' ,'😦']}") + @TestParameters("{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', expectedResult: ['','']}") + public void split_unicode_success(String string, String separator, List expectedResult) + throws Exception { + Object evaluatedResult = + eval("s.split(separator)", ImmutableMap.of("s", string, "separator", separator)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @SuppressWarnings("unchecked") // Test only, need List cast to test mutability + public void split_collectionIsImmutable() throws Exception { + CelAbstractSyntaxTree ast = cel.compile("'test'.split('')").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + + List evaluatedResult = (List) program.eval(); + + assertThrows(UnsupportedOperationException.class, () -> evaluatedResult.add("a")); + } + + @Test + public void split_separatorIsNonString_throwsException() { + // This is a type-check failure. + Assume.assumeFalse(isParseOnly); + CelValidationResult result = cel.compile("'12'.split(2)"); + CelValidationException exception = + assertThrows(CelValidationException.class, () -> result.getAst()); + + assertThat(exception).hasMessageThat().contains("found no matching overload for 'split'"); + } + + @Test + @TestParameters("{string: '', separator: '', limit: -1, expectedResult: []}") + @TestParameters("{string: '', separator: '', limit: 0, expectedResult: []}") + @TestParameters("{string: '', separator: ' ', limit: 0, expectedResult: []}") + @TestParameters("{string: ' ', separator: ' ', limit: 0, expectedResult: []}") + @TestParameters("{string: 'test', separator: '', limit: 0, expectedResult: []}") + @TestParameters("{string: 'test', separator: ' ', limit: 0, expectedResult: []}") + @TestParameters("{string: 'test', separator: 'test', limit: 0, expectedResult: []}") + @TestParameters("{string: 'hello world', separator: '', limit: 0, expectedResult: []}") + @TestParameters("{string: '', separator: '', limit: 1, expectedResult: ['']}") + @TestParameters("{string: '', separator: ' ', limit: 1, expectedResult: ['']}") + @TestParameters("{string: '', separator: ' ', limit: 1, expectedResult: ['']}") + @TestParameters("{string: '', separator: ' ', limit: 2, expectedResult: ['']}") + @TestParameters("{string: ' ', separator: '', limit: 1, expectedResult: [' ']}") + @TestParameters("{string: ' ', separator: ' ', limit: 1, expectedResult: [' ']}") + @TestParameters("{string: ' ', separator: ' ', limit: 2, expectedResult: ['','']}") + @TestParameters("{string: 'test', separator: '', limit: 1, expectedResult: ['test']}") + @TestParameters("{string: 'test', separator: '', limit: 2, expectedResult: ['t', 'est']}") + @TestParameters("{string: 'test', separator: '', limit: 3, expectedResult: ['t', 'e', 'st']}") + @TestParameters("{string: 'test', separator: '', limit: 4, expectedResult: ['t', 'e', 's', 't']}") + @TestParameters( + "{string: 'test', separator: '', limit: -1, expectedResult: ['t', 'e', 's', 't']}") + @TestParameters("{string: 'test', separator: ' ', limit: 1, expectedResult: ['test']}") + @TestParameters("{string: 'test', separator: ' ', limit: 2, expectedResult: ['test']}") + @TestParameters("{string: 'te st', separator: '', limit: 1, expectedResult: ['te st']}") + @TestParameters( + "{string: 'te st', separator: '', limit: -1, expectedResult: ['t', 'e', ' ', 's', 't']}") + @TestParameters( + "{string: 'te st', separator: '', limit: 5, expectedResult: ['t', 'e', ' ', 's', 't']}") + @TestParameters( + "{string: 'hello world', separator: ' ', limit: 1, expectedResult: ['hello world']}") + @TestParameters( + "{string: 'hello world', separator: ' ', limit: 2, expectedResult: ['hello', 'world']}") + @TestParameters( + "{string: 'hello world', separator: ' ', limit: 3, expectedResult: ['hello', 'world']}") + @TestParameters( + "{string: 'hello world', separator: ' ', limit: -1, expectedResult: ['hello', 'world']}") + @TestParameters( + "{string: 'hello world', separator: 'hello world', limit: 1, expectedResult: ['hello" + + " world']}") + @TestParameters( + "{string: 'hello world', separator: 'hello world', limit: 2, expectedResult: ['', '']}") + @TestParameters( + "{string: 'hello world', separator: 'hello world', limit: 3, expectedResult: ['', '']}") + @TestParameters( + "{string: 'hello world', separator: 'hello world', limit: -1, expectedResult: ['', '']}") + @TestParameters( + "{string: 'hello hello hello+hello', separator: '+', limit: 2, expectedResult: ['hello hello" + + " hello','hello']}") + @TestParameters( + "{string: 'hello hello hello+hello', separator: 'hello', limit: 3, expectedResult: ['', ' '," + + "' hello+hello']}") + @TestParameters( + "{string: 'hello hello hello+hello', separator: 'hello', limit: 5, expectedResult: ['', ' '," + + " ' ', '+','']}") + @TestParameters( + "{string: 'hello hello hello+hello', separator: 'hello', limit: -1, expectedResult: ['', ' '," + + " ' ', '+','']}") + @TestParameters( + "{string: 'h-e_l-lo w+o-rld', separator: '-', limit: 3, expectedResult: ['h', 'e_l', 'lo" + + " w+o-rld']}") + @TestParameters( + "{string: 'h-e_l-lo w+o-rld', separator: '-', limit: 5, expectedResult: ['h', 'e_l', 'lo" + + " w+o', 'rld']}") + @TestParameters( + "{string: 'h-e_l-lo w+o-rld', separator: '-', limit: -1, expectedResult: ['h', 'e_l', 'lo" + + " w+o', 'rld']}") + @TestParameters( + "{string: 'The quick brown fox jumps over the lazy dog', separator: 'fox', limit: 0," + + " expectedResult: []}") + @TestParameters( + "{string: 'The quick brown fox jumps over the lazy dog', separator: 'fox', limit: 1," + + " expectedResult: ['The quick brown fox jumps over the lazy dog']}") + @TestParameters( + "{string: 'The quick brown fox jumps over the lazy dog', separator: 'fox', limit: 2," + + " expectedResult: ['The quick brown ', ' jumps over the lazy dog']}") + @TestParameters( + "{string: 'The quick brown fox jumps over the lazy dog', separator: 'fox', limit: -1," + + " expectedResult: ['The quick brown ', ' jumps over the lazy dog']}") + public void split_asciiWithLimit_success( + String string, String separator, int limit, List expectedResult) throws Exception { + Object evaluatedResult = + eval( + "s.split(separator, limit)", + ImmutableMap.of("s", string, "separator", separator, "limit", limit)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: 'κ°€λ‚˜a 닀라', separator: ' ', limit: 0, expectedResult: []}") + @TestParameters("{string: 'Ξ²βˆ§Β±βŠ—βˆ‰Ξ·β–‘β‡β€°βˆ•', separator: 'βˆ‰Ξ·', limit: 0, expectedResult: []}") + @TestParameters("{string: '😁😦 πŸ˜‘πŸ˜¦', separator: 'b', limit: 0, expectedResult: []}") + @TestParameters("{string: 'κ°€λ‚˜a 닀라', separator: '', limit: 1, expectedResult: ['κ°€λ‚˜a 닀라']}") + @TestParameters("{string: 'κ°€λ‚˜a 닀라', separator: ' ', limit: 2, expectedResult: ['κ°€λ‚˜a', '닀라']}") + @TestParameters("{string: 'κ°€λ‚˜a 닀라', separator: ' ', limit: -1, expectedResult: ['κ°€λ‚˜a', '닀라']}") + @TestParameters( + "{string: 'Ξ²βˆ§Β±βŠ—βˆ‰Ξ·β–‘β‡β€°βˆ•', separator: 'βˆ‰Ξ·', limit: 1, expectedResult: ['Ξ²βˆ§Β±βŠ—βˆ‰Ξ·β–‘β‡β€°βˆ•']}") + @TestParameters( + "{string: 'Ξ²βˆ§Β±βŠ—βˆ‰Ξ·β–‘β‡β€°βˆ•', separator: 'βˆ‰Ξ·', limit: 2, expectedResult: ['Ξ²βˆ§Β±βŠ—', 'β–‘β‡β€°βˆ•']}") + @TestParameters( + "{string: 'Ξ²βˆ§Β±βŠ—βˆ‰Ξ·β–‘β‡β€°βˆ•', separator: 'βˆ‰Ξ·', limit: 3, expectedResult: ['Ξ²βˆ§Β±βŠ—', 'β–‘β‡β€°βˆ•']}") + @TestParameters( + "{string: 'Ξ²βˆ§Β±βŠ—βˆ‰Ξ·β–‘β‡β€°βˆ•', separator: 'βˆ‰Ξ·', limit: -1, expectedResult: ['Ξ²βˆ§Β±βŠ—', 'β–‘β‡β€°βˆ•']}") + @TestParameters("{string: '😁😦 πŸ˜‘πŸ˜¦', separator: '', limit: 1, expectedResult: ['😁😦 πŸ˜‘πŸ˜¦']}") + @TestParameters( + "{string: '😁😦 πŸ˜‘πŸ˜¦', separator: '', limit: 2, expectedResult: ['😁','😦 πŸ˜‘πŸ˜¦']}") + @TestParameters( + "{string: '😁😦 πŸ˜‘πŸ˜¦', separator: '', limit: 3, expectedResult: ['😁','😦',' πŸ˜‘πŸ˜¦']}") + @TestParameters( + "{string: '😁😦 πŸ˜‘πŸ˜¦', separator: '', limit: 4, expectedResult: ['😁','😦',' ','πŸ˜‘πŸ˜¦']}") + @TestParameters( + "{string: '😁😦 πŸ˜‘πŸ˜¦', separator: '', limit: 5, expectedResult: ['😁','😦',' ','πŸ˜‘','😦']}") + @TestParameters( + "{string: '😁😦 πŸ˜‘πŸ˜¦', separator: '', limit: 6, expectedResult: ['😁','😦',' ','πŸ˜‘','😦']}") + @TestParameters( + "{string: '😁😦 πŸ˜‘πŸ˜¦', separator: '', limit: -1, expectedResult: ['😁','😦',' ','πŸ˜‘','😦']}") + @TestParameters( + "{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: 'λ‚˜πŸ˜‘ ', limit: 1, expectedResult: ['😁aπŸ˜¦λ‚˜πŸ˜‘ 😦']}") + @TestParameters( + "{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: 'λ‚˜πŸ˜‘ ', limit: 2, expectedResult: ['😁a😦', '😦']}") + @TestParameters( + "{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: 'λ‚˜πŸ˜‘ ', limit: 3, expectedResult: ['😁a😦', '😦']}") + @TestParameters( + "{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: 'λ‚˜πŸ˜‘ ', limit: -1, expectedResult: ['😁a😦', '😦']}") + @TestParameters( + "{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', limit: 1, expectedResult: ['😁aπŸ˜¦λ‚˜πŸ˜‘" + + " 😦']}") + @TestParameters( + "{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', limit: 2, expectedResult: ['','']}") + @TestParameters( + "{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', limit: 3, expectedResult: ['','']}") + @TestParameters( + "{string: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', separator: '😁aπŸ˜¦λ‚˜πŸ˜‘ 😦', limit: -1, expectedResult: ['','']}") + public void split_unicodeWithLimit_success( + String string, String separator, int limit, List expectedResult) throws Exception { + Object evaluatedResult = + eval( + "s.split(separator, limit)", + ImmutableMap.of("s", string, "separator", separator, "limit", limit)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{separator: '', limit: 0}") + @TestParameters("{separator: '', limit: 1}") + @TestParameters("{separator: '', limit: 2}") + @TestParameters("{separator: 'te', limit: 0}") + @TestParameters("{separator: 'te', limit: 1}") + @TestParameters("{separator: 'te', limit: 2}") + @SuppressWarnings("unchecked") // Test only, need List cast to test mutability + public void split_withLimit_collectionIsImmutable(String separator, int limit) throws Exception { + List evaluatedResult = + (List) + eval( + "'test'.split(separator, limit)", + ImmutableMap.of("separator", separator, "limit", limit)); + + assertThrows(UnsupportedOperationException.class, () -> evaluatedResult.add("a")); + } + + @Test + public void split_withLimit_separatorIsNonString_throwsException() { + // This is a type-check failure. + Assume.assumeFalse(isParseOnly); + CelValidationResult result = cel.compile("'12'.split(2, 3)"); + CelValidationException exception = + assertThrows(CelValidationException.class, () -> result.getAst()); + + assertThat(exception).hasMessageThat().contains("found no matching overload for 'split'"); + } + + @Test + public void split_withLimitOverflow_throwsException() throws Exception { + ImmutableMap variables = ImmutableMap.of("limit", 2147483648L); // INT_MAX + 1 + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, () -> eval("'test'.split('', limit)", variables)); + + assertThat(exception) + .hasMessageThat() + .contains("split failure: Limit must not exceed the int32 range: 2147483648"); + } + + @Test + @TestParameters("{string: 'abcd', beginIndex: 0, endIndex: 0, expectedResult: ''}") + @TestParameters("{string: 'abcd', beginIndex: 0, endIndex: 1, expectedResult: 'a'}") + @TestParameters("{string: 'abcd', beginIndex: 0, endIndex: 2, expectedResult: 'ab'}") + @TestParameters("{string: 'abcd', beginIndex: 0, endIndex: 3, expectedResult: 'abc'}") + @TestParameters("{string: 'abcd', beginIndex: 0, endIndex: 4, expectedResult: 'abcd'}") + @TestParameters("{string: 'abcd', beginIndex: 1, endIndex: 4, expectedResult: 'bcd'}") + @TestParameters("{string: 'abcd', beginIndex: 1, endIndex: 3, expectedResult: 'bc'}") + @TestParameters("{string: 'abcd', beginIndex: 2, endIndex: 3, expectedResult: 'c'}") + @TestParameters("{string: 'abcd', beginIndex: 3, endIndex: 3, expectedResult: ''}") + @TestParameters("{string: '', beginIndex: 0, endIndex: 0, expectedResult: ''}") + public void substring_beginAndEndIndex_ascii_success( + String string, int beginIndex, int endIndex, String expectedResult) throws Exception { + Object evaluatedResult = + eval( + "s.substring(beginIndex, endIndex)", + ImmutableMap.of("s", string, "beginIndex", beginIndex, "endIndex", endIndex)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + // SMP + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 0, endIndex: 0, expectedResult: ''}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 0, endIndex: 1, expectedResult: '😁'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 0, endIndex: 2, expectedResult: 'πŸ˜πŸ˜‘'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 0, endIndex: 3, expectedResult: 'πŸ˜πŸ˜‘πŸ˜¦'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 1, endIndex: 3, expectedResult: 'πŸ˜‘πŸ˜¦'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 2, endIndex: 3, expectedResult: '😦'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 3, endIndex: 3, expectedResult: ''}") + // BMP/SMP Mixed + @TestParameters("{string: 'aπŸ˜λ‚˜', beginIndex: 0, endIndex: 0, expectedResult: ''}") + @TestParameters("{string: 'aπŸ˜λ‚˜', beginIndex: 0, endIndex: 1, expectedResult: 'a'}") + @TestParameters("{string: 'aπŸ˜λ‚˜', beginIndex: 0, endIndex: 2, expectedResult: 'a😁'}") + @TestParameters("{string: 'aπŸ˜λ‚˜', beginIndex: 0, endIndex: 3, expectedResult: 'aπŸ˜λ‚˜'}") + @TestParameters("{string: 'aπŸ˜λ‚˜', beginIndex: 1, endIndex: 3, expectedResult: 'πŸ˜λ‚˜'}") + @TestParameters("{string: 'aπŸ˜λ‚˜', beginIndex: 2, endIndex: 3, expectedResult: 'λ‚˜'}") + @TestParameters("{string: 'aπŸ˜λ‚˜', beginIndex: 3, endIndex: 3, expectedResult: ''}") + public void substring_beginAndEndIndex_unicode_success( + String string, int beginIndex, int endIndex, String expectedResult) throws Exception { + Object evaluatedResult = + eval( + "s.substring(beginIndex, endIndex)", + ImmutableMap.of("s", string, "beginIndex", beginIndex, "endIndex", endIndex)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: 'abcd', beginIndex: 7}") + @TestParameters("{string: '', beginIndex: 2}") + public void substring_beginIndexOutOfRange_ascii_throwsException(String string, int beginIndex) + throws Exception { + ImmutableMap variables = ImmutableMap.of("s", string, "beginIndex", beginIndex); + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, () -> eval("s.substring(beginIndex)", variables)); + + String exceptionMessage = + String.format( + "substring failure: Range [%d, %d) out of bounds", beginIndex, string.length()); + assertThat(exception).hasMessageThat().contains(exceptionMessage); + } + + @Test + // BMP + @TestParameters("{string: 'κ°€λ‚˜λ‹€', beginIndex: 4, uniqueCharCount: 3}") + // SMP + @TestParameters("{string: '😁', beginIndex: 2, uniqueCharCount: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 4, uniqueCharCount: 3}") + // BMP/SMP Mixed + @TestParameters("{string: 'πŸ˜κ°€λ‚˜', beginIndex: 4, uniqueCharCount: 3}") + public void substring_beginIndexOutOfRange_unicode_throwsException( + String string, int beginIndex, int uniqueCharCount) throws Exception { + ImmutableMap variables = ImmutableMap.of("s", string, "beginIndex", beginIndex); + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, () -> eval("s.substring(beginIndex)", variables)); + + String exceptionMessage = + String.format( + "substring failure: Range [%d, %d) out of bounds", beginIndex, uniqueCharCount); + assertThat(exception).hasMessageThat().contains(exceptionMessage); + } + + @Test + @TestParameters("{string: 'abcd', beginIndex: -1, endIndex: 1}") + @TestParameters("{string: 'abcd', beginIndex: 0, endIndex: 5}") + @TestParameters("{string: 'abcd', beginIndex: 2, endIndex: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: -1, endIndex: 3}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 0, endIndex: 5}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', beginIndex: 2, endIndex: 1}") + public void substring_beginAndEndIndexOutOfRange_throwsException( + String string, int beginIndex, int endIndex) throws Exception { + ImmutableMap variables = + ImmutableMap.of("s", string, "beginIndex", beginIndex, "endIndex", endIndex); + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> eval("s.substring(beginIndex, endIndex)", variables)); + + String exceptionMessage = + String.format("substring failure: Range [%d, %d) out of bounds", beginIndex, endIndex); + assertThat(exception).hasMessageThat().contains(exceptionMessage); + } + + @Test + public void substring_beginIndexOverflow_throwsException() throws Exception { + ImmutableMap variables = + ImmutableMap.of("beginIndex", 2147483648L); // INT_MAX + 1 + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, () -> eval("'abcd'.substring(beginIndex)", variables)); + + assertThat(exception) + .hasMessageThat() + .contains("substring failure: Index must not exceed the int32 range: 2147483648"); + } + + @Test + @TestParameters("{beginIndex: 0, endIndex: 2147483648}") // INT_MAX + 1 + @TestParameters("{beginIndex: 2147483648, endIndex: 2147483648}") + public void substring_beginOrEndIndexOverflow_throwsException(long beginIndex, long endIndex) + throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> + eval( + "'abcd'.substring(beginIndex, endIndex)", + ImmutableMap.of("beginIndex", beginIndex, "endIndex", endIndex))); + + assertThat(exception) + .hasMessageThat() + .contains("substring failure: Indices must not exceed the int32 range"); + } + + @Test + @TestParameters("{string: '', index: 0, expectedResult: ''}") + @TestParameters("{string: 'world', index: 0, expectedResult: 'w'}") + @TestParameters("{string: 'world', index: 1, expectedResult: 'o'}") + @TestParameters("{string: 'world', index: 2, expectedResult: 'r'}") + @TestParameters("{string: 'world', index: 3, expectedResult: 'l'}") + @TestParameters("{string: 'world', index: 4, expectedResult: 'd'}") + @TestParameters("{string: 'world', index: 5, expectedResult: ''}") + public void charAt_ascii_success(String string, long index, String expectedResult) + throws Exception { + Object evaluatedResult = eval("s.charAt(index)", ImmutableMap.of("s", string, "index", index)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + // BMP + @TestParameters("{string: 'あいう', index: 2, expectedResult: 'う'}") + @TestParameters("{string: 'κ°€λ‚˜λ‹€', index: 3, expectedResult: ''}") + @TestParameters("{string: 'κ°€λ‚˜λ‹€', index: 1, expectedResult: 'λ‚˜'}") + // SMP + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', index: 0, expectedResult: '😁'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', index: 1, expectedResult: 'πŸ˜‘'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', index: 2, expectedResult: '😦'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', index: 3, expectedResult: ''}") + // BMP/SMP mixed + @TestParameters("{string: 'aπŸ˜λ‚˜', index: 0, expectedResult: 'a'}") + @TestParameters("{string: 'aπŸ˜λ‚˜', index: 1, expectedResult: '😁'}") + @TestParameters("{string: 'aπŸ˜λ‚˜', index: 2, expectedResult: 'λ‚˜'}") + @TestParameters("{string: 'aπŸ˜λ‚˜', index: 3, expectedResult: ''}") + public void charAt_unicode_success(String string, long index, String expectedResult) + throws Exception { + Object evaluatedResult = eval("s.charAt(index)", ImmutableMap.of("s", string, "index", index)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: 'world', index: -1}") + @TestParameters("{string: 'world', index: 6}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', index: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', index: 4}") + public void charAt_outOfBounds_throwsException(String string, long index) throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> eval("s.charAt(index)", ImmutableMap.of("s", string, "index", index))); + + assertThat(exception).hasMessageThat().contains("charAt failure: Index out of range"); + } + + @Test + public void charAt_indexOverflow_throwsException() throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> + eval("'test'.charAt(index)", ImmutableMap.of("index", 2147483648L))); // INT_MAX + 1 + + assertThat(exception) + .hasMessageThat() + .contains("charAt failure: Index must not exceed the int32 range: 2147483648"); + } + + @Test + @TestParameters("{string: '', indexOf: '', expectedResult: 0}") + @TestParameters("{string: 'hello mellow', indexOf: '', expectedResult: 0}") + @TestParameters("{string: 'hello mellow', indexOf: 'hello', expectedResult: 0}") + @TestParameters("{string: 'hello mellow', indexOf: 'hello mellow', expectedResult: 0}") + @TestParameters("{string: 'hello mellow', indexOf: 'ello', expectedResult: 1}") + @TestParameters("{string: 'hello mellow', indexOf: 'l', expectedResult: 2}") + @TestParameters("{string: 'hello mellow', indexOf: 'll', expectedResult: 2}") + @TestParameters("{string: 'hello mellow', indexOf: 'lo', expectedResult: 3}") + @TestParameters("{string: 'hello mellow', indexOf: 'o ', expectedResult: 4}") + @TestParameters("{string: 'hello mellow', indexOf: ' ', expectedResult: 5}") + @TestParameters("{string: 'hello mellow', indexOf: 'mellow', expectedResult: 6}") + @TestParameters("{string: 'hello mellow', indexOf: 'ellow', expectedResult: 7}") + @TestParameters("{string: 'hello mellow', indexOf: 'llow', expectedResult: 8}") + @TestParameters("{string: 'hello mellow', indexOf: 'low', expectedResult: 9}") + @TestParameters("{string: 'hello mellow', indexOf: 'ow', expectedResult: 10}") + @TestParameters("{string: 'hello mellow', indexOf: 'w', expectedResult: 11}") + @TestParameters("{string: 'hello mellow', indexOf: 'hellomellow', expectedResult: -1}") + @TestParameters("{string: 'hello mellow', indexOf: 'jello', expectedResult: -1}") + @TestParameters("{string: 'hello mellow', indexOf: ' ', expectedResult: -1}") + public void indexOf_ascii_success(String string, String indexOf, int expectedResult) + throws Exception { + Object evaluatedResult = + eval("s.indexOf(indexOfParam)", ImmutableMap.of("s", string, "indexOfParam", indexOf)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + // SMP + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: ' ', expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: ' ', expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: '😁', expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜‘', expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: '😦', expectedResult: 3}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: '😦', expectedResult: 3}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜πŸ˜‘', expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜‘ 😦', expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: ' 😦', expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: ' 😦 ', expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜πŸ˜‘ 😦', expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜πŸ˜‘πŸ˜¦', expectedResult: -1}") + // BMP/SMP Mixed + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: ' ', expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'πŸ˜πŸ˜‘', expectedResult: 1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'λ‚˜πŸ˜¦', expectedResult: 4}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'λ‚˜πŸ˜', expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', expectedResult: 0}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€πŸ˜', expectedResult: -1}") + public void indexOf_unicode_success(String string, String indexOf, int expectedResult) + throws Exception { + Object evaluatedResult = + eval("s.indexOf(indexOfParam)", ImmutableMap.of("s", string, "indexOfParam", indexOf)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{indexOf: ' '}") + @TestParameters("{indexOf: 'a'}") + @TestParameters("{indexOf: 'abc'}") + @TestParameters("{indexOf: 'λ‚˜'}") + @TestParameters("{indexOf: '😁'}") + public void indexOf_onEmptyString_throwsException(String indexOf) throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> eval("''.indexOf(indexOfParam)", ImmutableMap.of("indexOfParam", indexOf))); + + assertThat(exception).hasMessageThat().contains("indexOf failure: Offset out of range"); + } + + @Test + @TestParameters("{string: '', indexOf: '', offset: 0, expectedResult: 0}") + @TestParameters("{string: '', indexOf: '', offset: -5, expectedResult: -5}") // This is valid + @TestParameters("{string: 'hello mellow', indexOf: '', offset: -10, expectedResult: -10}") + @TestParameters("{string: 'hello mellow', indexOf: 'h', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'hello mellow', indexOf: 'h', offset: 1, expectedResult: -1}") + @TestParameters("{string: 'hello mellow', indexOf: 'hello', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'hello mellow', indexOf: 'ello', offset: 0, expectedResult: 1}") + @TestParameters("{string: 'hello mellow', indexOf: 'ello', offset: 1, expectedResult: 1}") + @TestParameters("{string: 'hello mellow', indexOf: 'ello', offset: 2, expectedResult: 7}") + @TestParameters("{string: 'hello mellow', indexOf: '', offset: 2, expectedResult: 2}") + @TestParameters("{string: 'hello mellow', indexOf: 'l', offset: 0, expectedResult: 2}") + @TestParameters("{string: 'hello mellow', indexOf: 'l', offset: 1, expectedResult: 2}") + @TestParameters("{string: 'hello mellow', indexOf: 'l', offset: 2, expectedResult: 2}") + @TestParameters("{string: 'hello mellow', indexOf: 'l', offset: 3, expectedResult: 3}") + @TestParameters("{string: 'hello mellow', indexOf: 'l', offset: 4, expectedResult: 8}") + @TestParameters("{string: 'hello mellow', indexOf: 'l', offset: 9, expectedResult: 9}") + @TestParameters("{string: 'hello mellow', indexOf: 'l', offset: 10, expectedResult: -1}") + public void indexOf_asciiWithOffset_success( + String string, String indexOf, int offset, int expectedResult) throws Exception { + Object evaluatedResult = + eval( + "s.indexOf(indexOfParam, offset)", + ImmutableMap.of("s", string, "indexOfParam", indexOf, "offset", offset)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + // SMP + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜πŸ˜‘ 😦', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜πŸ˜‘ 😦', offset: 1, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜πŸ˜‘πŸ˜¦', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: ' ', offset: 0, expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: '😁', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜‘', offset: 0, expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜‘', offset: 1, expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜‘', offset: 2, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜πŸ˜‘', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜πŸ˜‘ ', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜‘ 😦', offset: 0, expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜‘ 😦', offset: 1, expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: 'πŸ˜‘ 😦', offset: 2, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: ' 😦', offset: 0, expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: ' 😦', offset: 1, expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: '😦', offset: 2, expectedResult: 3}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: '😦', offset: 3, expectedResult: 3}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: '😦 ', offset: 3, expectedResult: -1}") + // BMP/SMP Mixed + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: ' ', offset: 0, expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: ' ', offset: 3, expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: ' ', offset: 4, expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'πŸ˜πŸ˜‘', offset: 1, expectedResult: 1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'πŸ˜πŸ˜‘', offset: 3, expectedResult: 6}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'πŸ˜πŸ˜‘', offset: 6, expectedResult: 6}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'πŸ˜πŸ˜‘', offset: 7, expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'λ‚˜πŸ˜¦', offset: 0, expectedResult: 4}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'λ‚˜πŸ˜¦', offset: 4, expectedResult: 4}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'λ‚˜πŸ˜', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 0, expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 3, expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 4, expectedResult: -1}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 0, expectedResult: 0}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 1, expectedResult: -1}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', indexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€πŸ˜', offset: 0, expectedResult: -1}") + public void indexOf_unicodeWithOffset_success( + String string, String indexOf, int offset, int expectedResult) throws Exception { + Object evaluatedResult = + eval( + "s.indexOf(indexOfParam, offset)", + ImmutableMap.of("s", string, "indexOfParam", indexOf, "offset", offset)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: '', indexOf: ' ', offset: 1}") + @TestParameters("{string: 'hello mellow', indexOf: 'hello', offset: 12}") + @TestParameters("{string: 'hello mellow', indexOf: 'mellow', offset: 12}") + @TestParameters("{string: 'πŸ˜πŸ˜‘', indexOf: '😁', offset: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘d', indexOf: '😁', offset: 5}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', indexOf: '😦', offset: 4}") + public void indexOf_withOffsetOutOfBounds_throwsException( + String string, String indexOf, int offset) throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> + eval( + "s.indexOf(indexOfParam, offset)", + ImmutableMap.of("s", string, "indexOfParam", indexOf, "offset", offset))); + + assertThat(exception).hasMessageThat().contains("indexOf failure: Offset out of range"); + } + + @Test + public void indexOf_offsetOverflow_throwsException() throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> + eval( + "'test'.indexOf('t', offset)", + ImmutableMap.of("offset", 2147483648L))); // INT_MAX + 1 + + assertThat(exception) + .hasMessageThat() + .contains("indexOf failure: Offset must not exceed the int32 range: 2147483648"); + } + + @Test + @TestParameters("{list: '[]', expectedResult: ''}") + @TestParameters("{list: '['' '']', expectedResult: ' '}") + @TestParameters("{list: '[''x'']', expectedResult: 'x'}") + @TestParameters("{list: '[''x'', ''y'']', expectedResult: 'xy'}") + @TestParameters("{list: '[''x'', dyn(''y'')]', expectedResult: 'xy'}") + @TestParameters("{list: '[dyn(''x''), dyn(''y'')]', expectedResult: 'xy'}") + @TestParameters("{list: '[''x'', '' '', '' y '', ''z '']', expectedResult: 'x y z '}") + @TestParameters("{list: '[''hello '', ''world'']', expectedResult: 'hello world'}") + public void join_ascii_success(String list, String expectedResult) throws Exception { + String result = (String) eval(String.format("%s.join()", list)); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{list: '[''κ°€'', ''😁'']', expectedResult: 'κ°€πŸ˜'}") + @TestParameters("{list: '[''πŸ˜πŸ˜¦πŸ˜‘ 😦'', ''λ‚˜'']', expectedResult: 'πŸ˜πŸ˜¦πŸ˜‘ πŸ˜¦λ‚˜'}") + public void join_unicode_success(String list, String expectedResult) throws Exception { + String result = (String) eval(String.format("%s.join()", list)); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{list: '[]', separator: '', expectedResult: ''}") + @TestParameters("{list: '[]', separator: '-', expectedResult: ''}") + @TestParameters("{list: '['' '']', separator: '', expectedResult: ' '}") + @TestParameters("{list: '['' '']', separator: '-', expectedResult: ' '}") + @TestParameters("{list: '[''x'']', separator: '', expectedResult: 'x'}") + @TestParameters("{list: '[''x'']', separator: '+', expectedResult: 'x'}") + @TestParameters("{list: '[''x'', ''y'']', separator: ' ', expectedResult: 'x y'}") + @TestParameters("{list: '[''x'', ''y'']', separator: '+', expectedResult: 'x+y'}") + @TestParameters("{list: '[''x'', dyn(''y'')]', separator: ' $ ', expectedResult: 'x $ y'}") + @TestParameters("{list: '[dyn(''x''), dyn(''y'')]', separator: 'x', expectedResult: 'xxy'}") + @TestParameters( + "{list: '[''x'', '' '', '' y '', ''z '']', separator: '', expectedResult: 'x y z '}") + @TestParameters( + "{list: '[''x'', '' '', '' y '', ''z '']', separator: '+', expectedResult: 'x+ + y +z '}") + @TestParameters( + "{list: '[''hello '', ''world'']', separator: '/', expectedResult: 'hello /world'}") + public void join_asciiWithSeparator_success(String list, String separator, String expectedResult) + throws Exception { + String result = (String) eval(String.format("%s.join('%s')", list, separator)); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{list: '[''κ°€'', ''😁'']', separator: '', expectedResult: 'κ°€πŸ˜'}") + @TestParameters("{list: '[''κ°€'', ''😁'']', separator: ' ', expectedResult: 'κ°€ 😁'}") + @TestParameters("{list: '[''κ°€'', ''😁'']', separator: '+', expectedResult: 'κ°€+😁'}") + @TestParameters("{list: '[''πŸ˜πŸ˜¦πŸ˜‘ 😦'', ''λ‚˜'']', separator: 't', expectedResult: 'πŸ˜πŸ˜¦πŸ˜‘ 😦tλ‚˜'}") + @TestParameters( + "{list: '[''😁😦'', ''a'', '' '', ''πŸ˜‘'', ''λ‚˜'']', separator: '-', expectedResult: '😁😦-a-" + + " -πŸ˜‘-λ‚˜'}") + public void join_unicodeWithSeparator_success( + String list, String separator, String expectedResult) throws Exception { + String result = (String) eval(String.format("%s.join('%s')", list, separator)); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + public void join_separatorIsNonString_throwsException() { + // This is a type-check failure. + Assume.assumeFalse(isParseOnly); + CelValidationException exception = + assertThrows(CelValidationException.class, () -> cel.compile("['x','y'].join(2)").getAst()); + + assertThat(exception).hasMessageThat().contains("found no matching overload for 'join'"); + } + + @Test + @TestParameters("{string: '@', lastIndexOf: '@@', expectedResult: -1}") + @TestParameters("{string: '', lastIndexOf: '', expectedResult: 0}") + @TestParameters("{string: 'hello mellow', lastIndexOf: '', expectedResult: 12}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'hello', expectedResult: 0}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'hello mellow', expectedResult: 0}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'ello', expectedResult: 7}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'l', expectedResult: 9}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'll', expectedResult: 8}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'lo', expectedResult: 9}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'o', expectedResult: 10}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'o ', expectedResult: 4}") + @TestParameters("{string: 'hello mellow', lastIndexOf: ' ', expectedResult: 5}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'mellow', expectedResult: 6}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'ellow', expectedResult: 7}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'llow', expectedResult: 8}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'low', expectedResult: 9}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'ow', expectedResult: 10}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'w', expectedResult: 11}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'hellomellow', expectedResult: -1}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'jello', expectedResult: -1}") + @TestParameters("{string: 'hello mellow', lastIndexOf: ' ', expectedResult: -1}") + public void lastIndexOf_ascii_success(String string, String lastIndexOf, int expectedResult) + throws Exception { + Object evaluatedResult = + eval( + "s.lastIndexOf(indexOfParam)", + ImmutableMap.of("s", string, "indexOfParam", lastIndexOf)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + // SMP + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: ' ', expectedResult: 3}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: ' ', expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😁', expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜‘', expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😦', expectedResult: 4}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜πŸ˜‘', expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜‘ 😦', expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: ' 😦', expectedResult: 3}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜¦πŸ˜‘', expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: ' 😦 ', expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜πŸ˜¦πŸ˜‘πŸ˜¦', expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜πŸ˜‘πŸ˜¦', expectedResult: -1}") + // BMP/SMP Mixed + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' ', expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'πŸ˜πŸ˜‘', expectedResult: 6}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'λ‚˜πŸ˜¦', expectedResult: 4}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'λ‚˜πŸ˜', expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', expectedResult: 0}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€πŸ˜', expectedResult: -1}") + public void lastIndexOf_unicode_success(String string, String lastIndexOf, int expectedResult) + throws Exception { + Object evaluatedResult = + eval( + "s.lastIndexOf(indexOfParam)", + ImmutableMap.of("s", string, "indexOfParam", lastIndexOf)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{lastIndexOf: '@@'}") + @TestParameters("{lastIndexOf: ' '}") + @TestParameters("{lastIndexOf: 'a'}") + @TestParameters("{lastIndexOf: 'abc'}") + @TestParameters("{lastIndexOf: 'λ‚˜'}") + @TestParameters("{lastIndexOf: '😁'}") + public void lastIndexOf_strLengthLessThanSubstrLength_returnsMinusOne(String lastIndexOf) + throws Exception { + Object evaluatedResult = + eval("''.lastIndexOf(indexOfParam)", ImmutableMap.of("s", "", "indexOfParam", lastIndexOf)); + + assertThat(evaluatedResult).isEqualTo(-1); + } + + @Test + @TestParameters("{string: '', lastIndexOf: '', offset: 0, expectedResult: 0}") + @TestParameters("{string: '', lastIndexOf: '', offset: -5, expectedResult: -5}") // This is valid + @TestParameters("{string: 'hello mellow', lastIndexOf: '', offset: 2, expectedResult: 2}") + @TestParameters("{string: 'hello mellow', lastIndexOf: '', offset: -10, expectedResult: -10}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'h', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'h', offset: 1, expectedResult: 0}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'hello', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'ello', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'ello', offset: 1, expectedResult: 1}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'ello', offset: 6, expectedResult: 1}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'ello', offset: 7, expectedResult: 7}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'l', offset: 2, expectedResult: 2}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'l', offset: 3, expectedResult: 3}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'l', offset: 4, expectedResult: 3}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'l', offset: 8, expectedResult: 8}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'l', offset: 9, expectedResult: 9}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'l', offset: 10, expectedResult: 9}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'l', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'l', offset: 1, expectedResult: -1}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'lo', offset: 3, expectedResult: 3}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'lo', offset: 10, expectedResult: 9}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'lo ', offset: 10, expectedResult: 3}") + @TestParameters( + "{string: 'hello mellow', lastIndexOf: 'hello mellowwww ', offset: 11, expectedResult: -1}") + public void lastIndexOf_asciiWithOffset_success( + String string, String lastIndexOf, int offset, int expectedResult) throws Exception { + Object evaluatedResult = + eval( + "s.lastIndexOf(indexOfParam, offset)", + ImmutableMap.of("s", string, "indexOfParam", lastIndexOf, "offset", offset)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + // SMP + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', offset: 1, expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜πŸ˜‘πŸ˜¦', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: ' ', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: ' ', offset: 2, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: ' ', offset: 3, expectedResult: 3}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😁', offset: 0, expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😁', offset: 4, expectedResult: 0}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜‘', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜‘', offset: 1, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜‘', offset: 2, expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜‘', offset: 3, expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜πŸ˜‘', offset: 4, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜¦πŸ˜‘', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜¦πŸ˜‘', offset: 1, expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜¦πŸ˜‘ ', offset: 1, expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜‘ 😦', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜‘ 😦', offset: 1, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: 'πŸ˜‘ 😦', offset: 2, expectedResult: 2}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: ' 😦', offset: 1, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: ' 😦', offset: 3, expectedResult: 3}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😦', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😦', offset: 1, expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😦', offset: 2, expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😦', offset: 3, expectedResult: 1}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😦', offset: 4, expectedResult: 4}") + @TestParameters("{string: 'πŸ˜πŸ˜¦πŸ˜‘ 😦', lastIndexOf: '😦 ', offset: 4, expectedResult: -1}") + // BMP/SMP Mixed + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' ', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' ', offset: 2, expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' ', offset: 3, expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' ', offset: 8, expectedResult: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'πŸ˜πŸ˜‘', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'πŸ˜πŸ˜‘', offset: 1, expectedResult: 1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'πŸ˜πŸ˜‘', offset: 5, expectedResult: 1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'πŸ˜πŸ˜‘', offset: 6, expectedResult: 6}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'πŸ˜πŸ˜‘', offset: 8, expectedResult: 6}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'λ‚˜πŸ˜¦', offset: 0, expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'λ‚˜πŸ˜¦', offset: 3, expectedResult: -1}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'λ‚˜πŸ˜¦', offset: 4, expectedResult: 4}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'λ‚˜πŸ˜¦', offset: 8, expectedResult: 4}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'λ‚˜πŸ˜', offset: 8, expectedResult: -1}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 0, expectedResult: -1}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 2, expectedResult: -1}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 3, expectedResult: 3}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 4, expectedResult: 3}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: ' λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 8, expectedResult: 3}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 0, expectedResult: 0}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 1, expectedResult: 0}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', offset: 8, expectedResult: 0}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€πŸ˜', offset: 0, expectedResult: -1}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', lastIndexOf: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€πŸ˜', offset: 8, expectedResult: -1}") + public void lastIndexOf_unicodeWithOffset_success( + String string, String lastIndexOf, int offset, int expectedResult) throws Exception { + Object evaluatedResult = + eval( + "s.lastIndexOf(indexOfParam, offset)", + ImmutableMap.of("s", string, "indexOfParam", lastIndexOf, "offset", offset)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: '', lastIndexOf: ' ', offset: 1}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'hello', offset: 12}") + @TestParameters("{string: 'hello mellow', lastIndexOf: 'mellow', offset: 12}") + @TestParameters("{string: 'πŸ˜πŸ˜‘', lastIndexOf: '😁', offset: 3}") + @TestParameters("{string: 'aπŸ˜πŸ˜‘d', lastIndexOf: '😁', offset: 5}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', lastIndexOf: '😦', offset: 4}") + public void lastIndexOf_withOffsetOutOfBounds_throwsException( + String string, String lastIndexOf, int offset) throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> + eval( + "s.lastIndexOf(indexOfParam, offset)", + ImmutableMap.of("s", string, "indexOfParam", lastIndexOf, "offset", offset))); + + assertThat(exception).hasMessageThat().contains("lastIndexOf failure: Offset out of range"); + } + + @Test + public void lastIndexOf_offsetOverflow_throwsException() throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> + eval( + "'test'.lastIndexOf('t', offset)", + ImmutableMap.of("offset", 2147483648L))); // INT_MAX + 1 + + assertThat(exception) + .hasMessageThat() + .contains("lastIndexOf failure: Offset must not exceed the int32 range: 2147483648"); + } + + @Test + @TestParameters("{string: '', searchString: '', replacement: '', expectedResult: ''}") + @TestParameters("{string: '', searchString: '', replacement: 'hi', expectedResult: 'hi'}") + @TestParameters("{string: '', searchString: 'test', replacement: 'hi', expectedResult: ''}") + @TestParameters("{string: 'a b', searchString: '', replacement: 'a', expectedResult: 'aaa aba'}") + @TestParameters( + "{string: 'hello hello hello', searchString: 'hello', replacement: 'hi', expectedResult: 'hi" + + " hi hi'}") + @TestParameters( + "{string: 'hello hello hello', searchString: 'hello ', replacement: 'hi', expectedResult:" + + " 'hihihello'}") + @TestParameters( + "{string: 'hello hello hello', searchString: '', replacement: 'hi', expectedResult:" + + " 'hihhiehilhilhiohi hihhiehilhilhiohi hihhiehilhilhiohi'}") + @TestParameters( + "{string: '!@#$%^&*/();?:\\\\', searchString: '!@#$%^&*/();?:\\\\', replacement: 'test'," + + " expectedResult: 'test'}") + public void replace_ascii_success( + String string, String searchString, String replacement, String expectedResult) + throws Exception { + Object evaluatedResult = + eval(String.format("'%s'.replace('%s', '%s')", string, searchString, replacement)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: 'πŸ˜πŸ˜‘', searchString: '', replacement: 'a', expectedResult: 'a😁aπŸ˜‘a'}") + @TestParameters( + "{string: 'πŸ˜πŸ˜‘πŸ˜¦ πŸ˜πŸ˜‘πŸ˜¦', searchString: 'πŸ˜πŸ˜‘', replacement: 'πŸ˜†', expectedResult: 'πŸ˜†πŸ˜¦" + + " πŸ˜†πŸ˜¦'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: '', replacement: 'test', expectedResult:" + + " 'testatest😁testπŸ˜‘test testλ‚˜test😦test😁testπŸ˜‘testλ‹€test'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: 'πŸ˜πŸ˜‘', replacement: ' λ‚˜πŸ˜¦πŸ˜', expectedResult: 'a" + + " λ‚˜πŸ˜¦πŸ˜ λ‚˜πŸ˜¦ λ‚˜πŸ˜¦πŸ˜λ‹€'}") + public void replace_unicode_success( + String string, String searchString, String replacement, String expectedResult) + throws Exception { + Object evaluatedResult = + eval(String.format("'%s'.replace('%s', '%s')", string, searchString, replacement)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: '', searchString: '', replacement: '', limit: -1, expectedResult: ''}") + @TestParameters( + "{string: '', searchString: '', replacement: 'hi', limit: -1, expectedResult: 'hi'}") + @TestParameters("{string: '', searchString: '', replacement: 'hi', limit: 0, expectedResult: ''}") + @TestParameters( + "{string: '', searchString: '', replacement: 'hi', limit: 1, expectedResult: 'hi'}") + @TestParameters( + "{string: '', searchString: '', replacement: 'hi', limit: 2, expectedResult: 'hi'}") + @TestParameters( + "{string: '', searchString: 'test', replacement: 'hi', limit: -1, expectedResult: ''}") + @TestParameters( + "{string: '', searchString: 'test', replacement: 'hi', limit: 0, expectedResult: ''}") + @TestParameters( + "{string: '', searchString: 'test', replacement: 'hi', limit: 1, expectedResult: ''}") + @TestParameters( + "{string: 'a b', searchString: '', replacement: 'a', limit: 0, expectedResult: 'a b'}") + @TestParameters( + "{string: 'a b', searchString: '', replacement: 'a', limit: 1, expectedResult: 'aa b'}") + @TestParameters( + "{string: 'a b', searchString: '', replacement: 'a', limit: 2, expectedResult: 'aaa b'}") + @TestParameters( + "{string: 'a b', searchString: '', replacement: 'a', limit: 3, expectedResult: 'aaa ab'}") + @TestParameters( + "{string: 'a b', searchString: '', replacement: 'a', limit: 4, expectedResult: 'aaa aba'}") + @TestParameters( + "{string: 'a b', searchString: '', replacement: 'a', limit: 5, expectedResult: 'aaa aba'}") + @TestParameters( + "{string: 'a b', searchString: '', replacement: 'a', limit: -1, expectedResult: 'aaa aba'}") + @TestParameters( + "{string: 'hello', searchString: 'random', replacement: 'hi', limit: 1, expectedResult:" + + " 'hello'}") + @TestParameters( + "{string: 'hello hello hello', searchString: 'hello', replacement: 'hi', limit: -1," + + " expectedResult: 'hi hi hi'}") + @TestParameters( + "{string: 'hello hello hello', searchString: 'hello', replacement: 'hi', limit: 0," + + " expectedResult: 'hello hello hello'}") + @TestParameters( + "{string: 'hello hello hello', searchString: 'hello', replacement: 'hi', limit: 1," + + " expectedResult: 'hi hello hello'}") + @TestParameters( + "{string: 'hello hello hello', searchString: 'hello', replacement: 'hi', limit: 2," + + " expectedResult: 'hi hi hello'}") + @TestParameters( + "{string: 'hello hello hello', searchString: 'hello', replacement: 'hi', limit: 3," + + " expectedResult: 'hi hi hi'}") + @TestParameters( + "{string: 'hello hello hello', searchString: 'hello hello', replacement: 'hi hello', limit:" + + " 1, expectedResult: 'hi hello hello'}") + @TestParameters( + "{string: 'hello hello hello', searchString: 'hello hello hello', replacement: '', limit:" + + " 1, expectedResult: ''}") + @TestParameters( + "{string: 'hello hello', searchString: 'he', replacement: 'we', limit: 1," + + " expectedResult: 'wello hello'}") + @TestParameters( + "{string: 'hello hello hello', searchString: '', replacement: 'hi', limit: -1," + + " expectedResult: 'hihhiehilhilhiohi hihhiehilhilhiohi hihhiehilhilhiohi'}") + @TestParameters( + "{string: 'hello hello hello', searchString: '', replacement: 'hi', limit: 0," + + " expectedResult: 'hello hello hello'}") + @TestParameters( + "{string: 'hello hello hello', searchString: '', replacement: 'hi', limit: 1," + + " expectedResult: 'hihello hello hello'}") + @TestParameters( + "{string: 'hello hello hello', searchString: '', replacement: 'hi', limit: 2," + + " expectedResult: 'hihhiello hello hello'}") + @TestParameters( + "{string: '!@#$%^&*/();?:\\\\', searchString: '!@#$%^&*/();?:\\\\', replacement: 'test'," + + " limit: 1, expectedResult: 'test'}") + public void replace_ascii_withLimit_success( + String string, String searchString, String replacement, int limit, String expectedResult) + throws Exception { + Object evaluatedResult = + eval( + String.format( + "'%s'.replace('%s', '%s', %d)", string, searchString, replacement, limit)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters( + "{string: 'πŸ˜πŸ˜‘', searchString: '', replacement: 'a', limit: -1, expectedResult: 'a😁aπŸ˜‘a'}") + @TestParameters( + "{string: 'πŸ˜πŸ˜‘πŸ˜¦ πŸ˜πŸ˜‘πŸ˜¦', searchString: 'πŸ˜πŸ˜‘', replacement: 'πŸ˜†', limit: -1," + + " expectedResult: 'πŸ˜†πŸ˜¦ πŸ˜†πŸ˜¦'}") + @TestParameters( + "{string: 'πŸ˜πŸ˜‘πŸ˜¦ πŸ˜πŸ˜‘πŸ˜¦', searchString: 'πŸ˜πŸ˜‘', replacement: 'πŸ˜†', limit: 0," + + " expectedResult: 'πŸ˜πŸ˜‘πŸ˜¦ πŸ˜πŸ˜‘πŸ˜¦'}") + @TestParameters( + "{string: 'πŸ˜πŸ˜‘πŸ˜¦ πŸ˜πŸ˜‘πŸ˜¦', searchString: 'πŸ˜πŸ˜‘', replacement: 'πŸ˜†', limit: 1," + + " expectedResult: 'πŸ˜†πŸ˜¦ πŸ˜πŸ˜‘πŸ˜¦'}") + @TestParameters( + "{string: 'πŸ˜πŸ˜‘πŸ˜¦ πŸ˜πŸ˜‘πŸ˜¦', searchString: 'πŸ˜πŸ˜‘', replacement: 'πŸ˜†', limit: 2," + + " expectedResult: 'πŸ˜†πŸ˜¦ πŸ˜†πŸ˜¦'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: '', replacement: 'test', limit: -1, expectedResult:" + + " 'testatest😁testπŸ˜‘test testλ‚˜test😦test😁testπŸ˜‘testλ‹€test'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: '', replacement: 'test', limit: 0, expectedResult:" + + " 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: '', replacement: 'test', limit: 1, expectedResult:" + + " 'testaπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: '', replacement: 'test', limit: 2, expectedResult:" + + " 'testatestπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: '', replacement: 'test', limit: 3, expectedResult:" + + " 'testatest😁testπŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: '', replacement: 'test', limit: 4, expectedResult:" + + " 'testatest😁testπŸ˜‘test λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: 'πŸ˜πŸ˜‘', replacement: ' λ‚˜πŸ˜¦πŸ˜', limit: -1," + + " expectedResult: 'a λ‚˜πŸ˜¦πŸ˜ λ‚˜πŸ˜¦ λ‚˜πŸ˜¦πŸ˜λ‹€'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: 'πŸ˜πŸ˜‘', replacement: ' λ‚˜πŸ˜¦πŸ˜', limit: 0," + + " expectedResult: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: 'πŸ˜πŸ˜‘', replacement: ' λ‚˜πŸ˜¦πŸ˜', limit: 1," + + " expectedResult: 'a λ‚˜πŸ˜¦πŸ˜ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€'}") + @TestParameters( + "{string: 'aπŸ˜πŸ˜‘ λ‚˜πŸ˜¦πŸ˜πŸ˜‘λ‹€', searchString: 'πŸ˜πŸ˜‘', replacement: ' λ‚˜πŸ˜¦πŸ˜', limit: 2," + + " expectedResult: 'a λ‚˜πŸ˜¦πŸ˜ λ‚˜πŸ˜¦ λ‚˜πŸ˜¦πŸ˜λ‹€'}") + public void replace_unicode_withLimit_success( + String string, String searchString, String replacement, int limit, String expectedResult) + throws Exception { + Object evaluatedResult = + eval( + String.format( + "'%s'.replace('%s', '%s', %d)", string, searchString, replacement, limit)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + public void replace_limitOverflow_throwsException() throws Exception { + CelEvaluationException exception = + assertThrows( + CelEvaluationException.class, + () -> + eval( + "'test'.replace('','',index)", + ImmutableMap.of("index", 2147483648L))); // INT_MAX + 1 + + assertThat(exception) + .hasMessageThat() + .contains("replace failure: Index must not exceed the int32 range: 2147483648"); + } + + private enum TrimTestCase { + ASCII_EMPTY("", ""), + ASCII_NO_TRIM("test test", "test test"), + ASCII_LEFT_TRIM(" test test", "test test"), + ASCII_RIGHT_TRIM("test test ", "test test"), + ASCII_ALL_TRIM(" test test ", "test test"), + BMP_SMP_NO_TRIM("text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘", "text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘"), + BMP_SMP_LEFT_TRIM(" text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘", "text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘"), + BMP_SMP_RIGHT_TRIM("text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘ ", "text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘"), + BMP_SMP_ALL_TRIM(" text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘ ", "text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘"), + ESCAPE_SEQUENCES( + " \f\n\r\ttext ", + "text"), // Note: vertical tab (\v) is included below as an escaped sequence (U+000B). + ALL_WHITESPACES( + "\u000b\u0085\u00a0\u1680\u200a\u2028\u2029\u202F\u205F\u3000\u2000\u2001\u2002\u2003\u2004\u2004\u2006\u2007\u2008\u2009", + ""), + WHITESPACES_ASCII_1("\u000b\u0085\u00a0\u1680text", "text"), + WHITESPACES_ASCII_2("text\u2000\u2001\u2002\u2003\u2004\u2004\u2006\u2007\u2008\u2009", "text"), + WHITESPACES_ASCII_3("\u200atext\u2028\u2029\u202F\u205F\u3000", "text"), + WHITESPACES_BMP_SMP_MIXED_1( + "\u000b\u0085\u00a0\u1680\u200a\u2028\u2029text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘ " + + "\u202F\u205F\u3000\u2000\u2001\u2002\u2003\u2004\u2004\u2006\u2007\u2008\u2009", + "text κ°€λ‚˜λ‹€ πŸ˜¦πŸ˜πŸ˜‘"), + // Trim test with whitespace-like characters not included. + WHITESPACE_LIKE( + "\u180etext\u200b\u200c\u200d\u2060\ufeff", "\u180etext\u200b\u200c\u200d\u2060\ufeff"), + // Whitespaces in between non-whitespace characters are not removed + WHITESPACES_IN_BETWEEN( + "test\u000b\u0085\u00a0\u1680\u200a\u2028\u2029πŸ˜¦πŸ˜πŸ˜‘" + + "\u202F\u205F\u3000\u2000\u2001\u2002\u2003\u2004\u2004\u2006\u2007\u2008\u2009test", + "test\u000b\u0085\u00a0\u1680\u200a\u2028\u2029πŸ˜¦πŸ˜πŸ˜‘" + + "\u202F\u205F\u3000\u2000\u2001\u2002\u2003\u2004\u2004\u2006\u2007\u2008\u2009test"); + + private final String text; + private final String expectedResult; + + TrimTestCase(String text, String expectedResult) { + this.text = text; + this.expectedResult = expectedResult; + } + } + + @Test + public void trim_success(@TestParameter TrimTestCase testCase) throws Exception { + Object evaluatedResult = eval("s.trim()", ImmutableMap.of("s", testCase.text)); + + assertThat(evaluatedResult).isEqualTo(testCase.expectedResult); + } + + @Test + @TestParameters("{string: '', expectedResult: ''}") + @TestParameters("{string: 'hello world', expectedResult: 'HELLO WORLD'}") + @TestParameters("{string: 'HELLO WORLD', expectedResult: 'HELLO WORLD'}") + @TestParameters("{string: 'HeLlO wOrLd', expectedResult: 'HELLO WORLD'}") + @TestParameters( + "{string: 'a!@#$%^&*()-_+=?/<>.,;:''\"\\', expectedResult: 'A!@#$%^&*()-_+=?/<>.,;:''\"\\'}") + public void upperAscii_success(String string, String expectedResult) throws Exception { + Object evaluatedResult = eval("s.upperAscii()", ImmutableMap.of("s", string)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + // Some of these characters from Latin Extended plane have a lowercase mapping. + // In CEL's String extension, we do not transform these because they are outside Latin-1 + @TestParameters("{string: 'Γ€ΓŸΓ αΈ€αΈαΈ‚αΈƒ', expectedResult: 'Γ€ΓŸΓ αΈ€αΈαΈ‚αΈƒ'}") + @TestParameters("{string: 'κ°€λ‚˜λ‹€λΌ λ§ˆλ°”μ‚¬', expectedResult: 'κ°€λ‚˜λ‹€λΌ λ§ˆλ°”μ‚¬'}") + @TestParameters("{string: 'aκ°€bλ‚˜cλ‹€d라e 마fλ°”g사h', expectedResult: 'Aκ°€Bλ‚˜Cλ‹€D라E 마Fλ°”G사H'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', expectedResult: 'πŸ˜πŸ˜‘πŸ˜¦'}") + @TestParameters("{string: 'πŸ˜πŸ˜‘ 😦', expectedResult: 'πŸ˜πŸ˜‘ 😦'}") + @TestParameters("{string: 'a😁b πŸ˜‘cκ°€πŸ˜¦d', expectedResult: 'A😁B πŸ˜‘Cκ°€πŸ˜¦D'}") + public void upperAscii_outsideAscii_success(String string, String expectedResult) + throws Exception { + Object evaluatedResult = eval("s.upperAscii()", ImmutableMap.of("s", string)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + public void stringExtension_functionSubset_success() throws Exception { + Cel customCel = + runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.strings(Function.CHAR_AT, Function.SUBSTRING)) + .addRuntimeLibraries(CelExtensions.strings(Function.CHAR_AT, Function.SUBSTRING)) + .build(); + + Object evaluatedResult = + eval(customCel, "'test'.substring(2) == 'st' && 'hello'.charAt(1) == 'e'"); + + assertThat(evaluatedResult).isEqualTo(true); + } + + @Test + @TestParameters("{string: 'abcd', expectedResult: 'dcba'}") + @TestParameters("{string: '', expectedResult: ''}") + @TestParameters("{string: 'a', expectedResult: 'a'}") + @TestParameters("{string: 'hello world', expectedResult: 'dlrow olleh'}") + @TestParameters("{string: 'abκ°€cd', expectedResult: 'dcκ°€ba'}") + public void reverse_success(String string, String expectedResult) throws Exception { + Object evaluatedResult = eval("s.reverse()", ImmutableMap.of("s", string)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: 'πŸ˜πŸ˜‘πŸ˜¦', expectedResult: 'πŸ˜¦πŸ˜‘πŸ˜'}") + @TestParameters( + "{string: '\u180e\u200b\u200c\u200d\u2060\ufeff', expectedResult:" + + " '\ufeff\u2060\u200d\u200c\u200b\u180e'}") + public void reverse_unicode(String string, String expectedResult) throws Exception { + Object evaluatedResult = eval("s.reverse()", ImmutableMap.of("s", string)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{string: 'hello', expectedResult: '\"hello\"'}") + @TestParameters("{string: '', expectedResult: '\"\"'}") + @TestParameters( + "{string: 'contains \\\\\\\"quotes\\\\\\\"', expectedResult: '\"contains" + + " \\\\\\\\\\\\\\\"quotes\\\\\\\\\\\\\\\"\"'}") + @TestParameters( + "{string: 'ends with \\\\\\\\', expectedResult: '\"ends with \\\\\\\\\\\\\\\\\"'}") + @TestParameters( + "{string: '\\\\\\\\ starts with', expectedResult: '\"\\\\\\\\\\\\\\\\ starts with\"'}") + public void quote_success(String string, String expectedResult) throws Exception { + Object evaluatedResult = eval("strings.quote(s)", ImmutableMap.of("s", string)); + + assertThat(evaluatedResult).isEqualTo(expectedResult); + } + + @Test + public void quote_singleWithDoubleQuotes() throws Exception { + String expr = "strings.quote('single-quote with \"double quote\"')"; + String expected = "\"\\\"single-quote with \\\\\\\"double quote\\\\\\\"\\\"\""; + Object evaluatedResult = eval(expr + " == " + expected); + + assertThat(evaluatedResult).isEqualTo(true); + } + + @Test + public void quote_escapesSpecialCharacters() throws Exception { + Object evaluatedResult = + eval( + "strings.quote(s)", + ImmutableMap.of("s", "\u0007bell\u000Bvtab\bback\ffeed\rret\nline\ttab\\slash κ°€ 😁")); + + assertThat(evaluatedResult) + .isEqualTo("\"\\abell\\vvtab\\bback\\ffeed\\rret\\nline\\ttab\\\\slash κ°€ 😁\""); + } + + @Test + public void quote_escapesMalformed_endWithHighSurrogate() throws Exception { + assertThat(eval("strings.quote(s)", ImmutableMap.of("s", "end with high surrogate \uD83D"))) + .isEqualTo("\"end with high surrogate \uFFFD\""); + } + + @Test + public void quote_escapesMalformed_unpairedHighSurrogate() throws Exception { + assertThat(eval("strings.quote(s)", ImmutableMap.of("s", "bad pair \uD83DA"))) + .isEqualTo("\"bad pair \uFFFDA\""); + } + + @Test + public void quote_escapesMalformed_unpairedLowSurrogate() throws Exception { + assertThat(eval("strings.quote(s)", ImmutableMap.of("s", "bad pair \uDC00A"))) + .isEqualTo("\"bad pair \uFFFDA\""); + } + + @Test + public void stringExtension_compileUnallowedFunction_throws() { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries(CelExtensions.strings(Function.REPLACE)) + .build(); + + // This is a type-check failure. + Assume.assumeFalse(isParseOnly); + CelValidationResult result = celCompiler.compile("'test'.substring(2) == 'st'"); + assertThrows(CelValidationException.class, () -> result.getAst()); + } + + @Test + public void stringExtension_evaluateUnallowedFunction_throws() throws Exception { + Cel customCompilerCel = + runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.strings(Function.SUBSTRING)) + .build(); + Cel customRuntimeCel = + runtimeFlavor + .builder() + .addRuntimeLibraries(CelExtensions.strings(Function.REPLACE)) + .build(); + CelAbstractSyntaxTree ast = + isParseOnly + ? customCompilerCel.parse("'test'.substring(2) == 'st'").getAst() + : customCompilerCel.compile("'test'.substring(2) == 'st'").getAst(); + + assertThrows(CelEvaluationException.class, () -> customRuntimeCel.createProgram(ast).eval()); + } + + +} diff --git a/java_lite_proto_cel_library.bzl b/java_lite_proto_cel_library.bzl new file mode 100644 index 000000000..efed0bedc --- /dev/null +++ b/java_lite_proto_cel_library.bzl @@ -0,0 +1,54 @@ +# Copyright 2025 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. + +"""Starlark rule for generating descriptors that is compatible with Protolite Messages.""" + +load("//:java_lite_proto_cel_library_impl.bzl", "java_lite_proto_cel_library_impl") +load("@com_google_protobuf//bazel:java_lite_proto_library.bzl", "java_lite_proto_library") + +def java_lite_proto_cel_library( + name, + deps, + java_descriptor_class_suffix = None, + debug = False): + """Generates a CelLiteDescriptor + + Args: + name: name of this target. + deps: The list of proto_library rules to generate Java code for. + proto_src: Name of the proto_library target. + java_descriptor_class_suffix (optional): Suffix for the Java class name of the generated CEL lite descriptor. + Default is "CelLiteDescriptor". + debug: (optional) If true, prints additional information during codegen for debugging purposes. + """ + if not name: + fail("You must provide a name.") + + if not deps or len(deps) < 1: + fail("You must provide at least one proto_library dependency.") + + java_proto_library_dep = name + "_java_lite_proto_dep" + java_lite_proto_library( + name = java_proto_library_dep, + deps = deps, + ) + + java_lite_proto_cel_library_impl( + name = name, + deps = deps, + # used_by_android + java_descriptor_class_suffix = java_descriptor_class_suffix, + java_proto_library_dep = java_proto_library_dep, + debug = debug, + ) diff --git a/java_lite_proto_cel_library_impl.bzl b/java_lite_proto_cel_library_impl.bzl new file mode 100644 index 000000000..1c5254a8c --- /dev/null +++ b/java_lite_proto_cel_library_impl.bzl @@ -0,0 +1,132 @@ +# Copyright 2025 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. + +""" +Starlark rule for generating descriptors that is compatible with Protolite Messages. +This is an implementation detail. Clients should use 'java_lite_proto_cel_library' instead. +""" + +load("@rules_java//java:defs.bzl", "java_library") +load("//publish:cel_version.bzl", "CEL_VERSION") +load("@com_google_protobuf//bazel:java_lite_proto_library.bzl", "java_lite_proto_library") +load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo") + +def java_lite_proto_cel_library_impl( + name, + deps, + java_proto_library_dep, + constraints = [], + java_descriptor_class_suffix = None, + debug = False): + """Generates a CelLiteDescriptor + + Args: + name: Name of this target. + deps: The list of proto_library rules to generate Java code for. + java_descriptor_class_suffix (optional): Suffix for the Java class name of the generated CEL lite descriptor. + Default is "CelLiteDescriptor". + constraints: (optional) List of strings that denote which environment the produced java_library label is associated in. + java_proto_library_dep: (optional) Uses the provided java_lite_proto_library or java_proto_library to generate the lite descriptors. + If none is provided, java_lite_proto_library is used by default behind the scenes. Most use cases should not need to provide this. + debug: (optional) If true, prints additional information during codegen for debugging purposes. + """ + if not name: + fail("You must provide a name.") + + if not deps or len(deps) < 1: + fail("You must provide at least one proto_library dependency.") + + generated = name + "_cel_lite_descriptor" + java_lite_proto_cel_library_rule( + name = generated, + debug = debug, + descriptors = deps, + java_descriptor_class_suffix = java_descriptor_class_suffix, + ) + + if not java_proto_library_dep: + java_proto_library_dep = name + "_java_lite_proto_dep" + java_lite_proto_library( + name = java_proto_library_dep, + deps = deps, + ) + + descriptor_codegen_deps = [ + "//common/annotations", + "//protobuf:cel_lite_descriptor", + java_proto_library_dep, + ] + + java_library( + name = name, + srcs = [":" + generated], + deps = descriptor_codegen_deps, + ) + +def _generate_cel_lite_descriptor_class(ctx): + srcjar_output = ctx.actions.declare_file(ctx.attr.name + ".srcjar") + java_file_path = srcjar_output.path + + direct_descriptor_set = depset( + direct = [ + descriptor[ProtoInfo].direct_descriptor_set + for descriptor in ctx.attr.descriptors + ], + ) + transitive_descriptor_set = depset( + transitive = [ + descriptor[ProtoInfo].transitive_descriptor_sets + for descriptor in ctx.attr.descriptors + ], + ) + + args = ctx.actions.args() + args.add("--version", CEL_VERSION) + args.add_joined("--descriptor_set", direct_descriptor_set, join_with = ",") + args.add_joined("--transitive_descriptor_set", transitive_descriptor_set, join_with = ",") + args.add("--out", java_file_path) + + if ctx.attr.java_descriptor_class_suffix: + args.add("--overridden_descriptor_class_suffix", ctx.attr.java_descriptor_class_suffix) + + if ctx.attr.debug: + args.add("--debug") + + ctx.actions.run( + mnemonic = "CelLiteDescriptorGenerator", + arguments = [args], + inputs = transitive_descriptor_set, + outputs = [srcjar_output], + progress_message = "Generating CelLiteDescriptor for: " + ctx.attr.name, + executable = ctx.executable._tool, + ) + + return [DefaultInfo(files = depset([srcjar_output]))] + +java_lite_proto_cel_library_rule = rule( + implementation = _generate_cel_lite_descriptor_class, + attrs = { + "java_descriptor_class_suffix": attr.string(), + "descriptors": attr.label_list( + providers = [ProtoInfo], + ), + "debug": attr.bool(), + "_tool": attr.label( + executable = True, + cfg = "exec", + allow_files = True, + default = Label("//protobuf:cel_lite_descriptor_generator"), + ), + }, +) diff --git a/optimizer/BUILD.bazel b/optimizer/BUILD.bazel new file mode 100644 index 000000000..9468b01a9 --- /dev/null +++ b/optimizer/BUILD.bazel @@ -0,0 +1,38 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "optimizer", + exports = ["//optimizer/src/main/java/dev/cel/optimizer"], +) + +java_library( + name = "optimizer_builder", + exports = ["//optimizer/src/main/java/dev/cel/optimizer:optimizer_builder"], +) + +java_library( + name = "ast_optimizer", + exports = ["//optimizer/src/main/java/dev/cel/optimizer:ast_optimizer"], +) + +java_library( + name = "optimization_exception", + exports = ["//optimizer/src/main/java/dev/cel/optimizer:optimization_exception"], +) + +java_library( + name = "mutable_ast", + exports = ["//optimizer/src/main/java/dev/cel/optimizer:mutable_ast"], +) + +java_library( + name = "optimizer_impl", + testonly = 1, + visibility = ["//optimizer/src/test/java/dev/cel/optimizer:__pkg__"], + exports = ["//optimizer/src/main/java/dev/cel/optimizer:optimizer_impl"], +) diff --git a/optimizer/optimizers/BUILD.bazel b/optimizer/optimizers/BUILD.bazel new file mode 100644 index 000000000..26d98c574 --- /dev/null +++ b/optimizer/optimizers/BUILD.bazel @@ -0,0 +1,21 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "constant_folding", + exports = ["//optimizer/src/main/java/dev/cel/optimizer/optimizers:constant_folding"], +) + +java_library( + name = "common_subexpression_elimination", + exports = ["//optimizer/src/main/java/dev/cel/optimizer/optimizers:common_subexpression_elimination"], +) + +java_library( + name = "inlining", + exports = ["//optimizer/src/main/java/dev/cel/optimizer/optimizers:inlining"], +) diff --git a/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java b/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java new file mode 100644 index 000000000..59f842e29 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java @@ -0,0 +1,985 @@ +// Copyright 2023 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.optimizer; + +import static com.google.common.collect.ImmutableMap.toImmutableMap; +import static java.lang.Math.max; +import static java.util.stream.Collectors.toCollection; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.base.Strings; +import com.google.common.collect.HashBasedTable; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Table; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelMutableAst; +import dev.cel.common.CelMutableSource; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelExprIdGeneratorFactory; +import dev.cel.common.ast.CelExprIdGeneratorFactory.ExprIdGenerator; +import dev.cel.common.ast.CelExprIdGeneratorFactory.StableIdGenerator; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExpr.CelMutableCall; +import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.navigation.CelNavigableMutableAst; +import dev.cel.common.navigation.CelNavigableMutableExpr; +import dev.cel.common.navigation.TraversalOrder; +import dev.cel.common.types.CelType; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map.Entry; +import java.util.NoSuchElementException; +import java.util.Optional; +import java.util.function.Predicate; +import java.util.stream.Collectors; + +/** AstMutator contains logic for mutating a {@link CelAbstractSyntaxTree}. */ +@Immutable +public final class AstMutator { + private static final ExprIdGenerator NO_OP_ID_GENERATOR = id -> id; + private static final ExprIdGenerator UNSET_ID_GENERATOR = id -> 0; + private final long iterationLimit; + + /** + * Returns a new instance of an AST mutator with the iteration limit set. + * + *

Mutation is performed by walking the existing AST until the expression node to replace is + * found, then the new subtree is walked to complete the mutation. Visiting of each node + * increments the iteration counter. Replace subtree operations will throw an exception if this + * counter reaches the limit. + * + * @param iterationLimit Must be greater than 0. + */ + public static AstMutator newInstance(long iterationLimit) { + return new AstMutator(iterationLimit); + } + + private AstMutator(long iterationLimit) { + Preconditions.checkState(iterationLimit > 0L); + this.iterationLimit = iterationLimit; + } + + /** Replaces all the expression IDs in the expression tree with 0. */ + public CelMutableExpr clearExprIds(CelMutableExpr expr) { + return renumberExprIds(UNSET_ID_GENERATOR, expr); + } + + /** Wraps the given AST and its subexpressions with a new cel.@block call. */ + public CelMutableAst wrapAstWithNewCelBlock( + String celBlockFunction, CelMutableAst ast, List subexpressions) { + long maxId = getMaxId(ast); + CelMutableExpr blockExpr = + CelMutableExpr.ofCall( + ++maxId, + CelMutableCall.create( + celBlockFunction, + CelMutableExpr.ofList(++maxId, CelMutableList.create(subexpressions)), + ast.expr())); + + return CelMutableAst.of(blockExpr, ast.source()); + } + + /** + * Constructs a new global call wrapped in an AST with the provided ASTs as its argument. This + * will preserve all macro source information contained within the arguments. + */ + public CelMutableAst newGlobalCall(String function, Collection args) { + return newCallAst(Optional.empty(), function, args); + } + + /** + * Constructs a new global call wrapped in an AST with the provided ASTs as its argument. This + * will preserve all macro source information contained within the arguments. + */ + public CelMutableAst newGlobalCall(String function, CelMutableAst... args) { + return newGlobalCall(function, Arrays.asList(args)); + } + + /** + * Constructs a new member call wrapped in an AST the provided ASTs as its arguments. This will + * preserve all macro source information contained within the arguments. + */ + public CelMutableAst newMemberCall(CelMutableAst target, String function, CelMutableAst... args) { + return newMemberCall(target, function, Arrays.asList(args)); + } + + /** + * Constructs a new member call wrapped in an AST the provided ASTs as its arguments. This will + * preserve all macro source information contained within the arguments. + */ + public CelMutableAst newMemberCall( + CelMutableAst target, String function, Collection args) { + return newCallAst(Optional.of(target), function, args); + } + + private CelMutableAst newCallAst( + Optional target, String function, Collection args) { + long maxId = 0; + CelMutableSource combinedSource = CelMutableSource.newInstance(); + for (CelMutableAst arg : args) { + CelMutableAst stableArg = stabilizeAst(arg, maxId); + maxId = getMaxId(stableArg); + combinedSource = combine(combinedSource, stableArg.source()); + } + + Optional maybeTarget = Optional.empty(); + if (target.isPresent()) { + CelMutableAst stableTarget = stabilizeAst(target.get(), maxId); + combinedSource = combine(combinedSource, stableTarget.source()); + maxId = getMaxId(stableTarget); + + maybeTarget = Optional.of(stableTarget); + } + + List exprArgs = + args.stream().map(CelMutableAst::expr).collect(toCollection(ArrayList::new)); + CelMutableCall newCall = + maybeTarget + .map(celMutableAst -> CelMutableCall.create(celMutableAst.expr(), function, exprArgs)) + .orElseGet(() -> CelMutableCall.create(function, exprArgs)); + + CelMutableExpr newCallExpr = CelMutableExpr.ofCall(++maxId, newCall); + + return CelMutableAst.of(newCallExpr, combinedSource); + } + + /** Renumbers all the expr IDs in the given AST in a consecutive manner starting from 1. */ + public CelMutableAst renumberIdsConsecutively(CelMutableAst mutableAst) { + StableIdGenerator stableIdGenerator = CelExprIdGeneratorFactory.newStableIdGenerator(0); + CelMutableExpr mutableExpr = renumberExprIds(stableIdGenerator::renumberId, mutableAst.expr()); + CelMutableSource newSource = + normalizeMacroSource( + mutableAst.source(), Integer.MIN_VALUE, mutableExpr, stableIdGenerator::renumberId); + + return CelMutableAst.of(mutableExpr, newSource); + } + + /** + * Replaces all comprehension identifier names with a unique name based on the given prefix. + * + *

The purpose of this is to avoid errors that can be caused by shadowed variables while + * augmenting an AST. As an example: {@code [2, 3].exists(x, x - 1 > 3) || x - 1 > 3}. Note that + * the scoping of `x - 1` is different between th two LOGICAL_OR branches. Iteration variable `x` + * in `exists` will be mangled to {@code [2, 3].exists(@c0, @c0 - 1 > 3) || x - 1 > 3} to avoid + * erroneously extracting x - 1 as common subexpression. + * + *

The expression IDs are not modified when the identifier names are changed. + * + *

Mangling occurs only if the iteration variable is referenced within the loop step. + * + *

Iteration variables in comprehensions are numbered based on their comprehension nesting + * levels and the iteration variable's type. Examples: + * + *

    + *
  • {@code [true].exists(i, i) && [true].exists(j, j)} -> {@code [true].exists(@c0:0, @c0:0) + * && [true].exists(@c0:0, @c0:0)} // Note that i,j gets replaced to the same @c0:0 in this + * example as they share the same nesting level and type. + *
  • {@code [1].exists(i, i > 0) && [1u].exists(j, j > 0u)} -> {@code [1].exists(@c0:0, @c0:0 + * > 0) && [1u].exists(@c0:1, @c0:1 > 0u)} + *
  • {@code [true].exists(i, i && [true].exists(j, j))} -> {@code [true].exists(@c0:0, @c0:0 + * && [true].exists(@c1:0, @c1:0))} + *
+ * + * @param ast AST containing type-checked references + * @param newIterVarPrefix Prefix to use for new iteration variable identifier name. For example, + * providing @c will produce @c0:0, @c0:1, @c1:0, @c2:0... as new names. + * @param newAccuVarPrefix Prefix to use for new accumulation variable identifier name. + */ + public MangledComprehensionAst mangleComprehensionIdentifierNames( + CelMutableAst ast, + String newIterVarPrefix, + String newIterVar2Prefix, + String newAccuVarPrefix) { + CelNavigableMutableAst navigableMutableAst = CelNavigableMutableAst.fromAst(ast); + Predicate comprehensionIdentifierPredicate = x -> true; + comprehensionIdentifierPredicate = + comprehensionIdentifierPredicate + .and(node -> node.getKind().equals(Kind.COMPREHENSION)) + .and(node -> !node.expr().comprehension().iterVar().startsWith(newIterVarPrefix + ":")) + .and(node -> !node.expr().comprehension().accuVar().startsWith(newAccuVarPrefix + ":")) + .and( + node -> + !node.expr().comprehension().iterVar2().startsWith(newIterVar2Prefix + ":")); + LinkedHashMap comprehensionsToMangle = + navigableMutableAst + .getRoot() + // This is important - mangling needs to happen bottom-up to avoid stepping over + // shadowed variables that are not part of the comprehension being mangled. + .allNodes(TraversalOrder.POST_ORDER) + .filter(comprehensionIdentifierPredicate) + .filter( + node -> { + // Ensure the iter_var or the comprehension result is actually referenced in the + // loop_step. If it's not, we can skip mangling. + String iterVar = node.expr().comprehension().iterVar(); + String iterVar2 = node.expr().comprehension().iterVar2(); + String result = node.expr().comprehension().result().ident().name(); + return CelNavigableMutableExpr.fromExpr(node.expr().comprehension().loopStep()) + .allNodes() + .filter(subNode -> subNode.getKind().equals(Kind.IDENT)) + .map(subNode -> subNode.expr().ident()) + .anyMatch( + ident -> + ident.name().contains(iterVar) + || ident.name().contains(iterVar2) + || ident.name().contains(result)); + }) + .collect( + Collectors.toMap( + k -> k, + v -> { + CelMutableComprehension comprehension = v.expr().comprehension(); + String iterVar = comprehension.iterVar(); + String iterVar2 = comprehension.iterVar2(); + // Identifiers to mangle could be the iteration variable, comprehension + // result or both, but at least one has to exist. + // As an example, [1,2].map(i, 3) would result in optional.empty for iteration + // variable because `i` is not actually used. + Optional iterVarId = + CelNavigableMutableExpr.fromExpr(comprehension.loopStep()) + .allNodes() + .filter( + loopStepNode -> + loopStepNode.getKind().equals(Kind.IDENT) + && loopStepNode.expr().ident().name().equals(iterVar)) + .map(CelNavigableMutableExpr::id) + .findAny(); + Optional iterVar2Id = + CelNavigableMutableExpr.fromExpr(comprehension.loopStep()) + .allNodes() + .filter( + loopStepNode -> + !iterVar2.isEmpty() + && loopStepNode.getKind().equals(Kind.IDENT) + && loopStepNode.expr().ident().name().equals(iterVar2)) + .map(CelNavigableMutableExpr::id) + .findAny(); + Optional iterVarType = + iterVarId.map( + id -> + navigableMutableAst + .getType(id) + .orElseThrow( + () -> + new NoSuchElementException( + "Checked type not present for iteration" + + " variable: " + + iterVarId))); + Optional iterVar2Type = + iterVar2Id.map( + id -> + navigableMutableAst + .getType(id) + .orElseThrow( + () -> + new NoSuchElementException( + "Checked type not present for iteration" + + " variable: " + + iterVar2Id))); + CelType resultType = + navigableMutableAst + .getType(comprehension.result().id()) + .orElseThrow( + () -> + new IllegalStateException( + "Result type was not present for the comprehension ID: " + + comprehension.result().id())); + + return MangledComprehensionType.of(iterVarType, iterVar2Type, resultType); + }, + (x, y) -> { + throw new IllegalStateException( + "Unexpected CelNavigableMutableExpr collision"); + }, + LinkedHashMap::new)); + + // The map that we'll eventually return to the caller. + HashMap mangledIdentNamesToType = + new HashMap<>(); + // Intermediary table used for the purposes of generating a unique mangled variable name. + Table comprehensionLevelToType = + HashBasedTable.create(); + CelMutableExpr mutatedComprehensionExpr = navigableMutableAst.getAst().expr(); + CelMutableSource newSource = navigableMutableAst.getAst().source(); + int iterCount = 0; + for (Entry comprehensionEntry : + comprehensionsToMangle.entrySet()) { + CelNavigableMutableExpr comprehensionNode = comprehensionEntry.getKey(); + MangledComprehensionType comprehensionEntryType = comprehensionEntry.getValue(); + + CelMutableExpr comprehensionExpr = comprehensionNode.expr(); + MangledComprehensionName mangledComprehensionName = + getMangledComprehensionName( + newIterVarPrefix, + newIterVar2Prefix, + newAccuVarPrefix, + comprehensionNode, + comprehensionLevelToType, + comprehensionEntryType); + mangledIdentNamesToType.put(mangledComprehensionName, comprehensionEntryType); + + String iterVar = comprehensionExpr.comprehension().iterVar(); + String iterVar2 = comprehensionExpr.comprehension().iterVar2(); + String accuVar = comprehensionExpr.comprehension().accuVar(); + mutatedComprehensionExpr = + mangleIdentsInComprehensionExpr( + mutatedComprehensionExpr, + comprehensionExpr, + iterVar, + iterVar2, + accuVar, + mangledComprehensionName); + // Repeat the mangling process for the macro source. + newSource = + mangleIdentsInMacroSource( + newSource, + mutatedComprehensionExpr, + iterVar, + iterVar2, + mangledComprehensionName, + comprehensionExpr.id()); + iterCount++; + } + + if (iterCount >= iterationLimit) { + // Note that it's generally impossible to reach this for a well-formed AST. The nesting level + // of AST being mutated is always deeper than the number of identifiers being mangled, thus + // the mutation operation should throw before we ever reach here. + throw new IllegalStateException("Max iteration count reached."); + } + + return MangledComprehensionAst.of( + CelMutableAst.of(mutatedComprehensionExpr, newSource), + ImmutableMap.copyOf(mangledIdentNamesToType)); + } + + private static MangledComprehensionName getMangledComprehensionName( + String newIterVarPrefix, + String newIterVar2Prefix, + String newResultPrefix, + CelNavigableMutableExpr comprehensionNode, + Table comprehensionLevelToType, + MangledComprehensionType comprehensionEntryType) { + MangledComprehensionName mangledComprehensionName; + int comprehensionNestingLevel = countComprehensionNestingLevel(comprehensionNode); + if (comprehensionLevelToType.contains(comprehensionNestingLevel, comprehensionEntryType)) { + mangledComprehensionName = + comprehensionLevelToType.get(comprehensionNestingLevel, comprehensionEntryType); + } else { + // First time encountering the pair of . Generate a unique + // mangled variable name for this. + int uniqueTypeIdx = comprehensionLevelToType.row(comprehensionNestingLevel).size(); + String mangledIterVarName = + newIterVarPrefix + ":" + comprehensionNestingLevel + ":" + uniqueTypeIdx; + String mangledResultName = + newResultPrefix + ":" + comprehensionNestingLevel + ":" + uniqueTypeIdx; + String mangledIterVar2Name = + newIterVar2Prefix + ":" + comprehensionNestingLevel + ":" + uniqueTypeIdx; + + mangledComprehensionName = + MangledComprehensionName.of(mangledIterVarName, mangledIterVar2Name, mangledResultName); + comprehensionLevelToType.put( + comprehensionNestingLevel, comprehensionEntryType, mangledComprehensionName); + } + return mangledComprehensionName; + } + + private static int countComprehensionNestingLevel(CelNavigableMutableExpr comprehensionExpr) { + return comprehensionExpr + .descendants() + .filter(node -> node.getKind().equals(Kind.COMPREHENSION)) + .mapToInt( + node -> { + int nestedLevel = 1; + CelNavigableMutableExpr maybeParent = node.parent().orElse(null); + while (maybeParent != null && maybeParent.id() != comprehensionExpr.id()) { + if (maybeParent.getKind().equals(Kind.COMPREHENSION)) { + nestedLevel++; + } + maybeParent = maybeParent.parent().orElse(null); + } + return nestedLevel; + }) + .max() + .orElse(0); + } + + /** + * Replaces a subtree in the given expression node. This operation is intended for AST + * optimization purposes. + * + *

This is a very dangerous operation. Callers must re-typecheck the mutated AST and + * additionally verify that the resulting AST is semantically valid. + * + *

All expression IDs will be renumbered in a stable manner to ensure there's no ID collision + * between the nodes. The renumbering occurs even if the subtree was not replaced. + * + *

If the ability to unparse an expression containing a macro call must be retained, use {@link + * #replaceSubtree(CelMutableAst, CelMutableAst, long) instead.} + * + * @param root Original expression node to rewrite. + * @param newExpr New CelExpr to replace the subtree with. + * @param exprIdToReplace Expression id of the subtree that is getting replaced. + */ + public CelMutableAst replaceSubtree( + CelMutableExpr root, CelMutableExpr newExpr, long exprIdToReplace) { + return replaceSubtree( + CelMutableAst.of(root, CelMutableSource.newInstance()), newExpr, exprIdToReplace); + } + + /** + * Replaces a subtree in the given AST. This operation is intended for AST optimization purposes. + * + *

This is a very dangerous operation. Callers must re-typecheck the mutated AST and + * additionally verify that the resulting AST is semantically valid. + * + *

All expression IDs will be renumbered in a stable manner to ensure there's no ID collision + * between the nodes. The renumbering occurs even if the subtree was not replaced. + * + *

This will scrub out the description, positions and line offsets from {@code CelSource}. If + * the source contains macro calls, its call IDs will be to be consistent with the renumbered IDs + * in the AST. + * + * @param ast Original ast to mutate. + * @param newExpr New CelExpr to replace the subtree with. + * @param exprIdToReplace Expression id of the subtree that is getting replaced. + */ + public CelMutableAst replaceSubtree( + CelMutableAst ast, CelMutableExpr newExpr, long exprIdToReplace) { + return replaceSubtree( + ast, + CelMutableAst.of( + newExpr, + // Copy the macro call information to the new AST such that macro call map can be + // normalized post-replacement. + ast.source()), + exprIdToReplace); + } + + /** + * Replaces a subtree in the given AST. This operation is intended for AST optimization purposes. + * + *

This is a very dangerous operation. Callers must re-typecheck the mutated AST and + * additionally verify that the resulting AST is semantically valid. + * + *

All expression IDs will be renumbered in a stable manner to ensure there's no ID collision + * between the nodes. The renumbering occurs even if the subtree was not replaced. + * + *

This will scrub out the description, positions and line offsets from {@code CelSource}. If + * the source contains macro calls, its call IDs will be to be consistent with the renumbered IDs + * in the AST. + * + * @param ast Original ast to mutate. + * @param newAst New AST to replace the subtree with. + * @param exprIdToReplace Expression id of the subtree that is getting replaced. + */ + public CelMutableAst replaceSubtree( + CelMutableAst ast, CelMutableAst newAst, long exprIdToReplace) { + return replaceSubtree( + CelNavigableMutableAst.fromAst(ast), + CelNavigableMutableAst.fromAst(newAst), + exprIdToReplace); + } + + /** + * Replaces a subtree in the given AST. This operation is intended for AST optimization purposes. + * + *

This is a very dangerous operation. Callers must re-typecheck the mutated AST and + * additionally verify that the resulting AST is semantically valid. + * + *

All expression IDs will be renumbered in a stable manner to ensure there's no ID collision + * between the nodes. The renumbering occurs even if the subtree was not replaced. + * + *

This will scrub out the description, positions and line offsets from {@code CelSource}. If + * the source contains macro calls, its call IDs will be to be consistent with the renumbered IDs + * in the AST. + * + * @param navAst Original navigable ast to mutate. + * @param navNewAst New navigable AST to replace the subtree with. + * @param exprIdToReplace Expression id of the subtree that is getting replaced. + */ + public CelMutableAst replaceSubtree( + CelNavigableMutableAst navAst, CelNavigableMutableAst navNewAst, long exprIdToReplace) { + // Stabilize the incoming AST by renumbering all of its expression IDs. + long maxId = max(getMaxId(navAst), getMaxId(navNewAst)); + CelMutableAst ast = navAst.getAst(); + CelMutableAst newAst = navNewAst.getAst(); + newAst = stabilizeAst(newAst, maxId); + long stablizedNewExprRootId = newAst.expr().id(); + + // Mutate the AST root with the new subtree. All the existing expr IDs are renumbered in the + // process, but its original IDs are memoized so that we can normalize the expr IDs + // in the macro source map. + StableIdGenerator stableIdGenerator = + CelExprIdGeneratorFactory.newStableIdGenerator(getMaxId(newAst)); + + CelMutableExpr mutatedRoot = + mutateExpr(stableIdGenerator::renumberId, ast.expr(), newAst.expr(), exprIdToReplace); + CelMutableSource newAstSource = + CelMutableSource.newInstance().setDescription(ast.source().getDescription()); + if (!ast.source().getMacroCalls().isEmpty()) { + newAstSource = combine(newAstSource, ast.source()); + } + + if (!newAst.source().getMacroCalls().isEmpty()) { + stableIdGenerator.memoize( + stablizedNewExprRootId, stableIdGenerator.renumberId(exprIdToReplace)); + newAstSource = combine(newAstSource, newAst.source()); + } + + newAstSource = + normalizeMacroSource( + newAstSource, exprIdToReplace, mutatedRoot, stableIdGenerator::renumberId); + return CelMutableAst.of(mutatedRoot, newAstSource); + } + + private CelMutableExpr mangleIdentsInComprehensionExpr( + CelMutableExpr root, + CelMutableExpr comprehensionExpr, + String originalIterVar, + String originalIterVar2, + String originalAccuVar, + MangledComprehensionName mangledComprehensionName) { + CelMutableComprehension comprehension = comprehensionExpr.comprehension(); + replaceIdentName( + comprehension.loopStep(), originalIterVar, mangledComprehensionName.iterVarName()); + replaceIdentName(comprehensionExpr, originalAccuVar, mangledComprehensionName.resultName()); + + comprehension.setIterVar(mangledComprehensionName.iterVarName()); + + // Most standard macros set accu_var as __result__, but not all (ex: cel.bind). + if (comprehension.accuVar().equals(originalAccuVar)) { + comprehension.setAccuVar(mangledComprehensionName.resultName()); + } + + if (!originalIterVar2.isEmpty()) { + comprehension.setIterVar2(mangledComprehensionName.iterVar2Name()); + replaceIdentName( + comprehension.loopStep(), originalIterVar2, mangledComprehensionName.iterVar2Name()); + } + + return mutateExpr(NO_OP_ID_GENERATOR, root, comprehensionExpr, comprehensionExpr.id()); + } + + private void replaceIdentName( + CelMutableExpr comprehensionExpr, String originalIdentName, String newIdentName) { + int iterCount; + for (iterCount = 0; iterCount < iterationLimit; iterCount++) { + CelMutableExpr identToMangle = + CelNavigableMutableExpr.fromExpr(comprehensionExpr) + .descendants() + .map(CelNavigableMutableExpr::expr) + .filter( + node -> + node.getKind().equals(Kind.IDENT) + && node.ident().name().equals(originalIdentName)) + .findAny() + .orElse(null); + if (identToMangle == null) { + break; + } + + comprehensionExpr = + mutateExpr( + NO_OP_ID_GENERATOR, + comprehensionExpr, + CelMutableExpr.ofIdent(newIdentName), + identToMangle.id()); + } + + if (iterCount >= iterationLimit) { + throw new IllegalStateException("Max iteration count reached."); + } + } + + private CelMutableSource mangleIdentsInMacroSource( + CelMutableSource sourceBuilder, + CelMutableExpr mutatedComprehensionExpr, + String originalIterVar, + String originalIterVar2, + MangledComprehensionName mangledComprehensionName, + long originalComprehensionId) { + if (!sourceBuilder.getMacroCalls().containsKey(originalComprehensionId)) { + return sourceBuilder; + } + + // First, normalize the macro source. + // ex: [x].exists(x, [x].exists(x, x == 1)) -> [x].exists(x, [@c1].exists(x, @c0 == 1)). + CelMutableSource newSource = + normalizeMacroSource(sourceBuilder, -1, mutatedComprehensionExpr, (id) -> id); + + // Note that in the above example, the iteration variable is not replaced after normalization. + // This is because populating a macro call map upon parse generates a new unique identifier + // that does not exist in the main AST. Thus, we need to manually replace the identifier. + // Also note that this only applies when the macro is at leaf. For nested macros, the iteration + // variable actually exists in the main AST thus, this step isn't needed. + // ex: [1].map(x, [2].filter(y, x == y). Here, the variable declaration `x` exists in the AST + // but not `y`. + CelMutableExpr macroExpr = newSource.getMacroCalls().get(originalComprehensionId); + // By convention, the iteration variable is always the first argument of the + // macro call expression. + CelMutableExpr identToMangle = macroExpr.call().args().get(0); + if (identToMangle.ident().name().equals(originalIterVar)) { + macroExpr = + mutateExpr( + NO_OP_ID_GENERATOR, + macroExpr, + CelMutableExpr.ofIdent(mangledComprehensionName.iterVarName()), + identToMangle.id()); + } + if (!originalIterVar2.isEmpty()) { + // Similarly by convention, iter_var2 is always the second argument of the macro call. + identToMangle = macroExpr.call().args().get(1); + if (identToMangle.ident().name().equals(originalIterVar2)) { + macroExpr = + mutateExpr( + NO_OP_ID_GENERATOR, + macroExpr, + CelMutableExpr.ofIdent(mangledComprehensionName.iterVar2Name()), + identToMangle.id()); + } + } + + newSource.addMacroCalls(originalComprehensionId, macroExpr); + + return newSource; + } + + private static CelMutableSource combine( + CelMutableSource celSource1, CelMutableSource celSource2) { + return CelMutableSource.newInstance() + .setDescription( + Strings.isNullOrEmpty(celSource1.getDescription()) + ? celSource2.getDescription() + : celSource1.getDescription()) + .addAllExtensions(celSource1.getExtensions()) + .addAllExtensions(celSource2.getExtensions()) + .addAllMacroCalls(celSource1.getMacroCalls()) + .addAllMacroCalls(celSource2.getMacroCalls()); + } + + /** + * Stabilizes the incoming AST by ensuring that all of expr IDs are consistently renumbered + * (monotonically increased) from the starting seed ID. If the AST contains any macro calls, its + * IDs are also normalized. + */ + private CelMutableAst stabilizeAst(CelMutableAst mutableAst, long seedExprId) { + CelMutableExpr mutableExpr = mutableAst.expr(); + CelMutableSource source = mutableAst.source(); + StableIdGenerator stableIdGenerator = + CelExprIdGeneratorFactory.newStableIdGenerator(seedExprId); + CelMutableExpr mutatedExpr = renumberExprIds(stableIdGenerator::nextExprId, mutableExpr); + + CelMutableSource sourceBuilder = + CelMutableSource.newInstance().addAllExtensions(source.getExtensions()); + // Update the macro call IDs and their call IDs + for (Entry macroCall : source.getMacroCalls().entrySet()) { + long macroId = macroCall.getKey(); + long newCallId = stableIdGenerator.renumberId(macroId); + CelMutableExpr existingMacroCallExpr = CelMutableExpr.newInstance(macroCall.getValue()); + + CelMutableExpr newCall = + renumberExprIds(stableIdGenerator::renumberId, existingMacroCallExpr); + + sourceBuilder.addMacroCalls(newCallId, newCall); + } + + return CelMutableAst.of(mutatedExpr, sourceBuilder); + } + + private CelMutableSource normalizeMacroSource( + CelMutableSource source, + long exprIdToReplace, + CelMutableExpr mutatedRoot, + ExprIdGenerator idGenerator) { + // Remove the macro metadata that no longer exists in the AST due to being replaced. + source.clearMacroCall(exprIdToReplace); + if (source.getMacroCalls().isEmpty()) { + return source; + } + + ImmutableMap allExprs = + CelNavigableMutableExpr.fromExpr(mutatedRoot) + .allNodes() + .map(CelNavigableMutableExpr::expr) + .collect( + toImmutableMap( + CelMutableExpr::id, + expr -> expr, + (expr1, expr2) -> { + // Comprehensions can reuse same expression (result). We just need to ensure + // that they are identical. + if (expr1.equals(expr2)) { + return expr1; + } + throw new IllegalStateException( + "Expected expressions to be the same for id: " + expr1.id()); + })); + + CelMutableSource newMacroSource = + CelMutableSource.newInstance() + .setDescription(source.getDescription()) + .addAllExtensions(source.getExtensions()); + // Update the macro call IDs and their call references + for (Entry existingMacroCall : source.getMacroCalls().entrySet()) { + long macroId = existingMacroCall.getKey(); + long callId = idGenerator.generate(macroId); + + if (!allExprs.containsKey(callId)) { + continue; + } + + CelMutableExpr existingMacroCallExpr = + CelMutableExpr.newInstance(existingMacroCall.getValue()); + CelMutableExpr newMacroCallExpr = renumberExprIds(idGenerator, existingMacroCallExpr); + + CelNavigableMutableExpr callNav = CelNavigableMutableExpr.fromExpr(newMacroCallExpr); + ArrayList callDescendants = + callNav + .descendants() + .map(CelNavigableMutableExpr::expr) + .collect(toCollection(ArrayList::new)); + + for (CelMutableExpr callChild : callDescendants) { + if (!allExprs.containsKey(callChild.id())) { + continue; + } + + CelMutableExpr mutatedExpr = allExprs.get(callChild.id()); + if (!callChild.equals(mutatedExpr)) { + newMacroCallExpr = + mutateExpr(NO_OP_ID_GENERATOR, newMacroCallExpr, mutatedExpr, callChild.id()); + } + } + + if (exprIdToReplace > 0) { + long replacedId = idGenerator.generate(exprIdToReplace); + boolean isListExprBeingReplaced = + allExprs.containsKey(replacedId) + && allExprs.get(replacedId).getKind().equals(Kind.LIST); + if (isListExprBeingReplaced) { + unwrapListArgumentsInMacroCallExpr( + allExprs.get(callId).comprehension(), newMacroCallExpr); + } + } + + newMacroSource.addMacroCalls(callId, newMacroCallExpr); + } + + // Replace comprehension nodes with a NOT_SET reference to reduce AST size. + for (Entry macroCall : newMacroSource.getMacroCalls().entrySet()) { + CelMutableExpr macroCallExpr = macroCall.getValue(); + CelNavigableMutableExpr.fromExpr(macroCallExpr) + .allNodes() + .filter(node -> node.getKind().equals(Kind.COMPREHENSION)) + .map(CelNavigableMutableExpr::expr) + .forEach( + node -> { + CelMutableExpr mutatedNode = + mutateExpr( + NO_OP_ID_GENERATOR, + macroCallExpr, + CelMutableExpr.ofNotSet(node.id()), + node.id()); + macroCall.setValue(mutatedNode); + }); + + // Prune any NOT_SET (comprehension) nodes that no longer exist in the main AST + // This can occur from pulling out a nested comprehension into a separate cel.block index + CelNavigableMutableExpr.fromExpr(macroCallExpr) + .allNodes() + .filter(node -> node.getKind().equals(Kind.NOT_SET)) + .map(CelNavigableMutableExpr::id) + .filter(id -> !allExprs.containsKey(id)) + .forEach( + id -> { + ArrayList newCallArgs = + macroCallExpr.call().args().stream() + .filter(node -> node.id() != id) + .collect(toCollection(ArrayList::new)); + CelMutableCall call = macroCallExpr.call(); + call.setArgs(newCallArgs); + }); + } + + return newMacroSource; + } + + /** + * Unwraps the arguments in the extraneous list_expr which is present in the AST but does not + * exist in the macro call map. `map`, `filter` are examples of such. + * + *

This method inspects the comprehension's accumulator initializer to infer that the list_expr + * solely exists to match the expected result type of the macro call signature. + * + * @param comprehension Comprehension in the main AST to extract the macro call arguments from + * (loop step). + * @param newMacroCallExpr (Output parameter) Modified macro call expression with the call + * arguments unwrapped. + */ + private static void unwrapListArgumentsInMacroCallExpr( + CelMutableComprehension comprehension, CelMutableExpr newMacroCallExpr) { + CelMutableExpr accuInit = comprehension.accuInit(); + if (!accuInit.getKind().equals(Kind.LIST) || !accuInit.list().elements().isEmpty()) { + // Does not contain an extraneous list. + return; + } + + CelMutableExpr loopStepExpr = comprehension.loopStep(); + List loopStepArgs = loopStepExpr.call().args(); + if (loopStepArgs.size() != 2 && loopStepArgs.size() != 3) { + throw new IllegalArgumentException( + String.format( + "Expected exactly 2 or 3 arguments but got %d instead on expr id: %d", + loopStepArgs.size(), loopStepExpr.id())); + } + + CelMutableCall existingMacroCall = newMacroCallExpr.call(); + CelMutableCall newMacroCall = + existingMacroCall.target().isPresent() + ? CelMutableCall.create(existingMacroCall.target().get(), existingMacroCall.function()) + : CelMutableCall.create(existingMacroCall.function()); + newMacroCall.addArgs( + existingMacroCall.args().get(0)); // iter_var is first argument of the call by convention + + CelMutableList extraneousList; + if (loopStepArgs.size() == 2) { + extraneousList = loopStepArgs.get(1).list(); + } else { + newMacroCall.addArgs(loopStepArgs.get(0)); + // For map(x,y,z), z is wrapped in a _+_(@result, [z]) + extraneousList = loopStepArgs.get(1).call().args().get(1).list(); + } + + newMacroCall.addArgs(extraneousList.elements()); + + newMacroCallExpr.setCall(newMacroCall); + } + + private CelMutableExpr mutateExpr( + ExprIdGenerator idGenerator, + CelMutableExpr root, + CelMutableExpr newExpr, + long exprIdToReplace) { + MutableExprVisitor mutableAst = + MutableExprVisitor.newInstance(idGenerator, newExpr, exprIdToReplace, iterationLimit); + return mutableAst.visit(root); + } + + private CelMutableExpr renumberExprIds(ExprIdGenerator idGenerator, CelMutableExpr root) { + MutableExprVisitor mutableAst = + MutableExprVisitor.newInstance(idGenerator, root, Integer.MIN_VALUE, iterationLimit); + return mutableAst.visit(root); + } + + private static long getMaxId(CelMutableAst mutableAst) { + return getMaxId(CelNavigableMutableAst.fromAst(mutableAst)); + } + + private static long getMaxId(CelNavigableMutableAst navAst) { + long maxId = navAst.getRoot().maxId(); + for (Entry macroCall : + navAst.getAst().source().getMacroCalls().entrySet()) { + maxId = max(maxId, getMaxId(macroCall.getValue())); + } + + return maxId; + } + + private static long getMaxId(CelMutableExpr mutableExpr) { + return CelNavigableMutableExpr.fromExpr(mutableExpr) + .allNodes() + .mapToLong(CelNavigableMutableExpr::id) + .max() + .orElseThrow(NoSuchElementException::new); + } + + /** + * Intermediate value class to store the mangled identifiers for iteration variable and the + * comprehension result. + */ + @AutoValue + public abstract static class MangledComprehensionAst { + + /** AST after the iteration variables have been mangled. */ + public abstract CelMutableAst mutableAst(); + + /** Map containing the mangled identifier names to their types. */ + public abstract ImmutableMap + mangledComprehensionMap(); + + private static MangledComprehensionAst of( + CelMutableAst ast, + ImmutableMap mangledComprehensionMap) { + return new AutoValue_AstMutator_MangledComprehensionAst(ast, mangledComprehensionMap); + } + } + + /** + * Intermediate value class to store the types for iter_var and comprehension result of which its + * identifier names are being mangled. + */ + @AutoValue + public abstract static class MangledComprehensionType { + + /** + * Type of iter_var. Empty if iter_var is not referenced in the expression anywhere (ex: "i" in + * "[1].exists(i, true)" + */ + public abstract Optional iterVarType(); + + /** Type of iter_var2. */ + public abstract Optional iterVar2Type(); + + /** Type of comprehension result */ + public abstract CelType resultType(); + + private static MangledComprehensionType of( + Optional iterVarType, Optional iterVarType2, CelType resultType) { + return new AutoValue_AstMutator_MangledComprehensionType( + iterVarType, iterVarType2, resultType); + } + } + + /** + * Intermediate value class to store the mangled names for iteration variable and the + * comprehension result. + */ + @AutoValue + public abstract static class MangledComprehensionName { + + /** Mangled name for iter_var */ + public abstract String iterVarName(); + + /** Mangled name for iter_var2 */ + public abstract String iterVar2Name(); + + /** Mangled name for comprehension result */ + public abstract String resultName(); + + private static MangledComprehensionName of( + String iterVarName, String iterVar2Name, String resultName) { + return new AutoValue_AstMutator_MangledComprehensionName( + iterVarName, iterVar2Name, resultName); + } + } +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/BUILD.bazel b/optimizer/src/main/java/dev/cel/optimizer/BUILD.bazel new file mode 100644 index 000000000..e9e8994a2 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/BUILD.bazel @@ -0,0 +1,109 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//optimizer:__pkg__", + "//publish:__pkg__", + ], +) + +java_library( + name = "optimizer", + srcs = [ + "CelOptimizerFactory.java", + ], + tags = [ + ], + deps = [ + ":optimizer_impl", + "//bundle:cel", + "//checker:checker_builder", + "//compiler", + "//compiler:compiler_builder", + "//optimizer:optimizer_builder", + "//parser:parser_builder", + "//runtime", + ], +) + +java_library( + name = "optimizer_builder", + srcs = [ + "CelOptimizer.java", + "CelOptimizerBuilder.java", + ], + tags = [ + ], + deps = [ + ":ast_optimizer", + ":optimization_exception", + "//common:cel_ast", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "optimizer_impl", + srcs = [ + "CelOptimizerImpl.java", + ], + tags = [ + ], + deps = [ + ":ast_optimizer", + ":optimization_exception", + ":optimizer_builder", + "//bundle:cel", + "//common:cel_ast", + "//common:compiler_common", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "ast_optimizer", + srcs = ["CelAstOptimizer.java"], + tags = [ + ], + deps = [ + ":optimization_exception", + "//:auto_value", + "//bundle:cel", + "//common:cel_ast", + "//common:compiler_common", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "mutable_ast", + srcs = [ + "AstMutator.java", + "MutableExprVisitor.java", + ], + tags = [ + ], + deps = [ + "//:auto_value", + "//common:cel_ast", + "//common:mutable_ast", + "//common:mutable_source", + "//common/annotations", + "//common/ast", + "//common/ast:expr_factory", + "//common/ast:mutable_expr", + "//common/navigation:common", + "//common/navigation:mutable_navigation", + "//common/types:type_providers", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "optimization_exception", + srcs = ["CelOptimizationException.java"], + tags = [ + ], +) diff --git a/optimizer/src/main/java/dev/cel/optimizer/CelAstOptimizer.java b/optimizer/src/main/java/dev/cel/optimizer/CelAstOptimizer.java new file mode 100644 index 000000000..7a14f0f70 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/CelAstOptimizer.java @@ -0,0 +1,60 @@ +// Copyright 2023 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.optimizer; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelVarDecl; + +/** Public interface for performing a single, custom optimization on an AST. */ +public interface CelAstOptimizer { + + /** Optimizes a single AST. */ + OptimizationResult optimize(CelAbstractSyntaxTree ast, Cel cel) throws CelOptimizationException; + + /** + * Denotes the result of a single optimization pass on an AST. + * + *

The optimizer may optionally populate new variable and function declarations generated as + * part of optimizing an AST. + */ + @AutoValue + abstract class OptimizationResult { + public abstract CelAbstractSyntaxTree optimizedAst(); + + public abstract ImmutableList newVarDecls(); + + public abstract ImmutableList newFunctionDecls(); + + /** + * Create an optimization result with new declarations. The optimizer must populate these + * declarations after an optimization pass if they are required for type-checking to success. + */ + public static OptimizationResult create( + CelAbstractSyntaxTree optimizedAst, + ImmutableList newVarDecls, + ImmutableList newFunctionDecls) { + return new AutoValue_CelAstOptimizer_OptimizationResult( + optimizedAst, newVarDecls, newFunctionDecls); + } + + public static OptimizationResult create(CelAbstractSyntaxTree optimizedAst) { + return create(optimizedAst, ImmutableList.of(), ImmutableList.of()); + } + } +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/CelOptimizationException.java b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizationException.java new file mode 100644 index 000000000..baa79e618 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizationException.java @@ -0,0 +1,23 @@ +// Copyright 2023 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.optimizer; + +/** Checked exception thrown by CelOptimizer during AST optimization. */ +public final class CelOptimizationException extends Exception { + + public CelOptimizationException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/CelOptimizer.java b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizer.java new file mode 100644 index 000000000..a47b83e98 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizer.java @@ -0,0 +1,36 @@ +// Copyright 2023 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.optimizer; + +import dev.cel.common.CelAbstractSyntaxTree; + +/** Public interface for optimizing an AST. */ +public interface CelOptimizer { + + /** + * Performs custom optimization of the provided AST. + * + *

This invokes all the AST optimizers present in this CelOptimizer instance via {@link + * CelOptimizerBuilder#addAstOptimizers} in their added order. Any exceptions thrown within the + * AST optimizer will be propagated to the caller and will abort the optimization process. + * + *

Note that the produced expression string from unparsing an optimized AST will likely not be + * equal to the original expression. + * + * @param ast A type-checked AST. + * @throws CelOptimizationException If any failures occur during any of the AST optimization pass. + */ + CelAbstractSyntaxTree optimize(CelAbstractSyntaxTree ast) throws CelOptimizationException; +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/CelOptimizerBuilder.java b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizerBuilder.java new file mode 100644 index 000000000..abfed8f38 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizerBuilder.java @@ -0,0 +1,34 @@ +// Copyright 2023 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.optimizer; + +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; + +/** Interface for building an instance of CelOptimizer. */ +public interface CelOptimizerBuilder { + + /** Adds one or more optimizer to perform custom AST optimizations. */ + @CanIgnoreReturnValue + CelOptimizerBuilder addAstOptimizers(CelAstOptimizer... astOptimizers); + + /** Adds one or more optimizer to perform custom AST optimizations. */ + @CanIgnoreReturnValue + CelOptimizerBuilder addAstOptimizers(Iterable astOptimizers); + + /** Build a new instance of the {@link CelOptimizer}. */ + @CheckReturnValue + CelOptimizer build(); +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/CelOptimizerFactory.java b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizerFactory.java new file mode 100644 index 000000000..1ebfd293e --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizerFactory.java @@ -0,0 +1,47 @@ +// Copyright 2023 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.optimizer; + +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.checker.CelChecker; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelParser; +import dev.cel.runtime.CelRuntime; + +/** Factory class for constructing an {@link CelOptimizer} instance. */ +public final class CelOptimizerFactory { + + /** Create a new builder for constructing a {@link CelOptimizer} instance. */ + public static CelOptimizerBuilder standardCelOptimizerBuilder(Cel cel) { + return CelOptimizerImpl.newBuilder(cel); + } + + /** Create a new builder for constructing a {@link CelOptimizer} instance. */ + public static CelOptimizerBuilder standardCelOptimizerBuilder( + CelCompiler celCompiler, CelRuntime celRuntime) { + return standardCelOptimizerBuilder(CelFactory.combine(celCompiler, celRuntime)); + } + + /** Create a new builder for constructing a {@link CelOptimizer} instance. */ + public static CelOptimizerBuilder standardCelOptimizerBuilder( + CelParser celParser, CelChecker celChecker, CelRuntime celRuntime) { + return standardCelOptimizerBuilder( + CelCompilerFactory.combine(celParser, celChecker), celRuntime); + } + + private CelOptimizerFactory() {} +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/CelOptimizerImpl.java b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizerImpl.java new file mode 100644 index 000000000..4ac8764f1 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/CelOptimizerImpl.java @@ -0,0 +1,99 @@ +// Copyright 2023 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.optimizer; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.collect.ImmutableSet; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.optimizer.CelAstOptimizer.OptimizationResult; +import java.util.Arrays; + +final class CelOptimizerImpl implements CelOptimizer { + private final Cel cel; + private final ImmutableSet astOptimizers; + + CelOptimizerImpl(Cel cel, ImmutableSet astOptimizers) { + this.cel = cel; + this.astOptimizers = astOptimizers; + } + + @Override + public CelAbstractSyntaxTree optimize(CelAbstractSyntaxTree ast) throws CelOptimizationException { + if (!ast.isChecked()) { + throw new IllegalArgumentException("AST must be type-checked."); + } + + Cel celOptimizerEnv = cel; + CelAbstractSyntaxTree optimizedAst = ast; + try { + for (CelAstOptimizer optimizer : astOptimizers) { + OptimizationResult result = optimizer.optimize(optimizedAst, celOptimizerEnv); + if (!result.newFunctionDecls().isEmpty() || !result.newVarDecls().isEmpty()) { + celOptimizerEnv = + celOptimizerEnv + .toCelBuilder() + .addVarDeclarations(result.newVarDecls()) + .addFunctionDeclarations(result.newFunctionDecls()) + .build(); + } + optimizedAst = celOptimizerEnv.check(result.optimizedAst()).getAst(); + } + } catch (CelValidationException e) { + throw new CelOptimizationException( + "Optimized AST failed to type-check: " + e.getMessage(), e); + } catch (RuntimeException e) { + throw new CelOptimizationException("Optimization failure: " + e.getMessage(), e); + } + + return optimizedAst; + } + + /** Create a new builder for constructing a {@link CelOptimizer} instance. */ + static CelOptimizerImpl.Builder newBuilder(Cel cel) { + return new CelOptimizerImpl.Builder(cel); + } + + /** Builder class for {@link CelOptimizerImpl}. */ + static final class Builder implements CelOptimizerBuilder { + private final Cel cel; + private final ImmutableSet.Builder astOptimizers; + + private Builder(Cel cel) { + this.cel = cel; + this.astOptimizers = ImmutableSet.builder(); + } + + @Override + public CelOptimizerBuilder addAstOptimizers(CelAstOptimizer... astOptimizers) { + checkNotNull(astOptimizers); + return addAstOptimizers(Arrays.asList(astOptimizers)); + } + + @Override + public CelOptimizerBuilder addAstOptimizers(Iterable astOptimizers) { + checkNotNull(astOptimizers); + this.astOptimizers.addAll(astOptimizers); + return this; + } + + @Override + public CelOptimizer build() { + return new CelOptimizerImpl(cel, astOptimizers.build()); + } + } +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java b/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java new file mode 100644 index 000000000..7a04a3c3a --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java @@ -0,0 +1,165 @@ +// Copyright 2024 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.optimizer; + +import com.google.common.base.Preconditions; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.common.annotations.Internal; +import dev.cel.common.ast.CelExprIdGeneratorFactory.ExprIdGenerator; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExpr.CelMutableCall; +import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; +import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; +import java.util.List; + +/** + * MutableExprVisitor performs mutation of {@link CelMutableExpr} based on its configured + * parameters. + * + *

This class is NOT thread-safe. Callers should spawn a new instance of this class each time the + * expression is being mutated. + */ +@Internal +final class MutableExprVisitor { + private final CelMutableExpr newExpr; + private final ExprIdGenerator celExprIdGenerator; + private final long iterationLimit; + private int iterationCount; + private long exprIdToReplace; + + static MutableExprVisitor newInstance( + ExprIdGenerator idGenerator, + CelMutableExpr newExpr, + long exprIdToReplace, + long iterationLimit) { + // iterationLimit * 2, because the expr can be walked twice due to the immutable nature of + // CelExpr. + return new MutableExprVisitor(idGenerator, newExpr, exprIdToReplace, iterationLimit * 2); + } + + CelMutableExpr visit(CelMutableExpr root) { + if (++iterationCount > iterationLimit) { + throw new IllegalStateException("Max iteration count reached."); + } + + if (root.id() == exprIdToReplace) { + exprIdToReplace = Integer.MIN_VALUE; // Marks that the subtree has been replaced. + this.newExpr.setId(root.id()); + return visit(this.newExpr); + } + + root.setId(celExprIdGenerator.generate(root.id())); + + switch (root.getKind()) { + case SELECT: + return visit(root, root.select()); + case CALL: + return visit(root, root.call()); + case LIST: + return visit(root, root.list()); + case STRUCT: + return visit(root, root.struct()); + case MAP: + return visit(root, root.map()); + case COMPREHENSION: + return visit(root, root.comprehension()); + case CONSTANT: // Fall-through is intended + case IDENT: + case NOT_SET: // Note: comprehension arguments can contain a not set root. + return root; + } + throw new IllegalArgumentException("unexpected root kind: " + root.getKind()); + } + + @CanIgnoreReturnValue + private CelMutableExpr visit(CelMutableExpr expr, CelMutableSelect select) { + select.setOperand(visit(select.operand())); + return expr; + } + + @CanIgnoreReturnValue + private CelMutableExpr visit(CelMutableExpr expr, CelMutableCall call) { + if (call.target().isPresent()) { + call.setTarget(visit(call.target().get())); + } + List argsBuilders = call.args(); + for (int i = 0; i < argsBuilders.size(); i++) { + CelMutableExpr arg = argsBuilders.get(i); + call.setArg(i, visit(arg)); + } + + return expr; + } + + @CanIgnoreReturnValue + private CelMutableExpr visit(CelMutableExpr expr, CelMutableStruct struct) { + List entries = struct.entries(); + for (CelMutableStruct.Entry entry : entries) { + entry.setId(celExprIdGenerator.generate(entry.id())); + entry.setValue(visit(entry.value())); + } + + return expr; + } + + @CanIgnoreReturnValue + private CelMutableExpr visit(CelMutableExpr expr, CelMutableMap map) { + List entriesBuilders = map.entries(); + for (CelMutableMap.Entry entry : entriesBuilders) { + entry.setId(celExprIdGenerator.generate(entry.id())); + entry.setKey(visit(entry.key())); + entry.setValue(visit(entry.value())); + } + + return expr; + } + + @CanIgnoreReturnValue + private CelMutableExpr visit(CelMutableExpr expr, CelMutableList list) { + List elementsBuilders = list.elements(); + for (int i = 0; i < elementsBuilders.size(); i++) { + CelMutableExpr elem = elementsBuilders.get(i); + list.setElement(i, visit(elem)); + } + + return expr; + } + + @CanIgnoreReturnValue + private CelMutableExpr visit(CelMutableExpr expr, CelMutableComprehension comprehension) { + comprehension.setIterRange(visit(comprehension.iterRange())); + comprehension.setAccuInit(visit(comprehension.accuInit())); + comprehension.setLoopCondition(visit(comprehension.loopCondition())); + comprehension.setLoopStep(visit(comprehension.loopStep())); + comprehension.setResult(visit(comprehension.result())); + + return expr; + } + + private MutableExprVisitor( + ExprIdGenerator celExprIdGenerator, + CelMutableExpr newExpr, + long exprId, + long iterationLimit) { + Preconditions.checkState(iterationLimit > 0L); + this.iterationLimit = iterationLimit; + this.celExprIdGenerator = celExprIdGenerator; + this.newExpr = newExpr; + this.exprIdToReplace = exprId; + } +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/optimizers/BUILD.bazel b/optimizer/src/main/java/dev/cel/optimizer/optimizers/BUILD.bazel new file mode 100644 index 000000000..155ae262d --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/optimizers/BUILD.bazel @@ -0,0 +1,117 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//optimizer/optimizers:__pkg__", + "//publish:__pkg__", + ], +) + +java_library( + name = "constant_folding", + srcs = [ + "ConstantFoldingOptimizer.java", + ], + tags = [ + ], + deps = [ + ":default_optimizer_constants", + "//:auto_value", + "//bundle:cel", + "//checker:standard_decl", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:mutable_ast", + "//common:operator", + "//common/ast", + "//common/ast:mutable_expr", + "//common/internal:date_time_helpers", + "//common/navigation:common", + "//common/navigation:mutable_navigation", + "//common/types", + "//extensions:optional_library", + "//optimizer:ast_optimizer", + "//optimizer:mutable_ast", + "//optimizer:optimization_exception", + "//runtime", + "//runtime:partial_vars", + "//runtime:unknown_attributes", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "common_subexpression_elimination", + srcs = [ + "SubexpressionOptimizer.java", + ], + tags = [ + ], + deps = [ + ":default_optimizer_constants", + "//:auto_value", + "//bundle:cel", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:mutable_ast", + "//common:mutable_source", + "//common/ast", + "//common/ast:mutable_expr", + "//common/navigation", + "//common/navigation:common", + "//common/navigation:mutable_navigation", + "//common/types", + "//common/types:type_providers", + "//optimizer:ast_optimizer", + "//optimizer:mutable_ast", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "inlining", + srcs = [ + "InliningOptimizer.java", + ], + tags = [ + ], + deps = [ + "//:auto_value", + "//bundle:cel", + "//common:cel_ast", + "//common:mutable_ast", + "//common:operator", + "//common/ast", + "//common/ast:mutable_expr", + "//common/navigation:mutable_navigation", + "//common/types", + "//common/types:type_providers", + "//common/values", + "//optimizer:ast_optimizer", + "//optimizer:mutable_ast", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "default_optimizer_constants", + srcs = [ + "DefaultOptimizerConstants.java", + ], + visibility = ["//visibility:private"], + deps = [ + "//checker:standard_decl", + "//common:operator", + "//extensions", + "//extensions:optional_library", + "@maven//:com_google_guava_guava", + ], +) diff --git a/optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java b/optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java new file mode 100644 index 000000000..35d181905 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java @@ -0,0 +1,813 @@ +// Copyright 2023 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.optimizer.optimizers; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.MoreCollectors.onlyElement; +import static dev.cel.checker.CelStandardDeclarations.StandardFunction.DURATION; +import static dev.cel.checker.CelStandardDeclarations.StandardFunction.TIMESTAMP; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelMutableAst; +import dev.cel.common.CelSource; +import dev.cel.common.CelValidationException; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExpr.CelMutableCall; +import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; +import dev.cel.common.ast.CelMutableExprConverter; +import dev.cel.common.internal.DateTimeHelpers; +import dev.cel.common.navigation.CelNavigableMutableAst; +import dev.cel.common.navigation.CelNavigableMutableExpr; +import dev.cel.common.navigation.TraversalOrder; +import dev.cel.common.types.SimpleType; +import dev.cel.extensions.CelOptionalLibrary.Function; +import dev.cel.optimizer.AstMutator; +import dev.cel.optimizer.CelAstOptimizer; +import dev.cel.optimizer.CelOptimizationException; +import dev.cel.runtime.CelAttributePattern; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.PartialVars; +import java.time.Duration; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** + * Performs optimization for inlining constant scalar and aggregate literal values within function + * calls and select statements with their evaluated result. + */ +public final class ConstantFoldingOptimizer implements CelAstOptimizer { + private static final ConstantFoldingOptimizer INSTANCE = + new ConstantFoldingOptimizer(ConstantFoldingOptions.newBuilder().build()); + + /** Returns a default instance of constant folding optimizer with preconfigured defaults. */ + public static ConstantFoldingOptimizer getInstance() { + return INSTANCE; + } + + /** + * Returns a new instance of constant folding optimizer configured with the provided {@link + * ConstantFoldingOptions}. + */ + public static ConstantFoldingOptimizer newInstance( + ConstantFoldingOptions constantFoldingOptions) { + return new ConstantFoldingOptimizer(constantFoldingOptions); + } + + private final ConstantFoldingOptions constantFoldingOptions; + private final AstMutator astMutator; + private final ImmutableSet foldableFunctions; + + // Use optional.of and optional.none as sentinel function names for folding optional calls. + // TODO: Leverage CelValue representation of Optionals instead when available. + private static CelMutableExpr newOptionalNoneExpr() { + return CelMutableExpr.ofCall(CelMutableCall.create(Function.OPTIONAL_NONE.getFunction())); + } + + @Override + public OptimizationResult optimize(CelAbstractSyntaxTree ast, Cel cel) + throws CelOptimizationException { + // Override the environment's expected type to generally allow all subtrees to be folded. + Cel optimizerEnv = cel.toCelBuilder().setResultType(SimpleType.DYN).build(); + + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + int iterCount = 0; + boolean continueFolding = true; + while (continueFolding) { + if (iterCount >= constantFoldingOptions.maxIterationLimit()) { + throw new IllegalStateException("Max iteration count reached."); + } + iterCount++; + continueFolding = false; + + ImmutableList foldableExprs = + CelNavigableMutableAst.fromAst(mutableAst) + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .filter(this::canFold) + .collect(toImmutableList()); + for (CelNavigableMutableExpr foldableExpr : foldableExprs) { + iterCount++; + + Optional mutatedResult; + // Attempt to prune if it is a non-strict call + mutatedResult = maybePruneBranches(mutableAst, foldableExpr.expr()); + if (!mutatedResult.isPresent()) { + // Evaluate the call then fold + try { + mutatedResult = maybeFold(optimizerEnv, mutableAst, foldableExpr); + } catch (CelEvaluationException e) { + throw new CelOptimizationException( + "Constant folding failure. Failed to evaluate subtree due to: " + e.getMessage(), + e); + } + } + + if (!mutatedResult.isPresent()) { + // Skip this expr. It's neither prune-able nor foldable. + continue; + } + + continueFolding = true; + mutableAst = mutatedResult.get(); + // Break the loop because we mutated the AST. Since we traverse in PRE_ORDER (top-down), + // mutating a parent node means its children are now obsolete or folded. + // We restart the traversal to gather a fresh list of foldable expressions. + break; + } + } + + // If the output is a list, map, or struct which contains optional entries, then prune it + // to make sure that the optionals, if resolved, do not surface in the output literal. + mutableAst = pruneOptionalElements(mutableAst); + + return OptimizationResult.create(astMutator.renumberIdsConsecutively(mutableAst).toParsedAst()); + } + + private boolean canFold(CelNavigableMutableExpr navigableExpr) { + switch (navigableExpr.getKind()) { + case CALL: + if (!containsFoldableFunctionOnly(navigableExpr)) { + return false; + } + + // Timestamps/durations in CEL are calls, but they are effectively treated as literals. + // Expressions like timestamp(123) cannot be folded directly, but arithmetics involving + // timestamps can be optimized. + // Ex: timestamp(123) - timestamp(100) = duration("23s") + if (isCallTimestampOrDuration(navigableExpr.expr().call())) { + return false; + } + + CelMutableCall mutableCall = navigableExpr.expr().call(); + String functionName = mutableCall.function(); + + // These are already folded or do not need to be folded. + if (functionName.equals(Function.OPTIONAL_OF.getFunction()) + || functionName.equals(Function.OPTIONAL_NONE.getFunction())) { + return false; + } + + // Check non-strict calls + if (functionName.equals(Operator.LOGICAL_AND.getFunction()) + || functionName.equals(Operator.LOGICAL_OR.getFunction())) { + + // If any element is a constant, this could be a foldable expr (e.g: x && false -> x) + return mutableCall.args().stream().anyMatch(node -> node.getKind().equals(Kind.CONSTANT)); + } + + if (functionName.equals(Operator.CONDITIONAL.getFunction())) { + CelMutableExpr cond = mutableCall.args().get(0); + + // A ternary with a constant condition is trivially foldable + return cond.getKind().equals(Kind.CONSTANT) + && cond.constant().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE); + } + + if (functionName.equals(Operator.EQUALS.getFunction()) + || functionName.equals(Operator.NOT_EQUALS.getFunction())) { + if (mutableCall.args().stream() + .anyMatch(node -> isExprConstantOfKind(node, CelConstant.Kind.BOOLEAN_VALUE)) + || mutableCall.args().stream() + .allMatch(node -> node.getKind().equals(Kind.CONSTANT))) { + return true; + } + } + + if (functionName.equals(Operator.IN.getFunction())) { + return canFoldInOperator(navigableExpr); + } + + // Default case: all call arguments must be constants. If the argument is a container (ex: + // list, map), then its arguments must be a constant. + return areChildrenArgConstant(navigableExpr); + case SELECT: + CelNavigableMutableExpr operand = navigableExpr.children().collect(onlyElement()); + return areChildrenArgConstant(operand); + case COMPREHENSION: + return !isNestedComprehension(navigableExpr) && containsFoldableFunctionOnly(navigableExpr); + default: + return false; + } + } + + private boolean containsFoldableFunctionOnly(CelNavigableMutableExpr navigableExpr) { + return navigableExpr + .allNodes() + .filter(node -> node.getKind().equals(Kind.CALL)) + .map(node -> node.expr().call()) + .allMatch(call -> foldableFunctions.contains(call.function())); + } + + private static boolean isCallTimestampOrDuration(CelMutableCall call) { + return call.function().equals(TIMESTAMP.functionName()) + || call.function().equals(DURATION.functionName()); + } + + private static boolean canFoldInOperator(CelNavigableMutableExpr navigableExpr) { + ImmutableList allIdents = + navigableExpr + .allNodes() + .filter(node -> node.getKind().equals(Kind.IDENT)) + .collect(toImmutableList()); + for (CelNavigableMutableExpr identNode : allIdents) { + CelNavigableMutableExpr parent = identNode.parent().orElse(null); + while (parent != null) { + if (parent.getKind().equals(Kind.COMPREHENSION)) { + String identName = identNode.expr().ident().name(); + CelMutableComprehension parentComprehension = parent.expr().comprehension(); + if (parentComprehension.accuVar().equals(identName) + || parentComprehension.iterVar().equals(identName) + || parentComprehension.iterVar2().equals(identName)) { + // Prevent folding a subexpression if it contains a variable declared by a + // comprehension. The subexpression cannot be compiled without the full context of the + // surrounding comprehension. + return false; + } + } + parent = parent.parent().orElse(null); + } + } + + return true; + } + + private static boolean areChildrenArgConstant(CelNavigableMutableExpr expr) { + if (expr.getKind().equals(Kind.CONSTANT)) { + return true; + } + + if (expr.getKind().equals(Kind.CALL) + || expr.getKind().equals(Kind.LIST) + || expr.getKind().equals(Kind.MAP) + || expr.getKind().equals(Kind.SELECT) + || expr.getKind().equals(Kind.STRUCT)) { + return expr.children().allMatch(ConstantFoldingOptimizer::areChildrenArgConstant); + } + + return false; + } + + private static boolean isNestedComprehension(CelNavigableMutableExpr expr) { + Optional maybeParent = expr.parent(); + while (maybeParent.isPresent()) { + CelNavigableMutableExpr parent = maybeParent.get(); + if (parent.getKind().equals(Kind.COMPREHENSION)) { + return true; + } + maybeParent = parent.parent(); + } + + return false; + } + + private Optional maybeFold( + Cel cel, CelMutableAst mutableAst, CelNavigableMutableExpr node) + throws CelOptimizationException, CelEvaluationException { + Object result; + try { + result = evaluateExpr(cel, node); + } catch (CelValidationException e) { + throw new CelOptimizationException( + "Constant folding failure. Failed to evaluate subtree due to: " + e.getMessage(), e); + } + + // Rewrite optional calls to use the sentinel optional functions. + // ex1: optional.ofNonZeroValue(0) -> optional.none(). + // ex2: optional.ofNonZeroValue(5) -> optional.of(5) + if (result instanceof Optional) { + Optional optResult = ((Optional) result); + return maybeRewriteOptional(optResult, mutableAst, node.expr()); + } + + CelMutableExpr adaptedResult = maybeAdaptEvaluatedResult(result).orElse(null); + if (adaptedResult == null) { + return Optional.empty(); + } + + return Optional.of(astMutator.replaceSubtree(mutableAst, adaptedResult, node.id())); + } + + private Optional maybeAdaptEvaluatedResult(Object result) { + if (CelConstant.isConstantValue(result)) { + return Optional.of(CelMutableExpr.ofConstant(CelConstant.ofObjectValue(result))); + } else if (result instanceof Collection) { + Collection collection = (Collection) result; + List listElements = new ArrayList<>(); + for (Object evaluatedElement : collection) { + CelMutableExpr adaptedExpr = maybeAdaptEvaluatedResult(evaluatedElement).orElse(null); + if (adaptedExpr == null) { + return Optional.empty(); + } + listElements.add(adaptedExpr); + } + + return Optional.of(CelMutableExpr.ofList(CelMutableList.create(listElements))); + } else if (result instanceof Map) { + Map map = (Map) result; + List mapEntries = new ArrayList<>(); + for (Map.Entry entry : map.entrySet()) { + CelMutableExpr adaptedKey = maybeAdaptEvaluatedResult(entry.getKey()).orElse(null); + if (adaptedKey == null) { + return Optional.empty(); + } + CelMutableExpr adaptedValue = maybeAdaptEvaluatedResult(entry.getValue()).orElse(null); + if (adaptedValue == null) { + return Optional.empty(); + } + + mapEntries.add(CelMutableMap.Entry.create(adaptedKey, adaptedValue)); + } + + return Optional.of(CelMutableExpr.ofMap(CelMutableMap.create(mapEntries))); + } else if (result instanceof Duration) { + String durationStrArg = DateTimeHelpers.toString((Duration) result); + CelMutableCall durationCall = + CelMutableCall.create( + DURATION.functionName(), + CelMutableExpr.ofConstant(CelConstant.ofValue(durationStrArg))); + + return Optional.of(CelMutableExpr.ofCall(durationCall)); + } else if (result instanceof Instant) { + String timestampStrArg = result.toString(); + CelMutableCall timestampCall = + CelMutableCall.create( + TIMESTAMP.functionName(), + CelMutableExpr.ofConstant(CelConstant.ofValue(timestampStrArg))); + + return Optional.of(CelMutableExpr.ofCall(timestampCall)); + } + + // Evaluated result cannot be folded (e.g: unknowns) + return Optional.empty(); + } + + private Optional maybeRewriteOptional( + Optional optResult, CelMutableAst mutableAst, CelMutableExpr expr) { + Object unwrappedResult = optResult.orElse(null); + if (unwrappedResult == null) { + if (isCallToFunction(expr, Function.OPTIONAL_NONE.getFunction())) { + return Optional.empty(); + } + // An empty optional value was encountered. Rewrite the tree with optional.none call. + // This is to account for other optional functions returning an empty optional value + // e.g: optional.ofNonZeroValue(0) + return Optional.of(astMutator.replaceSubtree(mutableAst, newOptionalNoneExpr(), expr.id())); + } + + if (isCallToFunction(expr, Function.OPTIONAL_OF.getFunction())) { + return Optional.empty(); + } + + CelMutableExpr adaptedResult = maybeAdaptEvaluatedResult(unwrappedResult).orElse(null); + if (adaptedResult == null) { + // Evaluated result is not an adaptable constant. Leave the optional as is. + return Optional.empty(); + } + + CelMutableExpr newOptionalOfCall = + CelMutableExpr.ofCall( + CelMutableCall.create(Function.OPTIONAL_OF.getFunction(), adaptedResult)); + + return Optional.of(astMutator.replaceSubtree(mutableAst, newOptionalOfCall, expr.id())); + } + + private static boolean isCallToFunction(CelMutableExpr expr, String functionName) { + return expr.getKind().equals(Kind.CALL) && expr.call().function().equals(functionName); + } + + /** Inspects the non-strict calls to determine whether a branch can be removed. */ + private Optional maybePruneBranches( + CelMutableAst mutableAst, CelMutableExpr expr) { + if (!expr.getKind().equals(Kind.CALL)) { + return Optional.empty(); + } + + CelMutableCall call = expr.call(); + String function = call.function(); + if (function.equals(Operator.LOGICAL_AND.getFunction()) + || function.equals(Operator.LOGICAL_OR.getFunction())) { + return maybeShortCircuitCall(mutableAst, expr); + } else if (function.equals(Operator.CONDITIONAL.getFunction())) { + CelMutableExpr cond = call.args().get(0); + CelMutableExpr truthy = call.args().get(1); + CelMutableExpr falsy = call.args().get(2); + if (!cond.getKind().equals(Kind.CONSTANT)) { + throw new IllegalStateException( + String.format("Expected constant condition. Got: %s instead.", cond.getKind())); + } + CelMutableExpr result = cond.constant().booleanValue() ? truthy : falsy; + + return Optional.of(astMutator.replaceSubtree(mutableAst, result, expr.id())); + } else if (function.equals(Operator.IN.getFunction())) { + CelMutableExpr callArg = call.args().get(1); + if (!callArg.getKind().equals(Kind.LIST)) { + return Optional.empty(); + } + + CelMutableList haystack = callArg.list(); + if (haystack.elements().isEmpty()) { + return Optional.of( + astMutator.replaceSubtree( + mutableAst, CelMutableExpr.ofConstant(CelConstant.ofValue(false)), expr.id())); + } + + CelMutableExpr needle = call.args().get(0); + if (needle.getKind().equals(Kind.CONSTANT) || needle.getKind().equals(Kind.IDENT)) { + Object needleValue = + needle.getKind().equals(Kind.CONSTANT) ? needle.constant() : needle.ident(); + for (CelMutableExpr elem : haystack.elements()) { + if ((elem.getKind().equals(Kind.CONSTANT) && elem.constant().equals(needleValue)) + || (elem.getKind().equals(Kind.IDENT) && elem.ident().equals(needleValue))) { + return Optional.of( + astMutator.replaceSubtree( + mutableAst.expr(), + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), + expr.id())); + } + } + } + } else if (function.equals(Operator.EQUALS.getFunction()) + || function.equals(Operator.NOT_EQUALS.getFunction())) { + CelMutableExpr lhs = call.args().get(0); + CelMutableExpr rhs = call.args().get(1); + boolean lhsIsBoolean = isExprConstantOfKind(lhs, CelConstant.Kind.BOOLEAN_VALUE); + boolean rhsIsBoolean = isExprConstantOfKind(rhs, CelConstant.Kind.BOOLEAN_VALUE); + boolean invertCondition = function.equals(Operator.NOT_EQUALS.getFunction()); + Optional replacementExpr = Optional.empty(); + + if (lhs.getKind().equals(Kind.CONSTANT) && rhs.getKind().equals(Kind.CONSTANT)) { + // If both args are const, don't prune any branches and let maybeFold method evaluate this + // subExpr + return Optional.empty(); + } else if (lhsIsBoolean) { + boolean cond = invertCondition != lhs.constant().booleanValue(); + replacementExpr = + Optional.of( + cond + ? rhs + : CelMutableExpr.ofCall( + CelMutableCall.create(Operator.LOGICAL_NOT.getFunction(), rhs))); + } else if (rhsIsBoolean) { + boolean cond = invertCondition != rhs.constant().booleanValue(); + replacementExpr = + Optional.of( + cond + ? lhs + : CelMutableExpr.ofCall( + CelMutableCall.create(Operator.LOGICAL_NOT.getFunction(), lhs))); + } + + return replacementExpr.map(node -> astMutator.replaceSubtree(mutableAst, node, expr.id())); + } + + return Optional.empty(); + } + + private Optional maybeShortCircuitCall( + CelMutableAst mutableAst, CelMutableExpr expr) { + CelMutableCall call = expr.call(); + boolean shortCircuit = false; + boolean skip = true; + if (call.function().equals(Operator.LOGICAL_OR.getFunction())) { + shortCircuit = true; + skip = false; + } + ImmutableList.Builder newArgsBuilder = new ImmutableList.Builder<>(); + + for (CelMutableExpr arg : call.args()) { + if (!arg.getKind().equals(Kind.CONSTANT)) { + newArgsBuilder.add(arg); + continue; + } + if (arg.constant().booleanValue() == skip) { + continue; + } + + if (arg.constant().booleanValue() == shortCircuit) { + return Optional.of(astMutator.replaceSubtree(mutableAst, arg, expr.id())); + } + } + + ImmutableList newArgs = newArgsBuilder.build(); + if (newArgs.isEmpty()) { + CelMutableExpr shortCircuitTarget = + call.args().get(0); // either args(0) or args(1) would work here + return Optional.of(astMutator.replaceSubtree(mutableAst, shortCircuitTarget, expr.id())); + } + if (newArgs.size() == 1) { + return Optional.of(astMutator.replaceSubtree(mutableAst, newArgs.get(0), expr.id())); + } + + // TODO: Support folding variadic AND/ORs. + throw new UnsupportedOperationException( + "Folding variadic logical operator is not supported yet."); + } + + private boolean isFoldedAggregateLiteral(CelMutableExpr expr) { + if (expr.getKind().equals(Kind.CONSTANT)) { + return true; + } + if (expr.getKind().equals(Kind.LIST)) { + for (CelMutableExpr child : expr.list().elements()) { + if (!isFoldedAggregateLiteral(child)) { + return false; + } + } + return true; + } + if (expr.getKind().equals(Kind.MAP)) { + for (CelMutableExpr.CelMutableMap.Entry entry : expr.map().entries()) { + if (!isFoldedAggregateLiteral(entry.key()) || !isFoldedAggregateLiteral(entry.value())) { + return false; + } + } + return true; + } + if (expr.getKind().equals(Kind.STRUCT)) { + for (CelMutableExpr.CelMutableStruct.Entry entry : expr.struct().entries()) { + if (!isFoldedAggregateLiteral(entry.value())) { + return false; + } + } + return true; + } + return false; + } + + private CelMutableAst pruneOptionalElements(CelMutableAst ast) { + ImmutableList aggregateLiterals = + CelNavigableMutableExpr.fromExpr(ast.expr()) + .allNodes() + .filter( + node -> + node.getKind().equals(Kind.LIST) + || node.getKind().equals(Kind.MAP) + || node.getKind().equals(Kind.STRUCT)) + .map(CelNavigableMutableExpr::expr) + .collect(toImmutableList()); + + for (CelMutableExpr expr : aggregateLiterals) { + switch (expr.getKind()) { + case LIST: + ast = pruneOptionalListElements(ast, expr); + break; + case MAP: + ast = pruneOptionalMapElements(ast, expr); + break; + case STRUCT: + ast = pruneOptionalStructElements(ast, expr); + break; + default: + throw new IllegalArgumentException("Unexpected exprKind: " + expr.getKind()); + } + } + + return ast; + } + + private CelMutableAst pruneOptionalListElements(CelMutableAst mutableAst, CelMutableExpr expr) { + CelMutableList list = expr.list(); + if (list.optionalIndices().isEmpty()) { + return mutableAst; + } + + HashSet optionalIndices = new HashSet<>(list.optionalIndices()); + ImmutableList.Builder updatedElemBuilder = new ImmutableList.Builder<>(); + ImmutableList.Builder updatedIndicesBuilder = new ImmutableList.Builder<>(); + int newOptIndex = -1; + for (int i = 0; i < list.elements().size(); i++) { + newOptIndex++; + CelMutableExpr element = list.elements().get(i); + if (!optionalIndices.contains(i)) { + updatedElemBuilder.add(element); + continue; + } + + if (element.getKind().equals(Kind.CALL)) { + CelMutableCall call = element.call(); + if (call.function().equals(Function.OPTIONAL_NONE.getFunction())) { + // Skip optional.none. + // Skipping causes the list to get smaller. + newOptIndex--; + continue; + } else if (call.function().equals(Function.OPTIONAL_OF.getFunction())) { + CelMutableExpr arg = call.args().get(0); + if (isFoldedAggregateLiteral(arg)) { + updatedElemBuilder.add(call.args().get(0)); + continue; + } + } + } + + updatedElemBuilder.add(element); + updatedIndicesBuilder.add(newOptIndex); + } + + return astMutator.replaceSubtree( + mutableAst, + CelMutableExpr.ofList( + CelMutableList.create(updatedElemBuilder.build(), updatedIndicesBuilder.build())), + expr.id()); + } + + private CelMutableAst pruneOptionalMapElements(CelMutableAst ast, CelMutableExpr expr) { + CelMutableMap map = expr.map(); + ImmutableList.Builder updatedEntryBuilder = new ImmutableList.Builder<>(); + boolean modified = false; + for (CelMutableMap.Entry entry : map.entries()) { + CelMutableExpr key = entry.key(); + Kind keyKind = key.getKind(); + CelMutableExpr value = entry.value(); + Kind valueKind = value.getKind(); + if (!entry.optionalEntry() + || !keyKind.equals(Kind.CONSTANT) + || !valueKind.equals(Kind.CALL)) { + updatedEntryBuilder.add(entry); + continue; + } + + CelMutableCall call = value.call(); + if (call.function().equals(Function.OPTIONAL_NONE.getFunction())) { + // Skip the element. This is resolving an optional.none: ex {?1: optional.none()}. + modified = true; + continue; + } else if (call.function().equals(Function.OPTIONAL_OF.getFunction())) { + CelMutableExpr arg = call.args().get(0); + if (isFoldedAggregateLiteral(arg)) { + modified = true; + entry.setOptionalEntry(false); + entry.setValue(call.args().get(0)); + updatedEntryBuilder.add(entry); + continue; + } + } + + updatedEntryBuilder.add(entry); + } + + if (modified) { + return astMutator.replaceSubtree( + ast, CelMutableExpr.ofMap(CelMutableMap.create(updatedEntryBuilder.build())), expr.id()); + } + + return ast; + } + + private CelMutableAst pruneOptionalStructElements(CelMutableAst ast, CelMutableExpr expr) { + CelMutableStruct struct = expr.struct(); + ImmutableList.Builder updatedEntryBuilder = + new ImmutableList.Builder<>(); + boolean modified = false; + for (CelMutableStruct.Entry entry : struct.entries()) { + CelMutableExpr value = entry.value(); + Kind valueKind = value.getKind(); + if (!entry.optionalEntry() || !valueKind.equals(Kind.CALL)) { + // Preserve the entry as is + updatedEntryBuilder.add(entry); + continue; + } + + CelMutableCall call = value.call(); + if (call.function().equals(Function.OPTIONAL_NONE.getFunction())) { + // Skip the element. This is resolving an optional.none: ex msg{?field: optional.none()}. + modified = true; + continue; + } else if (call.function().equals(Function.OPTIONAL_OF.getFunction())) { + CelMutableExpr arg = call.args().get(0); + if (isFoldedAggregateLiteral(arg)) { + modified = true; + entry.setOptionalEntry(false); + entry.setValue(call.args().get(0)); + updatedEntryBuilder.add(entry); + continue; + } + } + + updatedEntryBuilder.add(entry); + } + + if (modified) { + return astMutator.replaceSubtree( + ast, + CelMutableExpr.ofStruct( + CelMutableStruct.create(struct.messageName(), updatedEntryBuilder.build())), + expr.id()); + } + + return ast; + } + + @CanIgnoreReturnValue + private static Object evaluateExpr(Cel cel, CelNavigableMutableExpr navigableMutableExpr) + throws CelValidationException, CelEvaluationException { + ImmutableList attributePatterns = + navigableMutableExpr + .allNodes() + .filter(node -> node.getKind().equals(Kind.IDENT)) + .map(node -> node.expr().ident().name()) + .map(CelAttributePattern::fromQualifiedIdentifier) + .collect(toImmutableList()); + CelAbstractSyntaxTree ast = + CelAbstractSyntaxTree.newParsedAst( + CelMutableExprConverter.fromMutableExpr(navigableMutableExpr.expr()), + CelSource.newBuilder().build()); + ast = cel.check(ast).getAst(); + + return cel.createProgram(ast).eval(PartialVars.of(attributePatterns)); + } + + /** Options to configure how Constant Folding behave. */ + @AutoValue + public abstract static class ConstantFoldingOptions { + public abstract int maxIterationLimit(); + + public abstract ImmutableSet foldableFunctions(); + + /** Builder for configuring the {@link ConstantFoldingOptions}. */ + @AutoValue.Builder + public abstract static class Builder { + + abstract ImmutableSet.Builder foldableFunctionsBuilder(); + + /** + * Limit the number of iteration while performing constant folding. An exception is thrown if + * the iteration count exceeds the set value. + */ + public abstract Builder maxIterationLimit(int value); + + /** + * Adds a collection of custom functions that will be a candidate for constant folding. By + * default, standard functions are foldable. + * + *

Note that the implementation of custom functions must be free of side effects. + */ + @CanIgnoreReturnValue + public Builder addFoldableFunctions(Iterable functions) { + checkNotNull(functions); + this.foldableFunctionsBuilder().addAll(functions); + return this; + } + + /** See {@link #addFoldableFunctions(Iterable)}. */ + @CanIgnoreReturnValue + public Builder addFoldableFunctions(String... functions) { + return addFoldableFunctions(Arrays.asList(functions)); + } + + public abstract ConstantFoldingOptions build(); + + Builder() {} + } + + /** Returns a new options builder with recommended defaults pre-configured. */ + public static Builder newBuilder() { + return new AutoValue_ConstantFoldingOptimizer_ConstantFoldingOptions.Builder() + .maxIterationLimit(400); + } + + ConstantFoldingOptions() {} + } + + private static boolean isExprConstantOfKind(CelMutableExpr expr, CelConstant.Kind constantKind) { + return expr.getKind().equals(Kind.CONSTANT) && expr.constant().getKind().equals(constantKind); + } + + private ConstantFoldingOptimizer(ConstantFoldingOptions constantFoldingOptions) { + this.constantFoldingOptions = constantFoldingOptions; + this.astMutator = AstMutator.newInstance(constantFoldingOptions.maxIterationLimit()); + this.foldableFunctions = + ImmutableSet.builder() + .addAll(DefaultOptimizerConstants.CEL_CANONICAL_FUNCTIONS) + .addAll(constantFoldingOptions.foldableFunctions()) + .build(); + } +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/optimizers/DefaultOptimizerConstants.java b/optimizer/src/main/java/dev/cel/optimizer/optimizers/DefaultOptimizerConstants.java new file mode 100644 index 000000000..a9db48391 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/optimizers/DefaultOptimizerConstants.java @@ -0,0 +1,50 @@ +// Copyright 2024 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.optimizer.optimizers; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static java.util.Arrays.stream; + +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Streams; +import dev.cel.checker.CelStandardDeclarations; +import dev.cel.common.Operator; +import dev.cel.extensions.CelExtensions; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.extensions.CelOptionalLibrary.Function; + +/** + * Package-private class that holds constants that's generally applicable across canonical + * optimizers provided from CEL. + */ +final class DefaultOptimizerConstants { + + /** + * List of function names from standard functions and extension libraries. These are free of side + * effects, thus amenable for optimization. + */ + static final ImmutableSet CEL_CANONICAL_FUNCTIONS = + ImmutableSet.builder() + .addAll(CelStandardDeclarations.getAllFunctionNames()) + .addAll( + Streams.concat( + stream(Operator.values()).map(Operator::getFunction), + stream(CelOptionalLibrary.Function.values()).map(Function::getFunction)) + .collect(toImmutableSet())) + .addAll(CelExtensions.getAllFunctionNames()) + .build(); + + private DefaultOptimizerConstants() {} +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/optimizers/InliningOptimizer.java b/optimizer/src/main/java/dev/cel/optimizer/optimizers/InliningOptimizer.java new file mode 100644 index 000000000..e4051f82f --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/optimizers/InliningOptimizer.java @@ -0,0 +1,313 @@ +// 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.optimizer.optimizers; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.UnsignedLong; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelMutableAst; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExpr.CelMutableCall; +import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; +import dev.cel.common.navigation.CelNavigableMutableAst; +import dev.cel.common.navigation.CelNavigableMutableExpr; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.values.NullValue; +import dev.cel.optimizer.AstMutator; +import dev.cel.optimizer.CelAstOptimizer; +import java.util.ArrayList; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Optional; +import java.util.stream.Stream; + +/** + * Performs optimization for inlining variables within function calls and select statements with + * their associated AST. + */ +public final class InliningOptimizer implements CelAstOptimizer { + + private final ImmutableList inlineVariables; + private final AstMutator astMutator; + + /** + * Creates a new {@code InliningOptimizer} with one or more {@link InlineVariable}s. + * + *

Note that the variables to be inlined can be a dependency to one other based on the supplied + * ordering. This allows for recursive inlining where a replacement value might itself contain + * variables that need to be inlined. + * + *

For example, given a source expression {@code "a + b"} and inline variables in the following + * order: + * + *

    + *
  • {@code {a: b, b: 2}}, result: {@code 2 + 2}. + *
  • {@code {b: 2, a: b}}, result: {@code b + 2}. + *
+ */ + public static InliningOptimizer newInstance(InlineVariable... inlineVariables) { + return newInstance(ImmutableList.copyOf(inlineVariables)); + } + + /** + * Creates a new {@code InliningOptimizer}. + * + * @see #newInstance(InlineVariable...) + */ + public static InliningOptimizer newInstance(List inlineVariables) { + return newInstance(InliningOptions.newBuilder().build(), ImmutableList.copyOf(inlineVariables)); + } + + /** + * Creates a new {@code InliningOptimizer}. + * + * @see #newInstance(InlineVariable...) + * @param options {@link InliningOptions} to customize the inlining behavior with. + */ + public static InliningOptimizer newInstance( + InliningOptions options, InlineVariable... inlineVariables) { + return newInstance(options, ImmutableList.copyOf(inlineVariables)); + } + + /** + * Creates a new {@code InliningOptimizer}. + * + * @see #newInstance(InlineVariable...) + * @param options {@link InliningOptions} to customize the inlining behavior with. + */ + public static InliningOptimizer newInstance( + InliningOptions options, List inlineVariables) { + return new InliningOptimizer(options, ImmutableList.copyOf(inlineVariables)); + } + + @Override + public OptimizationResult optimize(CelAbstractSyntaxTree ast, Cel cel) { + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + for (InlineVariable inlineVariable : inlineVariables) { + ImmutableList inlinableExprs = + CelNavigableMutableAst.fromAst(mutableAst) + .getRoot() + .allNodes() + .filter(node -> canInline(node, inlineVariable.name())) + .collect(toImmutableList()); + + for (CelNavigableMutableExpr inlinableExpr : inlinableExprs) { + CelMutableAst inlineVariableAst = CelMutableAst.fromCelAst(inlineVariable.ast()); + CelMutableExpr replacementExpr = inlineVariableAst.expr(); + + if (inlinableExpr.getKind().equals(Kind.SELECT) + && inlinableExpr.expr().select().testOnly()) { + replacementExpr = rewritePresenceExpr(inlineVariable, replacementExpr); + } + + mutableAst = + astMutator.replaceSubtree( + mutableAst, + CelMutableAst.of(replacementExpr, inlineVariableAst.source()), + inlinableExpr.id()); + } + } + + return OptimizationResult.create(astMutator.renumberIdsConsecutively(mutableAst).toParsedAst()); + } + + private static CelMutableExpr rewritePresenceExpr( + InlineVariable inlineVariable, CelMutableExpr replacementExpr) { + if (replacementExpr.getKind().equals(Kind.SELECT)) { + // Preserve testOnly property for Select replacements (has(A) -> has(B)) + replacementExpr.select().setTestOnly(true); + return replacementExpr; + } + + CelType replacementType = + inlineVariable + .ast() + .getType(replacementExpr.id()) + .orElseThrow(() -> new NoSuchElementException("Type is not present.")); + + if (isSizerType(replacementType)) { + // has(X) -> X.size() != 0 + return createNotEquals( + CelMutableExpr.ofCall(CelMutableCall.create(replacementExpr, "size")), + CelMutableExpr.ofConstant(CelConstant.ofValue(0))); + } + + if (replacementType.isAssignableFrom(SimpleType.NULL_TYPE)) { + // has(X) -> X != null + // This covers well-known wrapper types + + return createNotEquals( + replacementExpr, CelMutableExpr.ofConstant(CelConstant.ofValue(NullValue.NULL_VALUE))); + } + + return getZeroValueExpr(replacementType, replacementExpr) + .map(zeroValue -> createNotEquals(replacementExpr, zeroValue)) + .orElseThrow( + () -> + new IllegalArgumentException( + String.format( + "Unable to inline expression type %s into presence test", + replacementType.name()))); + } + + private static Optional getZeroValueExpr( + CelType type, CelMutableExpr replacementExpr) { + switch (type.kind()) { + case BOOL: + return Optional.of(CelMutableExpr.ofConstant(CelConstant.ofValue(false))); + case DOUBLE: + return Optional.of(CelMutableExpr.ofConstant(CelConstant.ofValue(0.0d))); + case INT: + return Optional.of(CelMutableExpr.ofConstant(CelConstant.ofValue(0))); + case UINT: + return Optional.of(CelMutableExpr.ofConstant(CelConstant.ofValue(UnsignedLong.ZERO))); + case TIMESTAMP: + return Optional.of( + CelMutableExpr.ofCall( + CelMutableCall.create( + "timestamp", CelMutableExpr.ofConstant(CelConstant.ofValue(0))))); + case DURATION: + return Optional.of( + CelMutableExpr.ofCall( + CelMutableCall.create( + "duration", CelMutableExpr.ofConstant(CelConstant.ofValue("0"))))); + case STRUCT: + return Optional.of( + CelMutableExpr.ofStruct( + CelMutableStruct.create( + replacementExpr.struct().messageName(), new ArrayList<>()))); + default: + return Optional.empty(); + } + } + + private static CelMutableExpr createNotEquals(CelMutableExpr left, CelMutableExpr right) { + return CelMutableExpr.ofCall( + CelMutableCall.create(Operator.NOT_EQUALS.getFunction(), left, right)); + } + + private static boolean isSizerType(CelType type) { + return type.kind().equals(CelKind.LIST) + || type.kind().equals(CelKind.MAP) + || type.equals(SimpleType.STRING) + || type.equals(SimpleType.BYTES); + } + + private static boolean canInline(CelNavigableMutableExpr node, String identifier) { + boolean matches = maybeToQualifiedName(node).map(name -> name.equals(identifier)).orElse(false); + + if (!matches) { + return false; + } + + for (CelNavigableMutableExpr p = node.parent().orElse(null); + p != null; + p = p.parent().orElse(null)) { + if (p.getKind() != Kind.COMPREHENSION) { + continue; + } + + CelMutableComprehension comp = p.expr().comprehension(); + boolean shadows = + Stream.of(comp.iterVar(), comp.iterVar2(), comp.accuVar()).anyMatch(identifier::equals); + + if (shadows) { + return false; + } + } + + return true; + } + + private static Optional maybeToQualifiedName(CelNavigableMutableExpr node) { + if (node.getKind().equals(Kind.IDENT)) { + return Optional.of(node.expr().ident().name()); + } + + if (node.getKind().equals(Kind.SELECT)) { + return node.children() + .findFirst() + .flatMap(InliningOptimizer::maybeToQualifiedName) + .map(operandName -> operandName + "." + node.expr().select().field()); + } + + return Optional.empty(); + } + + /** Represents a variable to be inlined. */ + @AutoValue + public abstract static class InlineVariable { + public abstract String name(); + + public abstract CelAbstractSyntaxTree ast(); + + /** + * Creates a new {@link InlineVariable} with the given name and AST. + * + *

The name must be a simple identifier or a qualified name (e.g. "a.b.c") and cannot be an + * internal variable (starting with @). + */ + public static InlineVariable of(String name, CelAbstractSyntaxTree ast) { + if (name.startsWith("@")) { + throw new IllegalArgumentException("Internal variables cannot be inlined: " + name); + } + return new AutoValue_InliningOptimizer_InlineVariable(name, ast); + } + } + + /** Options to configure how Inlining behaves. */ + @AutoValue + public abstract static class InliningOptions { + public abstract int maxIterationLimit(); + + /** Builder for configuring the {@link InliningOptimizer.InliningOptions}. */ + @AutoValue.Builder + public abstract static class Builder { + + /** + * Limit the number of iteration while inlining variables. An exception is thrown if the + * iteration count exceeds the set value. + */ + public abstract InliningOptions.Builder maxIterationLimit(int value); + + public abstract InliningOptimizer.InliningOptions build(); + + Builder() {} + } + + /** Returns a new options builder with recommended defaults pre-configured. */ + public static InliningOptimizer.InliningOptions.Builder newBuilder() { + return new AutoValue_InliningOptimizer_InliningOptions.Builder().maxIterationLimit(400); + } + + InliningOptions() {} + } + + private InliningOptimizer( + InliningOptions options, ImmutableList inlineVariables) { + this.inlineVariables = inlineVariables; + this.astMutator = AstMutator.newInstance(options.maxIterationLimit()); + } +} diff --git a/optimizer/src/main/java/dev/cel/optimizer/optimizers/SubexpressionOptimizer.java b/optimizer/src/main/java/dev/cel/optimizer/optimizers/SubexpressionOptimizer.java new file mode 100644 index 000000000..ce9a5dc77 --- /dev/null +++ b/optimizer/src/main/java/dev/cel/optimizer/optimizers/SubexpressionOptimizer.java @@ -0,0 +1,770 @@ +// Copyright 2024 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.optimizer.optimizers; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static java.util.stream.Collectors.toCollection; + +import com.google.auto.value.AutoValue; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Preconditions; +import com.google.common.base.Strings; +import com.google.common.base.Verify; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Streams; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelBuilder; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelMutableAst; +import dev.cel.common.CelMutableSource; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelSource; +import dev.cel.common.CelSource.Extension; +import dev.cel.common.CelSource.Extension.Component; +import dev.cel.common.CelSource.Extension.Version; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelVarDecl; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelComprehension; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; +import dev.cel.common.ast.CelMutableExprConverter; +import dev.cel.common.navigation.CelNavigableExpr; +import dev.cel.common.navigation.CelNavigableMutableAst; +import dev.cel.common.navigation.CelNavigableMutableExpr; +import dev.cel.common.navigation.TraversalOrder; +import dev.cel.common.types.CelType; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.optimizer.AstMutator; +import dev.cel.optimizer.AstMutator.MangledComprehensionAst; +import dev.cel.optimizer.CelAstOptimizer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; + +/** + * Performs Common Subexpression Elimination. + * + * 

+ * Subexpressions are extracted into `cel.bind` calls. For example, the expression below:
+ *
+ * {@code
+ *    message.child.text_map[x].startsWith("hello") && message.child.text_map[x].endsWith("world")
+ * }
+ *
+ * will be optimized into the following form:
+ *
+ * {@code
+ *    cel.bind(@r0, message.child.text_map[x],
+ *        @r0.startsWith("hello") && @r0.endsWith("world"))
+ * }
+ *
+ * Or, using the equivalent form of cel.@block (requires special runtime support):
+ * {@code
+ *    cel.block([message.child.text_map[x]],
+ *        @index0.startsWith("hello") && @index1.endsWith("world"))
+ * }
+ *
+ */ +public final class SubexpressionOptimizer implements CelAstOptimizer { + + private static final SubexpressionOptimizer INSTANCE = + new SubexpressionOptimizer(SubexpressionOptimizerOptions.newBuilder().build()); + private static final String BIND_IDENTIFIER_PREFIX = "@r"; + private static final String CEL_BLOCK_FUNCTION = "cel.@block"; + private static final String BLOCK_INDEX_PREFIX = "@index"; + private static final Extension CEL_BLOCK_AST_EXTENSION_TAG = + Extension.create("cel_block", Version.of(1L, 1L), Component.COMPONENT_RUNTIME); + + @VisibleForTesting static final String MANGLED_COMPREHENSION_ITER_VAR_PREFIX = "@it"; + @VisibleForTesting static final String MANGLED_COMPREHENSION_ITER_VAR2_PREFIX = "@it2"; + @VisibleForTesting static final String MANGLED_COMPREHENSION_ACCU_VAR_PREFIX = "@ac"; + + private final SubexpressionOptimizerOptions cseOptions; + private final AstMutator astMutator; + private final ImmutableSet cseEliminableFunctions; + + /** + * Returns a default instance of common subexpression elimination optimizer with preconfigured + * defaults. + */ + public static SubexpressionOptimizer getInstance() { + return INSTANCE; + } + + /** + * Returns a new instance of common subexpression elimination optimizer configured with the + * provided {@link SubexpressionOptimizerOptions}. + */ + public static SubexpressionOptimizer newInstance(SubexpressionOptimizerOptions cseOptions) { + return new SubexpressionOptimizer(cseOptions); + } + + @Override + public OptimizationResult optimize(CelAbstractSyntaxTree ast, Cel cel) { + OptimizationResult result = optimizeUsingCelBlock(ast, cel); + + verifyOptimizedAstCorrectness(result.optimizedAst()); + + return result; + } + + private OptimizationResult optimizeUsingCelBlock(CelAbstractSyntaxTree ast, Cel cel) { + CelMutableAst astToModify = CelMutableAst.fromCelAst(ast); + if (!cseOptions.populateMacroCalls()) { + astToModify.source().clearMacroCalls(); + } + + MangledComprehensionAst mangledComprehensionAst = + astMutator.mangleComprehensionIdentifierNames( + astToModify, + MANGLED_COMPREHENSION_ITER_VAR_PREFIX, + MANGLED_COMPREHENSION_ITER_VAR2_PREFIX, + MANGLED_COMPREHENSION_ACCU_VAR_PREFIX); + astToModify = mangledComprehensionAst.mutableAst(); + CelMutableSource sourceToModify = astToModify.source(); + + int blockIdentifierIndex = 0; + int iterCount; + ArrayList subexpressions = new ArrayList<>(); + + for (iterCount = 0; iterCount < cseOptions.iterationLimit(); iterCount++) { + CelNavigableMutableAst navAst = CelNavigableMutableAst.fromAst(astToModify); + List cseCandidates = getCseCandidates(navAst); + if (cseCandidates.isEmpty()) { + break; + } + + subexpressions.add(cseCandidates.get(0)); + + String blockIdentifier = BLOCK_INDEX_PREFIX + blockIdentifierIndex++; + + // Replace all CSE candidates with new block index identifier + for (CelMutableExpr cseCandidate : cseCandidates) { + iterCount++; + + astToModify = + astMutator.replaceSubtree( + navAst, + CelNavigableMutableAst.fromAst( + CelMutableAst.of( + CelMutableExpr.ofIdent(blockIdentifier), navAst.getAst().source())), + cseCandidate.id()); + + // Retain the existing macro calls in case if the block identifiers are replacing a subtree + // that contains a comprehension. + sourceToModify.addAllMacroCalls(astToModify.source().getMacroCalls()); + astToModify = CelMutableAst.of(astToModify.expr(), sourceToModify); + } + } + + if (iterCount >= cseOptions.iterationLimit()) { + throw new IllegalStateException("Max iteration count reached."); + } + + if (iterCount == 0) { + // No modification has been made. + return OptimizationResult.create(ast); + } + + ImmutableList.Builder newVarDecls = ImmutableList.builder(); + + // Add all mangled comprehension identifiers to the environment, so that the subexpressions can + // retain context to them. + mangledComprehensionAst + .mangledComprehensionMap() + .forEach( + (name, type) -> { + type.iterVarType() + .ifPresent( + iterVarType -> + newVarDecls.add( + CelVarDecl.newVarDeclaration(name.iterVarName(), iterVarType))); + type.iterVar2Type() + .ifPresent( + iterVar2Type -> + newVarDecls.add( + CelVarDecl.newVarDeclaration(name.iterVar2Name(), iterVar2Type))); + + newVarDecls.add(CelVarDecl.newVarDeclaration(name.resultName(), type.resultType())); + }); + + // Type-check all sub-expressions then create new block index identifiers. + newVarDecls.addAll(newBlockIndexVariableDeclarations(cel, newVarDecls.build(), subexpressions)); + + // Wrap the optimized expression in cel.block + astToModify = + astMutator.wrapAstWithNewCelBlock(CEL_BLOCK_FUNCTION, astToModify, subexpressions); + astToModify = astMutator.renumberIdsConsecutively(astToModify); + + // Tag the AST with cel.block designated as an extension + CelAbstractSyntaxTree optimizedAst = tagAstExtension(astToModify.toParsedAst()); + + return OptimizationResult.create( + optimizedAst, + newVarDecls.build(), + ImmutableList.of(newCelBlockFunctionDecl(ast.getResultType()))); + } + + /** + * Asserts that the optimized AST has no correctness issues. + * + * @throws com.google.common.base.VerifyException if the optimized AST is malformed. + */ + @VisibleForTesting + static void verifyOptimizedAstCorrectness(CelAbstractSyntaxTree ast) { + CelNavigableExpr celNavigableExpr = CelNavigableExpr.fromExpr(ast.getExpr()); + + ImmutableList allCelBlocks = + celNavigableExpr + .allNodes() + .map(CelNavigableExpr::expr) + .filter(expr -> expr.callOrDefault().function().equals(CEL_BLOCK_FUNCTION)) + .collect(toImmutableList()); + if (allCelBlocks.isEmpty()) { + return; + } + + CelExpr celBlockExpr = allCelBlocks.get(0); + Verify.verify( + allCelBlocks.size() == 1, + "Expected 1 cel.block function to be present but found %s", + allCelBlocks.size()); + Verify.verify( + celNavigableExpr.expr().equals(celBlockExpr), "Expected cel.block to be present at root"); + + // Assert correctness on block indices used in subexpressions + CelCall celBlockCall = celBlockExpr.call(); + ImmutableList subexprs = celBlockCall.args().get(0).list().elements(); + for (int i = 0; i < subexprs.size(); i++) { + verifyBlockIndex(subexprs.get(i), i); + } + + // Assert correctness on block indices used in block result + CelExpr blockResult = celBlockCall.args().get(1); + verifyBlockIndex(blockResult, subexprs.size()); + boolean resultHasAtLeastOneBlockIndex = + CelNavigableExpr.fromExpr(blockResult) + .allNodes() + .map(CelNavigableExpr::expr) + .anyMatch(expr -> expr.identOrDefault().name().startsWith(BLOCK_INDEX_PREFIX)); + Verify.verify( + resultHasAtLeastOneBlockIndex, + "Expected at least one reference of index in cel.block result"); + + verifyNoInvalidScopedMangledVariables(celBlockExpr); + } + + private static void verifyBlockIndex(CelExpr celExpr, int maxIndexValue) { + boolean areAllIndicesValid = + CelNavigableExpr.fromExpr(celExpr) + .allNodes() + .map(CelNavigableExpr::expr) + .filter(expr -> expr.identOrDefault().name().startsWith(BLOCK_INDEX_PREFIX)) + .map(CelExpr::ident) + .allMatch( + blockIdent -> + Integer.parseInt(blockIdent.name().substring(BLOCK_INDEX_PREFIX.length())) + < maxIndexValue); + Verify.verify( + areAllIndicesValid, + "Illegal block index found. The index value must be less than %s. Expr: %s", + maxIndexValue, + celExpr); + } + + private static void verifyNoInvalidScopedMangledVariables(CelExpr celExpr) { + CelCall celBlockCall = celExpr.call(); + CelExpr blockBody = celBlockCall.args().get(1); + + ImmutableSet allMangledVariablesInBlockBody = + CelNavigableExpr.fromExpr(blockBody) + .allNodes() + .map(CelNavigableExpr::expr) + .flatMap(SubexpressionOptimizer::extractMangledNames) + .collect(toImmutableSet()); + + CelList blockIndices = celBlockCall.args().get(0).list(); + for (CelExpr blockIndex : blockIndices.elements()) { + ImmutableSet indexDeclaredCompVariables = + CelNavigableExpr.fromExpr(blockIndex) + .allNodes() + .map(CelNavigableExpr::expr) + .filter(expr -> expr.getKind() == Kind.COMPREHENSION) + .map(CelExpr::comprehension) + .flatMap(comp -> Stream.of(comp.iterVar(), comp.iterVar2())) + .filter(iter -> !Strings.isNullOrEmpty(iter)) + .collect(toImmutableSet()); + + boolean containsIllegalDeclaration = + CelNavigableExpr.fromExpr(blockIndex) + .allNodes() + .map(CelNavigableExpr::expr) + .filter(expr -> expr.getKind() == Kind.IDENT) + .map(expr -> expr.ident().name()) + .filter(SubexpressionOptimizer::isMangled) + .anyMatch( + ident -> + !indexDeclaredCompVariables.contains(ident) + && allMangledVariablesInBlockBody.contains(ident)); + + Verify.verify( + !containsIllegalDeclaration, + "Illegal declared reference to a comprehension variable found in block indices. Expr: %s", + celExpr); + } + } + + private static Stream extractMangledNames(CelExpr expr) { + if (expr.getKind().equals(Kind.IDENT)) { + String name = expr.ident().name(); + return isMangled(name) ? Stream.of(name) : Stream.empty(); + } + if (expr.getKind().equals(Kind.COMPREHENSION)) { + CelComprehension comp = expr.comprehension(); + return Stream.of(comp.iterVar(), comp.iterVar2(), comp.accuVar()) + .filter(x -> !Strings.isNullOrEmpty(x)) + .filter(SubexpressionOptimizer::isMangled); + } + return Stream.empty(); + } + + private static boolean isMangled(String name) { + return name.startsWith(MANGLED_COMPREHENSION_ITER_VAR_PREFIX) + || name.startsWith(MANGLED_COMPREHENSION_ITER_VAR2_PREFIX); + } + + private static CelAbstractSyntaxTree tagAstExtension(CelAbstractSyntaxTree ast) { + // Tag the extension + CelSource.Builder celSourceBuilder = + ast.getSource().toBuilder().addAllExtensions(CEL_BLOCK_AST_EXTENSION_TAG); + + return CelAbstractSyntaxTree.newParsedAst(ast.getExpr(), celSourceBuilder.build()); + } + + /** + * Creates a list of numbered identifiers from the subexpressions that act as an indexer to + * cel.block (ex: @index0, @index1..). Each subexpressions are type-checked, then its result type + * is used as the new identifiers' types. + */ + private static ImmutableList newBlockIndexVariableDeclarations( + Cel cel, ImmutableList mangledVarDecls, List subexpressions) { + // The resulting type of the subexpressions will likely be different from the + // entire expression's expected result type. + CelBuilder celBuilder = cel.toCelBuilder().setResultType(SimpleType.DYN); + // Add the mangled comprehension variables to the environment for type-checking subexpressions + // to succeed + celBuilder.addVarDeclarations(mangledVarDecls); + + ImmutableList.Builder varDeclBuilder = ImmutableList.builder(); + for (int i = 0; i < subexpressions.size(); i++) { + CelMutableExpr subexpression = subexpressions.get(i); + + CelAbstractSyntaxTree subAst = + CelAbstractSyntaxTree.newParsedAst( + CelMutableExprConverter.fromMutableExpr(subexpression), + CelSource.newBuilder().build()); + + try { + subAst = celBuilder.build().check(subAst).getAst(); + } catch (CelValidationException e) { + throw new IllegalStateException("Failed to type-check subexpression", e); + } + + CelVarDecl indexVar = CelVarDecl.newVarDeclaration("@index" + i, subAst.getResultType()); + celBuilder.addVarDeclarations(indexVar); + varDeclBuilder.add(indexVar); + } + + return varDeclBuilder.build(); + } + + private List getCseCandidates(CelNavigableMutableAst navAst) { + if (cseOptions.subexpressionMaxRecursionDepth() > 0) { + return getCseCandidatesWithRecursionDepth( + navAst, cseOptions.subexpressionMaxRecursionDepth()); + } else { + return getCseCandidatesWithCommonSubexpr(navAst); + } + } + + /** + * Retrieves all subexpr candidates based on the recursion limit even if there's no duplicate + * subexpr found. + */ + private List getCseCandidatesWithRecursionDepth( + CelNavigableMutableAst navAst, int recursionLimit) { + Preconditions.checkArgument(recursionLimit > 0); + Set ineligibleExprs = getIneligibleExprsFromComprehensionBranches(navAst); + ImmutableList descendants = + navAst + .getRoot() + .descendants(TraversalOrder.PRE_ORDER) + .filter(node -> node.height() <= recursionLimit) + .filter(node -> canEliminate(node, ineligibleExprs)) + .sorted(Comparator.comparingInt(CelNavigableMutableExpr::height).reversed()) + .collect(toImmutableList()); + if (descendants.isEmpty()) { + return new ArrayList<>(); + } + + List cseCandidates = getCseCandidatesWithCommonSubexpr(descendants); + if (!cseCandidates.isEmpty()) { + return cseCandidates; + } + + // If there's no common subexpr, just return the one with the highest height that's still below + // the recursion limit, but only if it actually needs to be extracted due to exceeding the + // recursion limit. + boolean astHasMoreExtractableSubexprs = + navAst + .getRoot() + .allNodes(TraversalOrder.POST_ORDER) + .filter(node -> node.height() > recursionLimit) + .anyMatch(node -> canEliminate(node, ineligibleExprs)); + if (astHasMoreExtractableSubexprs) { + cseCandidates.add(descendants.get(0).expr()); + return cseCandidates; + } + + // The height of the remaining subexpression is already below the recursion limit. No need to + // extract. + return new ArrayList<>(); + } + + private List getCseCandidatesWithCommonSubexpr(CelNavigableMutableAst navAst) { + Set ineligibleExprs = getIneligibleExprsFromComprehensionBranches(navAst); + ImmutableList allNodes = + navAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .filter(node -> canEliminate(node, ineligibleExprs)) + .collect(toImmutableList()); + + return getCseCandidatesWithCommonSubexpr(allNodes); + } + + private List getCseCandidatesWithCommonSubexpr( + ImmutableList allNodes) { + CelMutableExpr normalizedCseCandidate = null; + HashSet semanticallyEqualNodes = new HashSet<>(); + for (CelNavigableMutableExpr node : allNodes) { + // Normalize the expr to test semantic equivalence. + CelMutableExpr normalizedExpr = normalizeForEquality(node.expr()); + if (semanticallyEqualNodes.contains(normalizedExpr)) { + normalizedCseCandidate = normalizedExpr; + break; + } + + semanticallyEqualNodes.add(normalizedExpr); + } + + List cseCandidates = new ArrayList<>(); + if (normalizedCseCandidate == null) { + return cseCandidates; + } + + for (CelNavigableMutableExpr node : allNodes) { + // Normalize the expr to test semantic equivalence. + CelMutableExpr normalizedExpr = normalizeForEquality(node.expr()); + if (normalizedExpr.equals(normalizedCseCandidate)) { + cseCandidates.add(node.expr()); + } + } + + return cseCandidates; + } + + private boolean canEliminate( + CelNavigableMutableExpr navigableExpr, Set ineligibleExprs) { + return !navigableExpr.getKind().equals(Kind.CONSTANT) + && !navigableExpr.getKind().equals(Kind.IDENT) + && !(navigableExpr.getKind().equals(Kind.IDENT) + && navigableExpr.expr().ident().name().startsWith(BIND_IDENTIFIER_PREFIX)) + // Exclude empty lists (cel.bind sets this for iterRange). + && !(navigableExpr.getKind().equals(Kind.LIST) + && navigableExpr.expr().list().elements().isEmpty()) + && containsEliminableFunctionOnly(navigableExpr) + && !ineligibleExprs.contains(navigableExpr.expr()) + && containsComprehensionIdentInSubexpr(navigableExpr) + && containsProperScopedComprehensionIdents(navigableExpr); + } + + private boolean containsProperScopedComprehensionIdents(CelNavigableMutableExpr navExpr) { + if (!navExpr.getKind().equals(Kind.COMPREHENSION)) { + return true; + } + + // For nested comprehensions of form [1].exists(x, [2].exists(y, x == y)), the inner + // comprehension [2].exists(y, x == y) + // should not be extracted out into a block index, as it causes issues with scoping. + ImmutableSet mangledIterVars = + navExpr + .descendants() + .filter(x -> x.getKind().equals(Kind.IDENT)) + .map(x -> x.expr().ident().name()) + .filter( + name -> + name.startsWith(MANGLED_COMPREHENSION_ITER_VAR_PREFIX) + || name.startsWith(MANGLED_COMPREHENSION_ITER_VAR2_PREFIX)) + .collect(toImmutableSet()); + + CelNavigableMutableExpr parent = navExpr.parent().orElse(null); + while (parent != null) { + if (parent.getKind().equals(Kind.COMPREHENSION)) { + CelMutableComprehension comp = parent.expr().comprehension(); + boolean containsParentIterReferences = + mangledIterVars.contains(comp.iterVar()) || mangledIterVars.contains(comp.iterVar2()); + + if (containsParentIterReferences) { + return false; + } + } + + parent = parent.parent().orElse(null); + } + + return true; + } + + private boolean containsComprehensionIdentInSubexpr(CelNavigableMutableExpr navExpr) { + if (navExpr.getKind().equals(Kind.COMPREHENSION)) { + return true; + } + + ImmutableList comprehensionIdents = + navExpr + .allNodes() + .filter( + node -> { + if (!node.getKind().equals(Kind.IDENT)) { + return false; + } + + String identName = node.expr().ident().name(); + return identName.startsWith(MANGLED_COMPREHENSION_ITER_VAR_PREFIX) + || identName.startsWith(MANGLED_COMPREHENSION_ITER_VAR2_PREFIX) + || identName.startsWith(MANGLED_COMPREHENSION_ACCU_VAR_PREFIX); + }) + .collect(toImmutableList()); + + if (comprehensionIdents.isEmpty()) { + return true; + } + + for (CelNavigableMutableExpr ident : comprehensionIdents) { + CelNavigableMutableExpr parent = ident.parent().orElse(null); + while (parent != null) { + if (parent.getKind().equals(Kind.COMPREHENSION)) { + return false; + } + + parent = parent.parent().orElse(null); + } + } + + return true; + } + + /** + * Collects a set of nodes that are not eligible to be optimized from comprehension branches. + * + *

All nodes from accumulator initializer and loop condition are not eligible to be optimized + * as that can interfere with scoping of shadowed variables. + */ + private static Set getIneligibleExprsFromComprehensionBranches( + CelNavigableMutableAst navAst) { + HashSet ineligibleExprs = new HashSet<>(); + navAst + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.COMPREHENSION)) + .forEach( + node -> { + Set nodes = + Streams.concat( + CelNavigableMutableExpr.fromExpr(node.expr().comprehension().accuInit()) + .allNodes(), + CelNavigableMutableExpr.fromExpr( + node.expr().comprehension().loopCondition()) + .allNodes()) + .map(CelNavigableMutableExpr::expr) + .collect(toCollection(HashSet::new)); + + ineligibleExprs.addAll(nodes); + }); + + return ineligibleExprs; + } + + private boolean containsEliminableFunctionOnly(CelNavigableMutableExpr navigableExpr) { + return navigableExpr + .allNodes() + .allMatch( + node -> { + if (node.getKind().equals(Kind.CALL)) { + return cseEliminableFunctions.contains(node.expr().call().function()); + } + + return true; + }); + } + + /** + * Converts the {@link CelMutableExpr} to make it suitable for performing a semantically equals + * check. + * + *

Specifically, this will deep copy the mutable expr then set all expr IDs in the expression + * tree to 0. + */ + private CelMutableExpr normalizeForEquality(CelMutableExpr mutableExpr) { + CelMutableExpr copiedExpr = CelMutableExpr.newInstance(mutableExpr); + + return astMutator.clearExprIds(copiedExpr); + } + + @VisibleForTesting + static CelFunctionDecl newCelBlockFunctionDecl(CelType resultType) { + return CelFunctionDecl.newFunctionDeclaration( + CEL_BLOCK_FUNCTION, + CelOverloadDecl.newGlobalOverload( + "cel_block_list", resultType, ListType.create(SimpleType.DYN), resultType)); + } + + /** Options to configure how Common Subexpression Elimination behave. */ + @AutoValue + public abstract static class SubexpressionOptimizerOptions { + public abstract int iterationLimit(); + + public abstract boolean populateMacroCalls(); + + public abstract boolean enableCelBlock(); + + public abstract int subexpressionMaxRecursionDepth(); + + public abstract ImmutableSet eliminableFunctions(); + + /** Builder for configuring the {@link SubexpressionOptimizerOptions}. */ + @AutoValue.Builder + public abstract static class Builder { + + /** + * Limit the number of iteration while performing CSE. An exception is thrown if the iteration + * count exceeds the set value. + */ + public abstract Builder iterationLimit(int value); + + /** + * Populate the macro_calls map in source_info with macro calls on the resulting optimized + * AST. + */ + public abstract Builder populateMacroCalls(boolean value); + + /** + * @deprecated This option is a no-op. cel.@block is always enabled. + */ + @Deprecated + public abstract Builder enableCelBlock(boolean value); + + /** + * Ensures all extracted subexpressions do not exceed the maximum depth of designated value. + * The purpose of this is to guarantee evaluation and deserialization safety by preventing + * deeply nested ASTs. The trade-off is increased memory usage due to memoizing additional + * block indices during lazy evaluation. + * + *

As a general note, root of a node has a depth of 0. An expression `x.y.z` has a depth of + * 2. + * + *

Note that expressions containing no common subexpressions may become a candidate for + * extraction to satisfy the max depth requirement. + * + *

This is a no-op if the configured value is less than 1, or no subexpression needs to be + * extracted because the entire expression is already under the designated limit. + * + *

Examples: + * + *

    + *
  1. a.b.c with depth 1 -> cel.@block([x.b, @index0.c], @index1) + *
  2. a.b.c with depth 3 -> a.b.c + *
  3. a.b + a.b.c.d with depth 3 -> cel.@block([a.b, @index0.c.d], @index0 + @index1) + *
+ * + *

+ */ + public abstract Builder subexpressionMaxRecursionDepth(int value); + + abstract ImmutableSet.Builder eliminableFunctionsBuilder(); + + /** + * Adds a collection of custom functions that will be a candidate for common subexpression + * elimination. By default, standard functions are eliminable. + * + *

Note that the implementation of custom functions must be free of side effects. + */ + @CanIgnoreReturnValue + public Builder addEliminableFunctions(Iterable functions) { + checkNotNull(functions); + this.eliminableFunctionsBuilder().addAll(functions); + return this; + } + + /** See {@link #addEliminableFunctions(Iterable)}. */ + @CanIgnoreReturnValue + public Builder addEliminableFunctions(String... functions) { + return addEliminableFunctions(Arrays.asList(functions)); + } + + public abstract SubexpressionOptimizerOptions build(); + + Builder() {} + } + + abstract Builder toBuilder(); + + /** Returns a new options builder with recommended defaults pre-configured. */ + public static Builder newBuilder() { + return new AutoValue_SubexpressionOptimizer_SubexpressionOptimizerOptions.Builder() + .iterationLimit(500) + .enableCelBlock(true) + .populateMacroCalls(false) + .subexpressionMaxRecursionDepth(0); + } + + SubexpressionOptimizerOptions() {} + } + + private SubexpressionOptimizer(SubexpressionOptimizerOptions cseOptions) { + this.cseOptions = cseOptions; + this.astMutator = AstMutator.newInstance(cseOptions.iterationLimit()); + this.cseEliminableFunctions = + ImmutableSet.builder() + .addAll(DefaultOptimizerConstants.CEL_CANONICAL_FUNCTIONS) + .addAll(cseOptions.eliminableFunctions()) + .build(); + } +} diff --git a/optimizer/src/test/java/dev/cel/optimizer/AstMutatorTest.java b/optimizer/src/test/java/dev/cel/optimizer/AstMutatorTest.java new file mode 100644 index 000000000..fa896ebca --- /dev/null +++ b/optimizer/src/test/java/dev/cel/optimizer/AstMutatorTest.java @@ -0,0 +1,1090 @@ +// Copyright 2023 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.optimizer; + +import static com.google.common.collect.ImmutableMap.toImmutableMap; +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelMutableAst; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelSource; +import dev.cel.common.CelSource.Extension; +import dev.cel.common.CelSource.Extension.Version; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExprConverter; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.common.navigation.CelNavigableExpr; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelExtensions; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.parser.CelStandardMacro; +import dev.cel.parser.CelUnparser; +import dev.cel.parser.CelUnparserFactory; +import java.util.List; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class AstMutatorTest { + private static final Cel CEL = + CelFactory.standardCelBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setOptions(CelOptions.current().populateMacroCalls(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addCompilerLibraries( + CelOptionalLibrary.INSTANCE, CelExtensions.bindings(), CelExtensions.comprehensions()) + .addRuntimeLibraries(CelOptionalLibrary.INSTANCE, CelExtensions.comprehensions()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .addVar("x", SimpleType.INT) + .build(); + + private static final CelUnparser CEL_UNPARSER = CelUnparserFactory.newUnparser(); + private static final AstMutator AST_MUTATOR = AstMutator.newInstance(1000); + + @Test + public void replaceSubtree_replaceConst() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("10").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newBooleanConst = CelMutableExpr.ofConstant(1, CelConstant.ofValue(true)); + + CelMutableAst result = + AST_MUTATOR.replaceSubtree(mutableAst, newBooleanConst, mutableAst.expr().id()); + + assertThat(result.toParsedAst().getExpr()) + .isEqualTo(CelExpr.ofConstant(3, CelConstant.ofValue(true))); + } + + @Test + public void astMutator_returnsParsedAst() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("10").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newBooleanConst = CelMutableExpr.ofConstant(1, CelConstant.ofValue(true)); + + CelMutableAst result = + AST_MUTATOR.replaceSubtree(mutableAst, newBooleanConst, mutableAst.expr().id()); + + assertThat(ast.isChecked()).isTrue(); + assertThat(result.toParsedAst().isChecked()).isFalse(); + } + + @Test + public void astMutator_nonMacro_sourceCleared() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("10").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newBooleanConst = CelMutableExpr.ofConstant(1, CelConstant.ofValue(true)); + + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR + .replaceSubtree(mutableAst, newBooleanConst, mutableAst.expr().id()) + .toParsedAst(); + + assertThat(mutatedAst.getSource().getLineOffsets()).isEmpty(); + assertThat(mutatedAst.getSource().getPositionsMap()).isEmpty(); + assertThat(mutatedAst.getSource().getExtensions()).isEmpty(); + assertThat(mutatedAst.getSource().getMacroCalls()).isEmpty(); + assertThat(mutatedAst.getSource().getDescription()).isEqualTo(ast.getSource().getDescription()); + } + + @Test + public void astMutator_macro_sourceMacroCallsPopulated() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("has(TestAllTypes{}.single_int32)").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newBooleanConst = CelMutableExpr.ofConstant(1, CelConstant.ofValue(true)); + + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR.replaceSubtree(mutableAst, newBooleanConst, 1).toParsedAst(); // no_op + + assertThat(mutatedAst.getSource().getLineOffsets()).isEmpty(); + assertThat(mutatedAst.getSource().getPositionsMap()).isEmpty(); + assertThat(mutatedAst.getSource().getExtensions()).isEmpty(); + assertThat(mutatedAst.getSource().getMacroCalls()).isNotEmpty(); + assertThat(mutatedAst.getSource().getDescription()).isEqualTo(ast.getSource().getDescription()); + } + + @Test + public void replaceSubtree_astContainsTaggedExtension_retained() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("has(TestAllTypes{}.single_int32)").getAst(); + Extension extension = Extension.create("test", Version.of(1, 1)); + CelSource celSource = ast.getSource().toBuilder().addAllExtensions(extension).build(); + ast = + CelAbstractSyntaxTree.newCheckedAst( + ast.getExpr(), celSource, ast.getReferenceMap(), ast.getTypeMap()); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR + .replaceSubtree(mutableAst, CelMutableExpr.ofConstant(CelConstant.ofValue(true)), 1) + .toParsedAst(); + + assertThat(mutatedAst.getSource().getExtensions()).containsExactly(extension); + } + + @Test + public void replaceSubtreeWithNewAst_astsContainTaggedExtension_retained() throws Exception { + // Setup first AST with a test extension + CelAbstractSyntaxTree ast = CEL.compile("has(TestAllTypes{}.single_int32)").getAst(); + Extension extension = Extension.create("test", Version.of(1, 1)); + ast = + CelAbstractSyntaxTree.newCheckedAst( + ast.getExpr(), + ast.getSource().toBuilder().addAllExtensions(extension).build(), + ast.getReferenceMap(), + ast.getTypeMap()); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + // Setup second AST with another test extension + CelAbstractSyntaxTree astToReplaceWith = CEL.compile("cel.bind(a, true, a)").getAst(); + Extension extension2 = Extension.create("test2", Version.of(2, 2)); + astToReplaceWith = + CelAbstractSyntaxTree.newCheckedAst( + astToReplaceWith.getExpr(), + astToReplaceWith.getSource().toBuilder().addAllExtensions(extension2).build(), + astToReplaceWith.getReferenceMap(), + astToReplaceWith.getTypeMap()); + CelMutableAst mutableAst2 = CelMutableAst.fromCelAst(astToReplaceWith); + + // Mutate the original AST with the new AST at the root + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR.replaceSubtree(mutableAst, mutableAst2, mutableAst.expr().id()).toParsedAst(); + + // Expect that both the extensions are merged + assertThat(mutatedAst.getSource().getExtensions()).containsExactly(extension, extension2); + } + + @Test + public void replaceSubtreeWithNewAst_astsContainSameExtensions_deduped() throws Exception { + // Setup first AST with a test extension + CelAbstractSyntaxTree ast = CEL.compile("has(TestAllTypes{}.single_int32)").getAst(); + Extension extension = Extension.create("test", Version.of(1, 1)); + ast = + CelAbstractSyntaxTree.newCheckedAst( + ast.getExpr(), + ast.getSource().toBuilder().addAllExtensions(extension).build(), + ast.getReferenceMap(), + ast.getTypeMap()); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + // Setup second AST with the same test extension as above + CelAbstractSyntaxTree astToReplaceWith = CEL.compile("cel.bind(a, true, a)").getAst(); + Extension extension2 = Extension.create("test", Version.of(1, 1)); + astToReplaceWith = + CelAbstractSyntaxTree.newCheckedAst( + astToReplaceWith.getExpr(), + astToReplaceWith.getSource().toBuilder().addAllExtensions(extension2).build(), + astToReplaceWith.getReferenceMap(), + astToReplaceWith.getTypeMap()); + CelMutableAst mutableAst2 = CelMutableAst.fromCelAst(astToReplaceWith); + + // Mutate the original AST with the new AST at the root + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR.replaceSubtree(mutableAst, mutableAst2, mutableAst.expr().id()).toParsedAst(); + + // Expect that the extension is deduped + assertThat(mutatedAst.getSource().getExtensions()).containsExactly(extension); + } + + @Test + @TestParameters("{source: '[1].exists(x, x > 0)', expectedMacroCallSize: 1}") + @TestParameters( + "{source: '[1].exists(x, x > 0) && [2].exists(x, x > 0)', expectedMacroCallSize: 2}") + @TestParameters( + "{source: '[1].exists(x, [2].exists(y, x > 0 && y > x))', expectedMacroCallSize: 2}") + public void replaceSubtree_rootReplacedWithMacro_macroCallPopulated( + String source, int expectedMacroCallSize) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("1").getAst(); + CelAbstractSyntaxTree ast2 = CEL.compile(source).getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableAst mutableAst2 = CelMutableAst.fromCelAst(ast2); + + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR.replaceSubtree(mutableAst, mutableAst2, mutableAst.expr().id()).toParsedAst(); + + assertThat(mutatedAst.getSource().getMacroCalls()).hasSize(expectedMacroCallSize); + assertThat(CEL_UNPARSER.unparse(mutatedAst)).isEqualTo(source); + assertThat(CEL.createProgram(CEL.check(mutatedAst).getAst()).eval()).isEqualTo(true); + } + + @Test + public void replaceSubtree_leftBranchReplacedWithMacro_macroCallPopulated() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("true && false").getAst(); + CelAbstractSyntaxTree ast2 = CEL.compile("[1].exists(x, x > 0)").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableAst mutableAst2 = CelMutableAst.fromCelAst(ast2); + + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR + .replaceSubtree(mutableAst, mutableAst2, 3) + .toParsedAst(); // Replace false with the macro expr + + assertThat(mutatedAst.getSource().getMacroCalls()).hasSize(1); + assertThat(CEL_UNPARSER.unparse(mutatedAst)).isEqualTo("true && [1].exists(x, x > 0)"); + assertThat(CEL.createProgram(CEL.check(mutatedAst).getAst()).eval()).isEqualTo(true); + } + + @Test + public void replaceSubtree_rightBranchReplacedWithMacro_macroCallPopulated() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("true && false").getAst(); + CelAbstractSyntaxTree ast2 = CEL.compile("[1].exists(x, x > 0)").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableAst mutableAst2 = CelMutableAst.fromCelAst(ast2); + + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR + .replaceSubtree(mutableAst, mutableAst2, 1) + .toParsedAst(); // Replace true with the macro expr + + assertThat(mutatedAst.getSource().getMacroCalls()).hasSize(1); + assertThat(CEL_UNPARSER.unparse(mutatedAst)).isEqualTo("[1].exists(x, x > 0) && false"); + assertThat(CEL.createProgram(CEL.check(mutatedAst).getAst()).eval()).isEqualTo(false); + } + + @Test + public void replaceSubtree_macroInsertedIntoExistingMacro_macroCallPopulated() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[1].exists(x, x > 0 && true)").getAst(); + CelAbstractSyntaxTree ast2 = CEL.compile("[2].exists(y, y > 0)").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableAst mutableAst2 = CelMutableAst.fromCelAst(ast2); + + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR + .replaceSubtree(mutableAst, mutableAst2, 9) + .toParsedAst(); // Replace true with the ast2 maro expr + + assertThat(mutatedAst.getSource().getMacroCalls()).hasSize(2); + assertThat(CEL_UNPARSER.unparse(mutatedAst)) + .isEqualTo("[1].exists(x, x > 0 && [2].exists(y, y > 0))"); + assertThat(CEL.createProgram(CEL.check(mutatedAst).getAst()).eval()).isEqualTo(true); + } + + @Test + public void replaceSubtree_macroReplacedWithConstExpr_macroCallCleared() throws Exception { + CelAbstractSyntaxTree ast = + CEL.compile("[1].exists(x, x > 0) && [2].exists(x, x > 0)").getAst(); + CelAbstractSyntaxTree ast2 = CEL.compile("1").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableAst mutableAst2 = CelMutableAst.fromCelAst(ast2); + + CelAbstractSyntaxTree mutatedAst = + AST_MUTATOR.replaceSubtree(mutableAst, mutableAst2, mutableAst.expr().id()).toParsedAst(); + + assertThat(mutatedAst.getSource().getMacroCalls()).isEmpty(); + assertThat(CEL_UNPARSER.unparse(mutatedAst)).isEqualTo("1"); + assertThat(CEL.createProgram(CEL.check(mutatedAst).getAst()).eval()).isEqualTo(1); + } + + @Test + @SuppressWarnings("unchecked") // Test only + public void replaceSubtree_replaceExtraneousListCreatedByMacro_unparseSuccess() throws Exception { + // Certain macros such as `map` or `filter` generates an extraneous list_expr in the loop step's + // argument that does not exist in the original expression. + // For example, the loop step of this expression looks like: + // CALL [10] { + // function: _+_ + // args: { + // IDENT [8] { + // name: __result__ + // } + // LIST [9] { + // elements: { + // CONSTANT [5] { value: 1 } + // } + // } + // } + // } + CelAbstractSyntaxTree ast = CEL.compile("[1].map(x, 1)").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableAst mutableAst2 = CelMutableAst.fromCelAst(ast); + + // These two mutation are equivalent. + CelAbstractSyntaxTree mutatedAstWithList = + AST_MUTATOR + .replaceSubtree( + mutableAst, + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(2L)))), + 9L) + .toParsedAst(); + CelAbstractSyntaxTree mutatedAstWithConstant = + AST_MUTATOR + .replaceSubtree(mutableAst2, CelMutableExpr.ofConstant(CelConstant.ofValue(2L)), 5L) + .toParsedAst(); + + assertThat(CEL_UNPARSER.unparse(mutatedAstWithList)).isEqualTo("[1].map(x, 2)"); + assertThat(CEL_UNPARSER.unparse(mutatedAstWithConstant)).isEqualTo("[1].map(x, 2)"); + assertThat((List) CEL.createProgram(CEL.check(mutatedAstWithList).getAst()).eval()) + .containsExactly(2L); + } + + @Test + @SuppressWarnings("unchecked") // Test only + public void replaceSubtree_replaceExtraneousListCreatedByThreeArgMacro_unparseSuccess() + throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[1].map(x, true, 1)").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableAst mutableAst2 = CelMutableAst.fromCelAst(ast); + + // These two mutation are equivalent. + CelAbstractSyntaxTree mutatedAstWithList = + AST_MUTATOR + .replaceSubtree( + mutableAst, + CelMutableExpr.ofList( + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(2L)))), + 10L) + .toParsedAst(); + CelAbstractSyntaxTree mutatedAstWithConstant = + AST_MUTATOR + .replaceSubtree(mutableAst2, CelMutableExpr.ofConstant(CelConstant.ofValue(2L)), 6L) + .toParsedAst(); + + assertThat(CEL_UNPARSER.unparse(mutatedAstWithList)).isEqualTo("[1].map(x, true, 2)"); + assertThat(CEL_UNPARSER.unparse(mutatedAstWithConstant)).isEqualTo("[1].map(x, true, 2)"); + assertThat((List) CEL.createProgram(CEL.check(mutatedAstWithList).getAst()).eval()) + .containsExactly(2L); + } + + @Test + public void globalCallExpr_replaceRoot() throws Exception { + // Tree shape (brackets are expr IDs): + // + [4] + // + [2] x [5] + // 1 [1] 2 [3] + CelAbstractSyntaxTree ast = CEL.compile("1 + 2 + x").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(10)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, mutableAst.expr().id()); + + assertThat(result.toParsedAst().getExpr()) + .isEqualTo(CelExpr.ofConstant(7, CelConstant.ofValue(10))); + } + + @Test + public void globalCallExpr_replaceLeaf() throws Exception { + // Tree shape (brackets are expr IDs): + // + [4] + // + [2] x [5] + // 1 [1] 2 [3] + CelAbstractSyntaxTree ast = CEL.compile("1 + 2 + x").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(10)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 1); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("10 + 2 + x"); + } + + @Test + public void globalCallExpr_replaceMiddleBranch() throws Exception { + // Tree shape (brackets are expr IDs): + // + [4] + // + [2] x [5] + // 1 [1] 2 [3] + CelAbstractSyntaxTree ast = CEL.compile("1 + 2 + x").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(10)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 2); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("10 + x"); + } + + @Test + public void globalCallExpr_replaceMiddleBranch_withCallExpr() throws Exception { + // Tree shape (brackets are expr IDs): + // + [4] + // + [2] x [5] + // 1 [1] 2 [3] + CelAbstractSyntaxTree ast = CEL.compile("1 + 2 + x").getAst(); + CelAbstractSyntaxTree ast2 = CEL.compile("4 + 5 + 6").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExprConverter.fromCelExpr(ast2.getExpr()); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 2); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("4 + 5 + 6 + x"); + } + + @Test + public void memberCallExpr_replaceLeafTarget() throws Exception { + // Tree shape (brackets are expr IDs): + // func [2] + // 10 [1] func [4] + // 4 [3] 5 [5] + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "func", + CelOverloadDecl.newMemberOverload( + "func_overload", SimpleType.INT, SimpleType.INT, SimpleType.INT))) + .build(); + CelAbstractSyntaxTree ast = cel.compile("10.func(4.func(5))").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(20)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 3); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("10.func(20.func(5))"); + } + + @Test + public void memberCallExpr_replaceLeafArgument() throws Exception { + // Tree shape (brackets are expr IDs): + // func [2] + // 10 [1] func [4] + // 4 [3] 5 [5] + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "func", + CelOverloadDecl.newMemberOverload( + "func_overload", SimpleType.INT, SimpleType.INT, SimpleType.INT))) + .build(); + CelAbstractSyntaxTree ast = cel.compile("10.func(4.func(5))").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(20)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 5); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("10.func(4.func(20))"); + } + + @Test + public void memberCallExpr_replaceMiddleBranchTarget() throws Exception { + // Tree shape (brackets are expr IDs): + // func [2] + // 10 [1] func [4] + // 4 [3] 5 [5] + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "func", + CelOverloadDecl.newMemberOverload( + "func_overload", SimpleType.INT, SimpleType.INT, SimpleType.INT))) + .build(); + CelAbstractSyntaxTree ast = cel.compile("10.func(4.func(5))").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(20)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 1); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("20.func(4.func(5))"); + } + + @Test + public void memberCallExpr_replaceMiddleBranchArgument() throws Exception { + // Tree shape (brackets are expr IDs): + // func [2] + // 10 [1] func [4] + // 4 [3] 5 [5] + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "func", + CelOverloadDecl.newMemberOverload( + "func_overload", SimpleType.INT, SimpleType.INT, SimpleType.INT))) + .build(); + CelAbstractSyntaxTree ast = cel.compile("10.func(4.func(5))").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(20)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 4); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("10.func(20)"); + } + + @Test + public void select_replaceField() throws Exception { + // Tree shape (brackets are expr IDs): + // + [2] + // 5 [1] select [4] + // msg [3] + CelAbstractSyntaxTree ast = CEL.compile("5 + msg.single_int64").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = + CelMutableExpr.ofSelect( + CelMutableSelect.create(CelMutableExpr.ofIdent("test"), "single_sint32")); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 4); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("5 + test.single_sint32"); + } + + @Test + public void select_replaceOperand() throws Exception { + // Tree shape (brackets are expr IDs): + // + [2] + // 5 [1] select [4] + // msg [3] + CelAbstractSyntaxTree ast = CEL.compile("5 + msg.single_int64").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofIdent("test"); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 3); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("5 + test.single_int64"); + } + + @Test + public void list_replaceElement() throws Exception { + // Tree shape (brackets are expr IDs): + // list [1] + // 2 [2] 3 [3] 4 [4] + CelAbstractSyntaxTree ast = CEL.compile("[2, 3, 4]").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(5)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 4); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("[2, 3, 5]"); + } + + @Test + public void struct_replaceValue() throws Exception { + // Tree shape (brackets are expr IDs): + // TestAllTypes [1] + // single_int64 [2] + // 2 [3] + CelAbstractSyntaxTree ast = CEL.compile("TestAllTypes{single_int64: 2}").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(5)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 3); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())) + .isEqualTo("cel.expr.conformance.proto3.TestAllTypes{single_int64: 5}"); + } + + @Test + public void map_replaceKey() throws Exception { + // Tree shape (brackets are expr IDs): + // map [1] + // map_entry [2] + // 'a' [3] : 1 [4] + CelAbstractSyntaxTree ast = CEL.compile("{'a': 1}").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(5)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 3); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("{5: 1}"); + } + + @Test + public void map_replaceValue() throws Exception { + // Tree shape (brackets are expr IDs): + // map [1] + // map_entry [2] + // 'a' [3] : 1 [4] + CelAbstractSyntaxTree ast = CEL.compile("{'a': 1}").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(5)); + + CelMutableAst result = AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 4); + + assertThat(CEL_UNPARSER.unparse(result.toParsedAst())).isEqualTo("{\"a\": 5}"); + } + + @Test + public void comprehension_replaceIterRange() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[true].exists(i, i)").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(false)); + + CelAbstractSyntaxTree replacedAst = + AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 2).toParsedAst(); + + assertThat(CEL_UNPARSER.unparse(replacedAst)).isEqualTo("[false].exists(i, i)"); + assertThat(CEL.createProgram(CEL.check(replacedAst).getAst()).eval()).isEqualTo(false); + assertConsistentMacroCalls(replacedAst); + } + + @Test + public void comprehension_replaceAccuInit() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[false].exists(i, i)").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofConstant(CelConstant.ofValue(true)); + + CelAbstractSyntaxTree replacedAst = + AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 6).toParsedAst(); + + assertThat(CEL_UNPARSER.unparse(replacedAst)).isEqualTo("[false].exists(i, i)"); + assertThat(CEL.createProgram(CEL.check(replacedAst).getAst()).eval()).isEqualTo(true); + // Check that the init value of accumulator has actually been replaced. + assertThat(ast.getExpr().comprehension().accuInit().constant().booleanValue()).isFalse(); + assertThat(replacedAst.getExpr().comprehension().accuInit().constant().booleanValue()).isTrue(); + assertConsistentMacroCalls(ast); + } + + @Test + public void comprehension_replaceLoopStep() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[false].exists(i, i)").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + CelMutableExpr newExpr = CelMutableExpr.ofIdent("test"); + + CelAbstractSyntaxTree replacedAst = + AST_MUTATOR.replaceSubtree(mutableAst, newExpr, 5).toParsedAst(); + + assertThat(CEL_UNPARSER.unparse(replacedAst)).isEqualTo("[false].exists(i, test)"); + assertConsistentMacroCalls(ast); + } + + @Test + public void mangleComprehensionVariable_singleMacro() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[false].exists(i, i)").getAst(); + + CelAbstractSyntaxTree mangledAst = + AST_MUTATOR + .mangleComprehensionIdentifierNames(CelMutableAst.fromCelAst(ast), "@it", "@it2", "@ac") + .mutableAst() + .toParsedAst(); + + assertThat(mangledAst.getExpr().toString()) + .isEqualTo( + "COMPREHENSION [13] {\n" + + " iter_var: @it:0:0\n" + + " iter_range: {\n" + + " LIST [1] {\n" + + " elements: {\n" + + " CONSTANT [2] { value: false }\n" + + " }\n" + + " }\n" + + " }\n" + + " accu_var: @ac:0:0\n" + + " accu_init: {\n" + + " CONSTANT [6] { value: false }\n" + + " }\n" + + " loop_condition: {\n" + + " CALL [9] {\n" + + " function: @not_strictly_false\n" + + " args: {\n" + + " CALL [8] {\n" + + " function: !_\n" + + " args: {\n" + + " IDENT [7] {\n" + + " name: @ac:0:0\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " loop_step: {\n" + + " CALL [11] {\n" + + " function: _||_\n" + + " args: {\n" + + " IDENT [10] {\n" + + " name: @ac:0:0\n" + + " }\n" + + " IDENT [5] {\n" + + " name: @it:0:0\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " result: {\n" + + " IDENT [12] {\n" + + " name: @ac:0:0\n" + + " }\n" + + " }\n" + + "}"); + assertThat(CEL_UNPARSER.unparse(mangledAst)).isEqualTo("[false].exists(@it:0:0, @it:0:0)"); + assertThat(CEL.createProgram(CEL.check(mangledAst).getAst()).eval()).isEqualTo(false); + assertConsistentMacroCalls(ast); + } + + @Test + public void mangleComprehensionVariable_withTwoIterVars_singleMacro() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[false].exists(i, v, v)").getAst(); + + CelAbstractSyntaxTree mangledAst = + AST_MUTATOR + .mangleComprehensionIdentifierNames(CelMutableAst.fromCelAst(ast), "@it", "@it2", "@ac") + .mutableAst() + .toParsedAst(); + + assertThat(mangledAst.getExpr().toString()) + .isEqualTo( + "COMPREHENSION [14] {\n" + + " iter_var: @it:0:0\n" + + " iter_var2: @it2:0:0\n" + + " iter_range: {\n" + + " LIST [1] {\n" + + " elements: {\n" + + " CONSTANT [2] { value: false }\n" + + " }\n" + + " }\n" + + " }\n" + + " accu_var: @ac:0:0\n" + + " accu_init: {\n" + + " CONSTANT [7] { value: false }\n" + + " }\n" + + " loop_condition: {\n" + + " CALL [10] {\n" + + " function: @not_strictly_false\n" + + " args: {\n" + + " CALL [9] {\n" + + " function: !_\n" + + " args: {\n" + + " IDENT [8] {\n" + + " name: @ac:0:0\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " loop_step: {\n" + + " CALL [12] {\n" + + " function: _||_\n" + + " args: {\n" + + " IDENT [11] {\n" + + " name: @ac:0:0\n" + + " }\n" + + " IDENT [6] {\n" + + " name: @it2:0:0\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " result: {\n" + + " IDENT [13] {\n" + + " name: @ac:0:0\n" + + " }\n" + + " }\n" + + "}"); + assertThat(CEL_UNPARSER.unparse(mangledAst)) + .isEqualTo("[false].exists(@it:0:0, @it2:0:0, @it2:0:0)"); + assertThat(CEL.createProgram(CEL.check(mangledAst).getAst()).eval()).isEqualTo(false); + assertConsistentMacroCalls(ast); + } + + @Test + public void mangleComprehensionVariable_adjacentMacros_sameIterVarTypes() throws Exception { + CelAbstractSyntaxTree ast = + CEL.compile( + "[1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j +" + + " 1))") + .getAst(); + + CelAbstractSyntaxTree mangledAst = + AST_MUTATOR + .mangleComprehensionIdentifierNames(CelMutableAst.fromCelAst(ast), "@it", "@it2", "@ac") + .mutableAst() + .toParsedAst(); + + assertThat(CEL_UNPARSER.unparse(mangledAst)) + .isEqualTo( + "[1, 2, 3].map(@it:1:0, [1, 2, 3].map(@it:0:0, @it:0:0 + 1)) == " + + "[1, 2, 3].map(@it:1:0, [1, 2, 3].map(@it:0:0, @it:0:0 + 1))"); + assertThat(CEL.createProgram(CEL.check(mangledAst).getAst()).eval()).isEqualTo(true); + assertConsistentMacroCalls(ast); + } + + @Test + public void mangleComprehensionVariable_withTwoIterVars_adjacentMacros_sameIterVarTypes() + throws Exception { + CelAbstractSyntaxTree ast = + CEL.compile( + // LHS & RHS are same expressions, just different var names + "[1, 2].transformMap(i, v, [1,2].transformMap(i, v, i)) == " + + "[1, 2].transformMap(x, y, [1,2].transformMap(x, y, x))") + .getAst(); + + CelAbstractSyntaxTree mangledAst = + AST_MUTATOR + .mangleComprehensionIdentifierNames(CelMutableAst.fromCelAst(ast), "@it", "@it2", "@ac") + .mutableAst() + .toParsedAst(); + + assertThat(CEL_UNPARSER.unparse(mangledAst)) + .isEqualTo( + "[1, 2].transformMap(@it:1:0, @it2:1:0, [1, 2].transformMap(@it:0:0, @it2:0:0," + + " @it:0:0)) == [1, 2].transformMap(@it:1:0, @it2:1:0, [1," + + " 2].transformMap(@it:0:0, @it2:0:0, @it:0:0))"); + assertThat(CEL.createProgram(CEL.check(mangledAst).getAst()).eval()).isEqualTo(true); + assertConsistentMacroCalls(ast); + } + + @Test + public void mangleComprehensionVariable_adjacentMacros_differentIterVarTypes() throws Exception { + CelAbstractSyntaxTree ast = + CEL.compile( + "[1,2,3].map(i, [1, 2, 3].map(i, i)) == dyn([1u,2u,3u].map(j, [1u, 2u, 3u].map(j," + + " j)))") + .getAst(); + + CelAbstractSyntaxTree mangledAst = + AST_MUTATOR + .mangleComprehensionIdentifierNames(CelMutableAst.fromCelAst(ast), "@it", "@it2", "@ac") + .mutableAst() + .toParsedAst(); + + assertThat(CEL_UNPARSER.unparse(mangledAst)) + .isEqualTo( + "[1, 2, 3].map(@it:1:0, [1, 2, 3].map(@it:0:0, @it:0:0)) == " + + "dyn([1u, 2u, 3u].map(@it:1:1, [1u, 2u, 3u].map(@it:0:1, @it:0:1)))"); + assertThat(CEL.createProgram(CEL.check(mangledAst).getAst()).eval()).isEqualTo(true); + assertConsistentMacroCalls(ast); + } + + @Test + public void mangleComprehensionVariable_macroSourceDisabled_macroCallMapIsEmpty() + throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setOptions(CelOptions.current().populateMacroCalls(false).build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("[false].exists(i, i)").getAst(); + + CelAbstractSyntaxTree mangledAst = + AST_MUTATOR + .mangleComprehensionIdentifierNames(CelMutableAst.fromCelAst(ast), "@it", "@it2", "@ac") + .mutableAst() + .toParsedAst(); + + assertThat(mangledAst.getSource().getMacroCalls()).isEmpty(); + } + + @Test + public void mangleComprehensionVariable_nestedMacroWithShadowedVariables() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[x].exists(x, [x].exists(x, x == 1))").getAst(); + + CelAbstractSyntaxTree mangledAst = + AST_MUTATOR + .mangleComprehensionIdentifierNames(CelMutableAst.fromCelAst(ast), "@it", "@it2", "@ac") + .mutableAst() + .toParsedAst(); + + assertThat(mangledAst.getExpr().toString()) + .isEqualTo( + "COMPREHENSION [27] {\n" + + " iter_var: @it:1:0\n" + + " iter_range: {\n" + + " LIST [1] {\n" + + " elements: {\n" + + " IDENT [2] {\n" + + " name: x\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " accu_var: @ac:1:0\n" + + " accu_init: {\n" + + " CONSTANT [20] { value: false }\n" + + " }\n" + + " loop_condition: {\n" + + " CALL [23] {\n" + + " function: @not_strictly_false\n" + + " args: {\n" + + " CALL [22] {\n" + + " function: !_\n" + + " args: {\n" + + " IDENT [21] {\n" + + " name: @ac:1:0\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " loop_step: {\n" + + " CALL [25] {\n" + + " function: _||_\n" + + " args: {\n" + + " IDENT [24] {\n" + + " name: @ac:1:0\n" + + " }\n" + + " COMPREHENSION [19] {\n" + + " iter_var: @it:0:0\n" + + " iter_range: {\n" + + " LIST [5] {\n" + + " elements: {\n" + + " IDENT [6] {\n" + + " name: @it:1:0\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " accu_var: @ac:0:0\n" + + " accu_init: {\n" + + " CONSTANT [12] { value: false }\n" + + " }\n" + + " loop_condition: {\n" + + " CALL [15] {\n" + + " function: @not_strictly_false\n" + + " args: {\n" + + " CALL [14] {\n" + + " function: !_\n" + + " args: {\n" + + " IDENT [13] {\n" + + " name: @ac:0:0\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " loop_step: {\n" + + " CALL [17] {\n" + + " function: _||_\n" + + " args: {\n" + + " IDENT [16] {\n" + + " name: @ac:0:0\n" + + " }\n" + + " CALL [10] {\n" + + " function: _==_\n" + + " args: {\n" + + " IDENT [9] {\n" + + " name: @it:0:0\n" + + " }\n" + + " CONSTANT [11] { value: 1 }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " result: {\n" + + " IDENT [18] {\n" + + " name: @ac:0:0\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + " result: {\n" + + " IDENT [26] {\n" + + " name: @ac:1:0\n" + + " }\n" + + " }\n" + + "}"); + assertThat(CEL_UNPARSER.unparse(mangledAst)) + .isEqualTo("[x].exists(@it:1:0, [@it:1:0].exists(@it:0:0, @it:0:0 == 1))"); + assertThat(CEL.createProgram(CEL.check(mangledAst).getAst()).eval(ImmutableMap.of("x", 1))) + .isEqualTo(true); + assertConsistentMacroCalls(ast); + } + + @Test + public void mangleComprehensionVariable_hasMacro_noOp() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("has(msg.single_int64)").getAst(); + + CelAbstractSyntaxTree mangledAst = + AST_MUTATOR + .mangleComprehensionIdentifierNames(CelMutableAst.fromCelAst(ast), "@it", "@it2", "@ac") + .mutableAst() + .toParsedAst(); + + assertThat(CEL_UNPARSER.unparse(mangledAst)).isEqualTo("has(msg.single_int64)"); + assertThat( + CEL.createProgram(CEL.check(mangledAst).getAst()) + .eval(ImmutableMap.of("msg", TestAllTypes.getDefaultInstance()))) + .isEqualTo(false); + assertConsistentMacroCalls(ast); + } + + @Test + public void replaceSubtree_iterationLimitReached_throws() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("true && false").getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast); + AstMutator astMutator = AstMutator.newInstance(1); + + IllegalStateException e = + assertThrows( + IllegalStateException.class, + () -> + astMutator.replaceSubtree( + mutableAst, CelMutableExpr.ofConstant(CelConstant.ofValue(false)), 1)); + + assertThat(e).hasMessageThat().isEqualTo("Max iteration count reached."); + } + + @Test + public void newGlobalCallAst_success() throws Exception { + CelMutableAst argAst1 = CelMutableAst.fromCelAst(CEL.compile("[1].exists(x, x >= 1)").getAst()); + CelMutableAst argAst2 = CelMutableAst.fromCelAst(CEL.compile("'hello'").getAst()); + + CelMutableAst callAst = AST_MUTATOR.newGlobalCall("func", argAst1, argAst2); + + assertThat(CEL_UNPARSER.unparse(callAst.toParsedAst())) + .isEqualTo("func([1].exists(x, x >= 1), \"hello\")"); + } + + @Test + public void newMemberCallAst_success() throws Exception { + CelMutableAst targetAst = CelMutableAst.fromCelAst(CEL.compile("'hello'").getAst()); + CelMutableAst argAst1 = CelMutableAst.fromCelAst(CEL.compile("[1].exists(x, x >= 1)").getAst()); + CelMutableAst argAst2 = CelMutableAst.fromCelAst(CEL.compile("'world'").getAst()); + + CelMutableAst callAst = AST_MUTATOR.newMemberCall(targetAst, "func", argAst1, argAst2); + + assertThat(CEL_UNPARSER.unparse(callAst.toParsedAst())) + .isEqualTo("\"hello\".func([1].exists(x, x >= 1), \"world\")"); + } + + /** + * Asserts that the expressions that appears in source_info's macro calls are consistent with the + * actual expr nodes in the AST. + */ + private void assertConsistentMacroCalls(CelAbstractSyntaxTree ast) { + assertThat(ast.getSource().getMacroCalls()).isNotEmpty(); + ImmutableMap allExprs = + CelNavigableAst.fromAst(ast) + .getRoot() + .allNodes() + .map(CelNavigableExpr::expr) + .collect(toImmutableMap(CelExpr::id, node -> node, (expr1, expr2) -> expr1)); + for (CelExpr macroCall : ast.getSource().getMacroCalls().values()) { + assertThat(macroCall.id()).isEqualTo(0); + CelNavigableExpr.fromExpr(macroCall) + .descendants() + .map(CelNavigableExpr::expr) + .forEach( + node -> { + CelExpr e = allExprs.get(node.id()); + if (e != null) { + assertThat(node.id()).isEqualTo(e.id()); + if (e.exprKind().getKind().equals(Kind.COMPREHENSION)) { + assertThat(node.exprKind().getKind()).isEqualTo(Kind.NOT_SET); + } else { + assertThat(node.exprKind().getKind()).isEqualTo(e.exprKind().getKind()); + } + } + }); + } + } +} diff --git a/optimizer/src/test/java/dev/cel/optimizer/BUILD.bazel b/optimizer/src/test/java/dev/cel/optimizer/BUILD.bazel new file mode 100644 index 000000000..8ea72a261 --- /dev/null +++ b/optimizer/src/test/java/dev/cel/optimizer/BUILD.bazel @@ -0,0 +1,52 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], +) + +java_library( + name = "tests", + testonly = 1, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//bundle:cel", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:mutable_ast", + "//common:options", + "//common/ast", + "//common/ast:mutable_expr", + "//common/navigation", + "//common/types", + "//compiler", + "//extensions", + "//extensions:optional_library", + "//optimizer", + "//optimizer:ast_optimizer", + "//optimizer:mutable_ast", + "//optimizer:optimization_exception", + "//optimizer:optimizer_builder", + "//optimizer:optimizer_impl", + "//parser:macro", + "//parser:parser_factory", + "//parser:unparser", + "//runtime", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/optimizer/src/test/java/dev/cel/optimizer/CelOptimizerFactoryTest.java b/optimizer/src/test/java/dev/cel/optimizer/CelOptimizerFactoryTest.java new file mode 100644 index 000000000..41c7ecd74 --- /dev/null +++ b/optimizer/src/test/java/dev/cel/optimizer/CelOptimizerFactoryTest.java @@ -0,0 +1,61 @@ +// Copyright 2023 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.optimizer; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.bundle.CelFactory; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelParserFactory; +import dev.cel.runtime.CelRuntimeFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelOptimizerFactoryTest { + + @Test + public void standardCelOptimizerBuilder_withParserCheckerAndRuntime() { + CelOptimizerBuilder builder = + CelOptimizerFactory.standardCelOptimizerBuilder( + CelParserFactory.standardCelParserBuilder().build(), + CelCompilerFactory.standardCelCheckerBuilder().build(), + CelRuntimeFactory.standardCelRuntimeBuilder().build()); + + assertThat(builder).isNotNull(); + assertThat(builder.build()).isNotNull(); + } + + @Test + public void standardCelOptimizerBuilder_withCompilerAndRuntime() { + CelOptimizerBuilder builder = + CelOptimizerFactory.standardCelOptimizerBuilder( + CelCompilerFactory.standardCelCompilerBuilder().build(), + CelRuntimeFactory.standardCelRuntimeBuilder().build()); + + assertThat(builder).isNotNull(); + assertThat(builder.build()).isNotNull(); + } + + @Test + public void standardCelOptimizerBuilder_withCel() { + CelOptimizerBuilder builder = + CelOptimizerFactory.standardCelOptimizerBuilder(CelFactory.standardCelBuilder().build()); + + assertThat(builder).isNotNull(); + assertThat(builder.build()).isNotNull(); + } +} diff --git a/optimizer/src/test/java/dev/cel/optimizer/CelOptimizerImplTest.java b/optimizer/src/test/java/dev/cel/optimizer/CelOptimizerImplTest.java new file mode 100644 index 000000000..cb0bff6c6 --- /dev/null +++ b/optimizer/src/test/java/dev/cel/optimizer/CelOptimizerImplTest.java @@ -0,0 +1,134 @@ +// Copyright 2023 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.optimizer; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelSource; +import dev.cel.common.CelValidationException; +import dev.cel.common.ast.CelExpr; +import dev.cel.optimizer.CelAstOptimizer.OptimizationResult; +import java.util.ArrayList; +import java.util.List; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelOptimizerImplTest { + + private static final Cel CEL = CelFactory.standardCelBuilder().build(); + + @Test + public void constructCelOptimizer_success() { + CelOptimizer celOptimizer = + CelOptimizerImpl.newBuilder(CEL) + .addAstOptimizers( + (ast, cel) -> + // no-op + OptimizationResult.create(ast)) + .build(); + + assertThat(celOptimizer).isNotNull(); + assertThat(celOptimizer).isInstanceOf(CelOptimizerImpl.class); + } + + @Test + public void astOptimizers_invokedInOrder() throws Exception { + List list = new ArrayList<>(); + + CelOptimizer celOptimizer = + CelOptimizerImpl.newBuilder(CEL) + .addAstOptimizers( + (ast, cel) -> { + list.add(1); + return OptimizationResult.create(ast); + }) + .addAstOptimizers( + (ast, cel) -> { + list.add(2); + return OptimizationResult.create(ast); + }) + .addAstOptimizers( + (ast, cel) -> { + list.add(3); + return OptimizationResult.create(ast); + }) + .build(); + + CelAbstractSyntaxTree ast = celOptimizer.optimize(CEL.compile("'hello world'").getAst()); + + assertThat(ast).isNotNull(); + assertThat(list).containsExactly(1, 2, 3).inOrder(); + } + + @Test + public void optimizer_whenAstOptimizerThrows_throwsException() { + CelOptimizer celOptimizer = + CelOptimizerImpl.newBuilder(CEL) + .addAstOptimizers( + (navigableAst, cel) -> { + throw new IllegalArgumentException("Test exception"); + }) + .build(); + + CelOptimizationException e = + assertThrows( + CelOptimizationException.class, + () -> celOptimizer.optimize(CEL.compile("'hello world'").getAst())); + assertThat(e).hasMessageThat().isEqualTo("Optimization failure: Test exception"); + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + } + + @Test + public void parsedAst_throwsException() { + CelOptimizer celOptimizer = CelOptimizerImpl.newBuilder(CEL).build(); + + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> celOptimizer.optimize(CEL.parse("'test'").getAst())); + assertThat(e).hasMessageThat().contains("AST must be type-checked."); + } + + @Test + public void optimizedAst_failsToTypeCheck_throwsException() { + CelOptimizer celOptimizer = + CelOptimizerImpl.newBuilder(CEL) + .addAstOptimizers( + (navigableAst, cel) -> + OptimizationResult.create( + CelAbstractSyntaxTree.newParsedAst( + CelExpr.ofIdent(1, "undeclared_ident"), + CelSource.newBuilder().build()))) + .build(); + + CelOptimizationException e = + assertThrows( + CelOptimizationException.class, + () -> celOptimizer.optimize(CEL.compile("'hello world'").getAst())); + + assertThat(e) + .hasMessageThat() + .contains( + "Optimized AST failed to type-check: ERROR: :1:1: undeclared reference to" + + " 'undeclared_ident' (in container '')"); + assertThat(e).hasCauseThat().isInstanceOf(CelValidationException.class); + } +} diff --git a/optimizer/src/test/java/dev/cel/optimizer/optimizers/BUILD.bazel b/optimizer/src/test/java/dev/cel/optimizer/optimizers/BUILD.bazel new file mode 100644 index 000000000..53d72de67 --- /dev/null +++ b/optimizer/src/test/java/dev/cel/optimizer/optimizers/BUILD.bazel @@ -0,0 +1,59 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], +) + +java_library( + name = "tests", + testonly = 1, + srcs = glob(["*.java"]), + resources = ["//optimizer/src/test/resources:baselines"], + deps = [ + "//bundle:cel", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:mutable_ast", + "//common:options", + "//common/ast", + "//common/navigation:mutable_navigation", + "//common/types", + "//extensions", + "//extensions:optional_library", + # "//java/com/google/testing/testsize:annotations", + "//optimizer", + "//optimizer:optimization_exception", + "//optimizer:optimizer_builder", + "//optimizer/optimizers:common_subexpression_elimination", + "//optimizer/optimizers:constant_folding", + "//optimizer/optimizers:inlining", + "//parser:macro", + "//parser:unparser", + "//runtime", + "//runtime:function_binding", + "//runtime:partial_vars", + "//runtime:program", + "//runtime:unknown_attributes", + "//testing:baseline_test_case", + "//testing:cel_runtime_flavor", + "@maven//:junit_junit", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "//:java_truth", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + ], +) + +junit4_test_suites( + name = "test_suites", + shard_count = 4, + sizes = [ + "small", + "medium", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/optimizer/src/test/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizerTest.java b/optimizer/src/test/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizerTest.java new file mode 100644 index 000000000..ee62c5ed1 --- /dev/null +++ b/optimizer/src/test/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizerTest.java @@ -0,0 +1,581 @@ +// Copyright 2023 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.optimizer.optimizers; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelBuilder; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.SimpleType; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelExtensions; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.optimizer.CelOptimizationException; +import dev.cel.optimizer.CelOptimizer; +import dev.cel.optimizer.CelOptimizerFactory; +import dev.cel.optimizer.optimizers.ConstantFoldingOptimizer.ConstantFoldingOptions; +import dev.cel.parser.CelStandardMacro; +import dev.cel.parser.CelUnparser; +import dev.cel.parser.CelUnparserFactory; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.testing.CelRuntimeFlavor; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class ConstantFoldingOptimizerTest { + private static final CelOptions CEL_OPTIONS = + CelOptions.current() + .populateMacroCalls(true) + .enableHeterogeneousNumericComparisons(true) + .build(); + + private static final CelUnparser CEL_UNPARSER = CelUnparserFactory.newUnparser(); + + @TestParameter CelRuntimeFlavor runtimeFlavor; + + private Cel cel; + private CelOptimizer celOptimizer; + + @Before + public void setUp() { + this.cel = setupEnv(runtimeFlavor.builder()); + this.celOptimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(this.cel) + .addAstOptimizers(ConstantFoldingOptimizer.getInstance()) + .build(); + } + + private static Cel setupEnv(CelBuilder celBuilder) { + return celBuilder + .addVar("x", SimpleType.DYN) + .addVar("y", SimpleType.DYN) + .addVar("list_var", ListType.create(SimpleType.STRING)) + .addVar("map_var", MapType.create(SimpleType.STRING, SimpleType.STRING)) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "get_true", + CelOverloadDecl.newGlobalOverload("get_true_overload", SimpleType.BOOL)), + CelFunctionDecl.newFunctionDeclaration( + "get_list", + CelOverloadDecl.newGlobalOverload( + "get_list_overload", + ListType.create(SimpleType.INT), + ListType.create(SimpleType.INT)))) + .addFunctionBindings( + CelFunctionBinding.from("get_true_overload", ImmutableList.of(), unused -> true)) + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .setOptions(CEL_OPTIONS) + .addCompilerLibraries( + CelExtensions.bindings(), + CelOptionalLibrary.INSTANCE, + CelExtensions.math(CEL_OPTIONS), + CelExtensions.strings(), + CelExtensions.sets(CEL_OPTIONS), + CelExtensions.encoders(CEL_OPTIONS)) + .addRuntimeLibraries( + CelOptionalLibrary.INSTANCE, + CelExtensions.math(CEL_OPTIONS), + CelExtensions.strings(), + CelExtensions.sets(CEL_OPTIONS), + CelExtensions.encoders(CEL_OPTIONS)) + .build(); + } + + @Test + @TestParameters("{source: 'null', expected: 'null'}") + @TestParameters("{source: '1 + 2', expected: '3'}") + @TestParameters("{source: '1 + 2 + 3', expected: '6'}") + @TestParameters("{source: '1 + 2 + x', expected: '3 + x'}") + @TestParameters("{source: 'true && true', expected: 'true'}") + @TestParameters("{source: 'true && false', expected: 'false'}") + @TestParameters("{source: 'true || false', expected: 'true'}") + @TestParameters("{source: 'false || false', expected: 'false'}") + @TestParameters("{source: 'true && false || true', expected: 'true'}") + @TestParameters("{source: 'false && true || false', expected: 'false'}") + @TestParameters("{source: 'true && x', expected: 'x'}") + @TestParameters("{source: 'x && true', expected: 'x'}") + @TestParameters("{source: 'false && x', expected: 'false'}") + @TestParameters("{source: 'x && false', expected: 'false'}") + @TestParameters("{source: 'true || x', expected: 'true'}") + @TestParameters("{source: 'x || true', expected: 'true'}") + @TestParameters("{source: 'false || x', expected: 'x'}") + @TestParameters("{source: 'x || false', expected: 'x'}") + @TestParameters("{source: 'true && x && true && x', expected: 'x && x'}") + @TestParameters("{source: 'false || x || false || x', expected: 'x || x'}") + @TestParameters("{source: 'false || x || false || y', expected: 'x || y'}") + @TestParameters("{source: 'true ? x + 1 : x + 2', expected: 'x + 1'}") + @TestParameters("{source: 'false ? x + 1 : x + 2', expected: 'x + 2'}") + @TestParameters( + "{source: 'false ? x + ''world'' : ''hello'' + ''world''', expected: '\"helloworld\"'}") + @TestParameters("{source: 'true ? (false ? x + 1 : x + 2) : x', expected: 'x + 2'}") + @TestParameters("{source: 'false ? x : (true ? x + 1 : x + 2)', expected: 'x + 1'}") + @TestParameters("{source: '[1, 1 + 2, 1 + (2 + 3)]', expected: '[1, 3, 6]'}") + @TestParameters("{source: '1 in []', expected: 'false'}") + @TestParameters("{source: 'x in []', expected: 'false'}") + @TestParameters("{source: '6 in [1, 1 + 2, 1 + (2 + 3)]', expected: 'true'}") + @TestParameters("{source: '5 in [1, 1 + 2, 1 + (2 + 3)]', expected: 'false'}") + @TestParameters("{source: '5 in [1, x, y, 5]', expected: 'true'}") + @TestParameters("{source: '!(5 in [1, x, y, 5])', expected: 'false'}") + @TestParameters("{source: 'x in [1, x, y, 5]', expected: 'true'}") + @TestParameters("{source: 'x in [1, 1 + 2, 1 + (2 + 3)]', expected: 'x in [1, 3, 6]'}") + @TestParameters("{source: 'duration(string(7 * 24) + ''h'')', expected: 'duration(\"168h\")'}") + @TestParameters("{source: '[1, ?optional.of(3)]', expected: '[1, 3]'}") + @TestParameters("{source: '[1, ?optional.ofNonZeroValue(0)]', expected: '[1]'}") + @TestParameters("{source: '[1, optional.of(3)]', expected: '[1, optional.of(3)]'}") + @TestParameters("{source: '[?optional.none(), ?x]', expected: '[?x]'}") + @TestParameters("{source: '[?optional.of(1 + 2 + 3)]', expected: '[6]'}") + @TestParameters("{source: '[?optional.of(3)]', expected: '[3]'}") + @TestParameters("{source: '[?optional.of(x)]', expected: '[?optional.of(x)]'}") + @TestParameters("{source: '[?optional.ofNonZeroValue(0)]', expected: '[]'}") + @TestParameters("{source: '[?optional.ofNonZeroValue(3)]', expected: '[3]'}") + @TestParameters("{source: '[optional.none(), ?x]', expected: '[optional.none(), ?x]'}") + @TestParameters("{source: '[optional.of(1 + 2 + 3)]', expected: '[optional.of(6)]'}") + @TestParameters("{source: '[optional.of(3)]', expected: '[optional.of(3)]'}") + @TestParameters("{source: '[optional.of(x)]', expected: '[optional.of(x)]'}") + @TestParameters("{source: '[optional.ofNonZeroValue(1 + 2 + 3)]', expected: '[optional.of(6)]'}") + @TestParameters("{source: '[optional.ofNonZeroValue(3)]', expected: '[optional.of(3)]'}") + @TestParameters("{source: 'optional.none()', expected: 'optional.none()'}") + @TestParameters( + "{source: '[1, x, optional.of(1), ?optional.of(1), optional.ofNonZeroValue(3)," + + " ?optional.ofNonZeroValue(3), ?optional.ofNonZeroValue(0), ?y, ?x.?y]', " + + "expected: '[1, x, optional.of(1), 1, optional.of(3), 3, ?y, ?x.?y]'}") + @TestParameters( + "{source: '[1, x, ?optional.ofNonZeroValue(3), ?x.?y].size() > 3'," + + " expected: '[1, x, 3, ?x.?y].size() > 3'}") + @TestParameters("{source: '{?1: optional.none()}', expected: '{}'}") + @TestParameters( + "{source: '{?1: optional.of(\"hello\"), ?2: optional.ofNonZeroValue(0), 3:" + + " optional.ofNonZeroValue(0), ?4: optional.of(x)}', expected: '{1: \"hello\", 3:" + + " optional.none(), ?4: optional.of(x)}'}") + @TestParameters( + "{source: '{?x: optional.of(1), ?y: optional.ofNonZeroValue(0)}', expected: '{?x:" + + " optional.of(1), ?y: optional.none()}'}") + @TestParameters( + "{source: 'TestAllTypes{single_int64: 1 + 2 + 3 + x}', " + + " expected: 'cel.expr.conformance.proto3.TestAllTypes{single_int64: 6 + x}'}") + @TestParameters( + "{source: 'TestAllTypes{?single_int64: optional.ofNonZeroValue(1)}', " + + " expected: 'cel.expr.conformance.proto3.TestAllTypes{single_int64: 1}'}") + @TestParameters( + "{source: 'TestAllTypes{?single_int64: optional.ofNonZeroValue(0)}', " + + " expected: 'cel.expr.conformance.proto3.TestAllTypes{}'}") + @TestParameters( + "{source: 'TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32:" + + " optional.of(4), ?single_uint64: optional.ofNonZeroValue(x)}', expected:" + + " 'cel.expr.conformance.proto3.TestAllTypes{single_int64: 1, single_int32: 4," + + " ?single_uint64: optional.ofNonZeroValue(x)}'}") + @TestParameters( + "{source: 'TestAllTypes{single_nested_message: TestAllTypes.NestedMessage{bb:" + + " 42}}.single_nested_message.bb', expected: '42'}") + @TestParameters("{source: '{\"a\": 1}[\"a\"]', expected: '1'}") + @TestParameters("{source: '{\"a\": {\"b\": 2}}[\"a\"][\"b\"]', expected: '2'}") + @TestParameters("{source: '{\"hello\": \"world\"}.hello == x', expected: '\"world\" == x'}") + @TestParameters("{source: '{\"hello\": \"world\"}[\"hello\"] == x', expected: '\"world\" == x'}") + @TestParameters("{source: '{\"hello\": \"world\"}.?hello', expected: 'optional.of(\"world\")'}") + @TestParameters( + "{source: '{\"hello\": \"world\"}.?hello.orValue(\"default\") == x', " + + "expected: '\"world\" == x'}") + @TestParameters( + "{source: '{?\"hello\": optional.of(\"world\")}[\"hello\"] == x', expected: '\"world\" ==" + + " x'}") + @TestParameters("{source: '[1] + [2] + [3]', expected: '[1, 2, 3]'}") + @TestParameters("{source: '[1] + [?optional.of(2)] + [3]', expected: '[1, 2, 3]'}") + @TestParameters("{source: '[1] + [x]', expected: '[1] + [x]'}") + @TestParameters("{source: 'x + dyn([1, 2] + [3, 4])', expected: 'x + [1, 2, 3, 4]'}") + @TestParameters( + "{source: '{\"a\": dyn([1, 2]), \"b\": x}', expected: '{\"a\": [1, 2], \"b\": x}'}") + @TestParameters("{source: 'map_var[?\"key\"]', expected: 'map_var[?\"key\"]'}") + @TestParameters("{source: '\"abc\" in list_var', expected: '\"abc\" in list_var'}") + @TestParameters("{source: '[?optional.none(), [?optional.none()]]', expected: '[[]]'}") + @TestParameters("{source: 'math.greatest(1.0, 2, 3.0)', expected: '3.0'}") + @TestParameters("{source: '\"world\".charAt(1)', expected: '\"o\"'}") + @TestParameters("{source: 'base64.encode(b\"hello\")', expected: '\"aGVsbG8=\"'}") + @TestParameters("{source: 'sets.contains([1], [1])', expected: 'true'}") + @TestParameters( + "{source: 'cel.bind(r0, [1, 2, 3], cel.bind(r1, 1 in r0, r1))', expected: 'true'}") + @TestParameters("{source: 'x == true', expected: 'x'}") + @TestParameters("{source: 'true == x', expected: 'x'}") + @TestParameters("{source: 'x == false', expected: '!x'}") + @TestParameters("{source: 'false == x', expected: '!x'}") + @TestParameters("{source: 'true == false', expected: 'false'}") + @TestParameters("{source: 'true == true', expected: 'true'}") + @TestParameters("{source: 'false == true', expected: 'false'}") + @TestParameters("{source: 'false == false', expected: 'true'}") + @TestParameters("{source: '10 == 42', expected: 'false'}") + @TestParameters("{source: '42 == 42', expected: 'true'}") + @TestParameters("{source: 'x != true', expected: '!x'}") + @TestParameters("{source: 'true != x', expected: '!x'}") + @TestParameters("{source: 'x != false', expected: 'x'}") + @TestParameters("{source: 'false != x', expected: 'x'}") + @TestParameters("{source: 'true != false', expected: 'true'}") + @TestParameters("{source: 'true != true', expected: 'false'}") + @TestParameters("{source: 'false != true', expected: 'true'}") + @TestParameters("{source: 'false != false', expected: 'false'}") + @TestParameters("{source: '10 != 42', expected: 'true'}") + @TestParameters("{source: '42 != 42', expected: 'false'}") + @TestParameters("{source: '[\"foo\",\"bar\"] == [\"foo\",\"bar\"]', expected: 'true'}") + @TestParameters("{source: '[\"bar\",\"foo\"] == [\"foo\",\"bar\"]', expected: 'false'}") + @TestParameters("{source: 'duration(\"1h\") - duration(\"60m\")', expected: 'duration(\"0s\")'}") + @TestParameters( + "{source: 'duration(\"2h23m42s12ms42us92ns\") + duration(\"129481231298125ns\")', expected:" + + " 'duration(\"138103.243340217s\")'}") + @TestParameters( + "{source: 'timestamp(900000) - timestamp(100)', expected: 'duration(\"899900s\")'}") + @TestParameters( + "{source: 'timestamp(\"2000-01-01T00:02:03.2123Z\") + duration(\"25h2m32s42ms53us29ns\")'," + + " expected: 'timestamp(\"2000-01-02T01:04:35.254353029Z\")'}") + @TestParameters( + "{source: 'has({\"req\": \"Avail\"}.opt) ? ({\"req\": \"Avail\"}.req + \" \" +" + + " {\"req\": \"Avail\"}.opt) : {\"req\": \"Avail\"}.req', expected: '\"Avail\"'}") + @TestParameters("{source: 'true || optional.none().hasValue()', expected: 'true'}") + @TestParameters("{source: 'false && map_var[?\"missing\"].hasValue()', expected: 'false'}") + @TestParameters("{source: '{\"hello\": [1, 2]}.?hello', expected: 'optional.of([1, 2])'}") + @TestParameters( + "{source: '{?\"key\": optional.of({\"a\": 1})}', expected: '{\"key\": {\"a\": 1}}'}") + @TestParameters( + "{source: 'TestAllTypes{?repeated_int32: optional.of([1, 2])}'," + + " expected: 'cel.expr.conformance.proto3.TestAllTypes{repeated_int32: [1, 2]}'}") + @TestParameters("{source: '[?optional.of([1, x])]', expected: '[?optional.of([1, x])]'}") + @TestParameters("{source: '[?optional.of({\"a\": x})]', expected: '[?optional.of({\"a\": x})]'}") + @TestParameters("{source: '[?optional.of({x: 1})]', expected: '[?optional.of({x: 1})]'}") + @TestParameters( + "{source: '[?optional.of(TestAllTypes{single_int32: x})]', expected:" + + " '[?optional.of(cel.expr.conformance.proto3.TestAllTypes{single_int32: x})]'}") + @TestParameters( + "{source: '[?optional.of(TestAllTypes{single_int32: 1})]', expected:" + + " '[cel.expr.conformance.proto3.TestAllTypes{single_int32: 1}]'}") + @TestParameters("{source: '[?optional.of(x)]', expected: '[?optional.of(x)]'}") + // TODO: Support folding lists with mixed types. This requires mutable lists. + // @TestParameters("{source: 'dyn([1]) + [1.0]'}") + public void constantFold_success(String source, String expected) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + CelAbstractSyntaxTree optimizedAst = celOptimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)).isEqualTo(expected); + } + + @Test + @TestParameters("{source: '[1 + 1, 1 + 2].exists(i, i < 10)', expected: 'true'}") + @TestParameters("{source: '[1, 1 + 1, 1 + 2, 2 + 3].exists(i, i < 10)', expected: 'true'}") + @TestParameters("{source: '[1, 1 + 1, 1 + 2, 2 + 3].exists(i, i < 1 % 2)', expected: 'false'}") + @TestParameters("{source: '[1, 2, 3].map(i, i * 2)', expected: '[2, 4, 6]'}") + @TestParameters( + "{source: '[1, 2, 3].map(i, [1, 2, 3].map(j, i * j))', " + + "expected: '[[1, 2, 3], [2, 4, 6], [3, 6, 9]]'}") + @TestParameters( + "{source: '[1, 2, 3].map(i, [1, 2, 3].map(j, i * j).filter(k, k % 2 == 0))', " + + "expected: '[[2], [2, 4, 6], [6]]'}") + @TestParameters( + "{source: '[1, 2, 3].map(i, [1, 2, 3].map(j, i * j).filter(k, k % 2 == x))', " + + "expected: '[1, 2, 3].map(i, [1, 2, 3].map(j, i * j).filter(k, k % 2 == x))'}") + @TestParameters("{source: '[1, 2, 3, 4].all(i, v, i < v)', expected: 'true'}") + @TestParameters( + "{source: '[1 + 1, 2 + 2, 3 + 3].all(i, v, i < 5 && v < x)', " + + "expected: '[2, 4, 6].all(i, v, i < 5 && v < x)'}") + @TestParameters( + "{source: '[{}, {\"a\": 1}, {\"b\": 2}].filter(m, has(m.a))', expected: '[{\"a\": 1}]'}") + @TestParameters( + "{source: '[{}, {?\"a\": optional.of(1)}, {\"b\": optional.of(2)}].filter(m, has(m.a))'," + + " expected: '[{\"a\": 1}]'}") + @TestParameters( + "{source: '[{}, {?\"a\": optional.of(1)}, {\"b\": optional.of(2)}].map(i, i)'," + + " expected: '[{}, {\"a\": 1}, {\"b\": optional.of(2)}].map(i, i)'}") + @TestParameters( + "{source: '[{}, {\"a\": 1}, {\"b\": 2}].filter(m, has({\"a\": true}.a))'," + + " expected: '[{}, {\"a\": 1}, {\"b\": 2}]'}") + @TestParameters("{source: 'has(x.single_int32)', expected: 'has(x.single_int32)'}") + @TestParameters( + "{source: '[{}, {\"a\": 1}, {\"b\": 2}].filter(m, has(x.a))', expected:" + + " '[{}, {\"a\": 1}, {\"b\": 2}].filter(m, has(x.a))'}") + @TestParameters( + "{source: 'cel.bind(r0, [1, 2, 3], cel.bind(r1, 1 in r0 && 2 in x, r1))', expected:" + + " 'cel.bind(r0, [1, 2, 3], cel.bind(r1, 1 in r0 && 2 in x, r1))'}") + @TestParameters("{source: 'false ? false : cel.bind(a, x, a)', expected: 'cel.bind(a, x, a)'}") + @TestParameters( + "{source: 'cel.bind(myMap, {\"foo\": \"bar\"}, myMap[?\"foo\"].optMap(x, x + \"baz\"))', " + + "expected: 'optional.of(\"barbaz\")'}") + public void constantFold_macros_macroCallMetadataPopulated(String source, String expected) + throws Exception { + Cel cel = + runtimeFlavor + .builder() + .addVar("x", SimpleType.DYN) + .addVar("y", SimpleType.DYN) + .addMessageTypes(TestAllTypes.getDescriptor()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setOptions(CEL_OPTIONS) + .addCompilerLibraries( + CelExtensions.bindings(), CelExtensions.optional(), CelExtensions.comprehensions()) + .addRuntimeLibraries(CelExtensions.optional(), CelExtensions.comprehensions()) + .build(); + CelOptimizer celOptimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers(ConstantFoldingOptimizer.getInstance()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + CelAbstractSyntaxTree optimizedAst = celOptimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)).isEqualTo(expected); + } + + @Test + @TestParameters("{source: '[1 + 1, 1 + 2].exists(i, i < 10) == true'}") + @TestParameters("{source: '[1, 1 + 1, 1 + 2, 2 + 3].exists(i, i < 10) == true'}") + @TestParameters("{source: '[1, 1 + 1, 1 + 2, 2 + 3].exists(i, i < 1 % 2) == false'}") + @TestParameters("{source: '[1, 2, 3].map(i, i * 2) == [2, 4, 6]'}") + @TestParameters( + "{source: '[1, 2, 3].map(i, [1, 2, 3].map(j, i * j)) == [[1, 2, 3], [2, 4, 6], [3, 6, 9]]'}") + @TestParameters( + "{source: '[1, 2, 3].map(i, [1, 2, 3].map(j, i * j).filter(k, k % 2 == 0)) == " + + "[[2], [2, 4, 6], [6]]'}") + @TestParameters("{source: '[{}, {\"a\": 1}, {\"b\": 2}].filter(m, has(m.a)) == [{\"a\": 1}]'}") + @TestParameters( + "{source: '[{}, {?\"a\": optional.of(1)}, {\"b\": optional.of(2)}].filter(m, has(m.a)) == " + + " [{\"a\": 1}]'}") + @TestParameters( + "{source: '[{}, {?\"a\": optional.of(1)}, {\"b\": optional.of(2)}].map(i, i) == " + + " [{}, {\"a\": 1}, {\"b\": optional.of(2)}].map(i, i)'}") + @TestParameters( + "{source: '[{}, {\"a\": 1}, {\"b\": 2}].filter(m, has({\"a\": true}.a)) == " + + " [{}, {\"a\": 1}, {\"b\": 2}]'}") + @TestParameters("{source: 'cel.bind(r0, [1, 2, 3], cel.bind(r1, 1 in r0 && 2 in r0, r1))'}") + @TestParameters("{source: 'false ? false : cel.bind(a, true, a)'}") + public void constantFold_macros_withoutMacroCallMetadata(String source) throws Exception { + Cel cel = + runtimeFlavor + .builder() + .addVar("x", SimpleType.DYN) + .addVar("y", SimpleType.DYN) + .addMessageTypes(TestAllTypes.getDescriptor()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setOptions( + CelOptions.current() + .enableHeterogeneousNumericComparisons(true) + .populateMacroCalls(false) + .build()) + .addCompilerLibraries(CelExtensions.bindings(), CelOptionalLibrary.INSTANCE) + .addRuntimeLibraries(CelOptionalLibrary.INSTANCE) + .build(); + CelOptimizer celOptimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers(ConstantFoldingOptimizer.getInstance()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + CelAbstractSyntaxTree optimizedAst = celOptimizer.optimize(ast); + + assertThat(optimizedAst.getSource().getMacroCalls()).isEmpty(); + assertThat(cel.createProgram(optimizedAst).eval()).isEqualTo(true); + } + + @Test + @TestParameters("{source: '1'}") + @TestParameters("{source: '5.0'}") + @TestParameters("{source: 'true'}") + @TestParameters("{source: 'x'}") + @TestParameters("{source: 'x + 1 + 2'}") + @TestParameters("{source: 'duration(\"16800s\")'}") + @TestParameters("{source: 'timestamp(\"1970-01-01T00:00:00Z\")'}") + @TestParameters( + "{source: 'type(1)'}") // This folds in cel-go implementation but Java does not yet have a + // literal representation for type values + @TestParameters("{source: '[1, 2, 3]'}") + @TestParameters("{source: 'optional.of(\"hello\")'}") + @TestParameters("{source: 'optional.none()'}") + @TestParameters("{source: '[optional.none()]'}") + @TestParameters("{source: '[?x.?y]'}") + @TestParameters( + "{source: 'cel.expr.conformance.proto3.TestAllTypes{" + + "single_int32: x, repeated_int32: [1, 2, 3]}'}") + @TestParameters("{source: 'get_true() == get_true()'}") + @TestParameters("{source: 'get_true() == true'}") + @TestParameters("{source: 'x == x'}") + @TestParameters("{source: 'x == 42'}") + @TestParameters("{source: 'timestamp(100)'}") + @TestParameters("{source: 'duration(\"1h\")'}") + @TestParameters("{source: '[true].exists(x, x == get_true())'}") + @TestParameters("{source: 'get_list([1, 2]).map(x, x * 2)'}") + @TestParameters("{source: '[(x - 1 > 3) ? (x - 1) : 5].exists(x, x - 1 > 3)'}") + public void constantFold_noOp(String source) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + CelAbstractSyntaxTree optimizedAst = celOptimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)).isEqualTo(source); + } + + @Test + public void constantFold_addFoldableFunction_success() throws Exception { + CelAbstractSyntaxTree ast = cel.compile("get_true() == get_true()").getAst(); + ConstantFoldingOptions options = + ConstantFoldingOptions.newBuilder().addFoldableFunctions("get_true").build(); + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers(ConstantFoldingOptimizer.newInstance(options)) + .build(); + + CelAbstractSyntaxTree optimizedAst = optimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)).isEqualTo("true"); + } + + @Test + public void constantFold_withExpectedResultTypeSet_success() throws Exception { + Cel cel = runtimeFlavor.builder().setResultType(SimpleType.STRING).build(); + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers(ConstantFoldingOptimizer.getInstance()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("string(!true)").getAst(); + + CelAbstractSyntaxTree optimizedAst = optimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)).isEqualTo("\"false\""); + } + + @Test + public void constantFold_withMacroCallPopulated_comprehensionsAreReplacedWithNotSet() + throws Exception { + Cel cel = + runtimeFlavor + .builder() + .addVar("x", SimpleType.DYN) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setOptions(CEL_OPTIONS) + .build(); + CelOptimizer celOptimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers(ConstantFoldingOptimizer.getInstance()) + .build(); + CelAbstractSyntaxTree ast = + cel.compile("[1, 1 + 1, 1 + 1+ 1].map(i, i).filter(j, j % 2 == x)").getAst(); + + CelAbstractSyntaxTree optimizedAst = celOptimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)) + .isEqualTo("[1, 2, 3].map(i, i).filter(j, j % 2 == x)"); + assertThat(optimizedAst.getSource().getMacroCalls()).hasSize(2); + assertThat(optimizedAst.getSource().getMacroCalls().get(1L).toString()) + .isEqualTo( + "CALL [0] {\n" + + " function: filter\n" + + " target: {\n" + + " NOT_SET [2] {}\n" + + " }\n" + + " args: {\n" + + " IDENT [25] {\n" + + " name: j\n" + + " }\n" + + " CALL [17] {\n" + + " function: _==_\n" + + " args: {\n" + + " CALL [18] {\n" + + " function: _%_\n" + + " args: {\n" + + " IDENT [19] {\n" + + " name: j\n" + + " }\n" + + " CONSTANT [20] { value: 2 }\n" + + " }\n" + + " }\n" + + " IDENT [21] {\n" + + " name: x\n" + + " }\n" + + " }\n" + + " }\n" + + " }\n" + + "}"); + assertThat(optimizedAst.getSource().getMacroCalls().get(2L).toString()) + .isEqualTo( + "CALL [0] {\n" + + " function: map\n" + + " target: {\n" + + " LIST [3] {\n" + + " elements: {\n" + + " CONSTANT [4] { value: 1 }\n" + + " CONSTANT [5] { value: 2 }\n" + + " CONSTANT [6] { value: 3 }\n" + + " }\n" + + " }\n" + + " }\n" + + " args: {\n" + + " IDENT [28] {\n" + + " name: i\n" + + " }\n" + + " IDENT [12] {\n" + + " name: i\n" + + " }\n" + + " }\n" + + "}"); + } + + @Test + public void constantFold_astProducesConsistentlyNumberedIds() throws Exception { + CelAbstractSyntaxTree ast = cel.compile("[1] + [2] + [3]").getAst(); + + CelAbstractSyntaxTree optimizedAst = celOptimizer.optimize(ast); + + assertThat(optimizedAst.getExpr().toString()) + .isEqualTo( + "LIST [1] {\n" + + " elements: {\n" + + " CONSTANT [2] { value: 1 }\n" + + " CONSTANT [3] { value: 2 }\n" + + " CONSTANT [4] { value: 3 }\n" + + " }\n" + + "}"); + } + + @Test + public void iterationLimitReached_throws() throws Exception { + Cel cel = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("1 + 1").getAst(); + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers( + ConstantFoldingOptimizer.newInstance( + ConstantFoldingOptions.newBuilder().maxIterationLimit(1).build())) + .build(); + + CelOptimizationException e = + assertThrows(CelOptimizationException.class, () -> optimizer.optimize(ast)); + assertThat(e).hasMessageThat().contains("Optimization failure: Max iteration count reached."); + } +} diff --git a/optimizer/src/test/java/dev/cel/optimizer/optimizers/InliningOptimizerTest.java b/optimizer/src/test/java/dev/cel/optimizer/optimizers/InliningOptimizerTest.java new file mode 100644 index 000000000..da2e9b745 --- /dev/null +++ b/optimizer/src/test/java/dev/cel/optimizer/optimizers/InliningOptimizerTest.java @@ -0,0 +1,309 @@ +// 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.optimizer.optimizers; + +import static com.google.common.truth.Truth.assertThat; +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.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.CelSource; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelExtensions; +import dev.cel.optimizer.CelOptimizationException; +import dev.cel.optimizer.CelOptimizer; +import dev.cel.optimizer.CelOptimizerFactory; +import dev.cel.optimizer.optimizers.InliningOptimizer.InlineVariable; +import dev.cel.optimizer.optimizers.InliningOptimizer.InliningOptions; +import dev.cel.optimizer.optimizers.SubexpressionOptimizer.SubexpressionOptimizerOptions; +import dev.cel.parser.CelStandardMacro; +import dev.cel.parser.CelUnparserFactory; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class InliningOptimizerTest { + + private static final Cel CEL = + CelFactory.standardCelBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setContainer(CelContainer.ofName("google.expr.proto3.test")) + .addFileTypes(TestAllTypes.getDescriptor().getFile()) + .addCompilerLibraries(CelExtensions.bindings()) + .addVar("int_var", SimpleType.INT) + .addVar("dyn_var", SimpleType.DYN) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .addVar("wrapper_var", StructTypeReference.create("google.protobuf.Int64Value")) + .addVar( + "child", + StructTypeReference.create(TestAllTypes.NestedMessage.getDescriptor().getFullName())) + .addVar("shadowed_ident", SimpleType.INT) + .setOptions(CelOptions.current().populateMacroCalls(true).build()) + .build(); + + @Test + public void inlining_success(@TestParameter SuccessTestCase testCase) throws Exception { + CelAbstractSyntaxTree astToInline = CEL.compile(testCase.source).getAst(); + CelAbstractSyntaxTree replacementAst = CEL.compile(testCase.replacement).getAst(); + + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL) + .addAstOptimizers( + InliningOptimizer.newInstance( + InlineVariable.of(testCase.inlineVarName, replacementAst))) + .build(); + + CelAbstractSyntaxTree optimized = optimizer.optimize(astToInline); + + String unparsed = CelUnparserFactory.newUnparser().unparse(optimized); + assertThat(unparsed).isEqualTo(testCase.expected); + } + + @Test + public void inlining_noop(@TestParameter NoOpTestCase testCase) throws Exception { + CelAbstractSyntaxTree astToInline = CEL.compile(testCase.source).getAst(); + CelAbstractSyntaxTree replacementAst = CEL.compile(testCase.replacement).getAst(); + + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL) + .addAstOptimizers( + InliningOptimizer.newInstance(InlineVariable.of(testCase.varName, replacementAst))) + .build(); + + CelAbstractSyntaxTree optimized = optimizer.optimize(astToInline); + + String unparsed = CelUnparserFactory.newUnparser().unparse(optimized); + assertThat(unparsed).isEqualTo(testCase.source); + } + + private enum SuccessTestCase { + CONSTANT( + /* source= */ "int_var + 2 + int_var", + /* inlineVarName= */ "int_var", + /* replacementExpr= */ "1", + /* expected= */ "1 + 2 + 1"), + REPEATED( + /* source= */ "dyn_var + [dyn_var]", + /* inlineVarName= */ "dyn_var", + /* replacementExpr= */ "dyn([1, 2])", + /* expected= */ "dyn([1, 2]) + [dyn([1, 2])]"), + SELECT_WITH_MACRO( + /* source= */ "has(msg.single_any.processing_purpose) ?" + + " msg.single_any.processing_purpose.map(i, i * 2)[0] : 42", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "[1,2,3].map(i, i * 2)", + /* expected= */ "([1, 2, 3].map(i, i * 2).size() != 0) ? ([1, 2, 3].map(i, i * 2).map(i, i" + + " * 2)[0]) : 42"), + PRESENCE_WITH_SELECT_EXPR( + /* source= */ "has(msg.single_any)", + /* inlineVarName= */ "msg.single_any", + /* replacementExpr= */ "msg.single_int64_wrapper", + /* expected= */ "has(msg.single_int64_wrapper)"), + PRESENCE_WITH_IDENT_NOT_NULL_REWRITE( + /* source= */ "has(msg.single_int64_wrapper)", + /* inlineVarName= */ "msg.single_int64_wrapper", + /* replacementExpr= */ "wrapper_var", + /* expected= */ "wrapper_var != null"), + PRESENCE_WITH_LIST_SIZE_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "[1, 2, 3]", + /* expected= */ "[1, 2, 3].size() != 0"), + PRESENCE_WITH_INT_LITERAL_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "1", + /* expected= */ "1 != 0"), + PRESENCE_WITH_UINT_LITERAL_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "1u", + /* expected= */ "1u != 0u"), + PRESENCE_WITH_DOUBLE_LITERAL_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "1.5", + /* expected= */ "1.5 != 0.0"), + PRESENCE_WITH_BOOL_LITERAL_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "true", + /* expected= */ "true != false"), + PRESENCE_WITH_STRING_LITERAL_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "'foo'", + /* expected= */ "\"foo\".size() != 0"), + PRESENCE_WITH_BYTES_LITERAL_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "b'abc'", + /* expected= */ "b\"\\141\\142\\143\".size() != 0"), + PRESENCE_WITH_TIMESTAMP_LITERAL_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "timestamp(1)", + /* expected= */ "timestamp(1) != timestamp(0)"), + PRESENCE_WITH_DURATION_LITERAL_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "duration('1h')", + /* expected= */ "duration(\"1h\") != duration(\"0\")"), + PRESENCE_WITH_PROTOBUF_MESSAGE_REWRITE( + /* source= */ "has(msg.single_any.processing_purpose)", + /* inlineVarName= */ "msg.single_any.processing_purpose", + /* replacementExpr= */ "cel.expr.conformance.proto3.TestAllTypes{single_int64: 1}", + /* expected= */ "cel.expr.conformance.proto3.TestAllTypes{single_int64: 1} !=" + + " cel.expr.conformance.proto3.TestAllTypes{}"), + NESTED_SELECT( + /* source= */ "msg.standalone_message.bb", + /* inlineVarName= */ "msg.standalone_message", + /* replacementExpr= */ "child", + /* expected= */ "child.bb"), + ; + + private final String source; + private final String inlineVarName; + private final String replacement; + private final String expected; + + SuccessTestCase(String source, String inlineVarName, String replacementExpr, String expected) { + this.source = source; + this.inlineVarName = inlineVarName; + this.replacement = replacementExpr; + this.expected = expected; + } + } + + private enum NoOpTestCase { + NO_INLINE_ITER_VAR("[0].exists(shadowed_ident, shadowed_ident == 0)", "shadowed_ident", "1"), + NO_INLINE_BIND_VAR("cel.bind(shadowed_ident, 2, shadowed_ident + 1)", "shadowed_ident", "1"), + ; + + private final String source; + private final String varName; + private final String replacement; + + NoOpTestCase(String source, String varName, String replacement) { + this.source = source; + this.varName = varName; + this.replacement = replacement; + } + } + + @Test + public void inline_exceededIterationLimit_throws() throws Exception { + String expression = "int_var + int_var + int_var"; + CelAbstractSyntaxTree astToInline = CEL.compile(expression).getAst(); + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL) + .addAstOptimizers( + InliningOptimizer.newInstance( + InliningOptions.newBuilder().maxIterationLimit(2).build(), + InlineVariable.of("int_var", CEL.compile("1").getAst()))) + .build(); + + CelOptimizationException e = + assertThrows(CelOptimizationException.class, () -> optimizer.optimize(astToInline)); + assertThat(e).hasMessageThat().contains("Max iteration count reached."); + } + + @Test + public void inlineVariableDecl_internalVar_throws() throws Exception { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> + InlineVariable.of( + "@internal_var", + CelAbstractSyntaxTree.newParsedAst( + CelExpr.ofNotSet(0L), CelSource.newBuilder().build()))); + assertThat(e).hasMessageThat().contains("Internal variables cannot be inlined: @internal_var"); + } + + @Test + public void inline_then_cse() throws Exception { + String source = + "has(msg.single_any.processing_purpose) ? " + + "msg.single_any.processing_purpose.map(i, i * 2)[0] : 42"; + CelAbstractSyntaxTree astToInline = CEL.compile(source).getAst(); + + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL) + .addAstOptimizers( + InliningOptimizer.newInstance( + InlineVariable.of( + "msg.single_any.processing_purpose", + CEL.compile("[1,2,3].map(i, i * 2)").getAst())), + SubexpressionOptimizer.newInstance( + SubexpressionOptimizerOptions.newBuilder().populateMacroCalls(true).build())) + .build(); + + CelAbstractSyntaxTree optimized = optimizer.optimize(astToInline); + + String unparsed = CelUnparserFactory.newUnparser().unparse(optimized); + assertThat(unparsed) + .isEqualTo( + "cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 * 2)], " + + "(@index0.size() != 0) ? (@index0.map(@it:1:0, @it:1:0 * 2)[0]) : 42)"); + } + + @Test + public void allowInliningDependentVariables_inOrder_dependentVariablesInlined() throws Exception { + String source = "int_var + dyn_var"; + CelAbstractSyntaxTree astToInline = CEL.compile(source).getAst(); + + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL) + .addAstOptimizers( + InliningOptimizer.newInstance( + InlineVariable.of("int_var", CEL.compile("dyn_var").getAst()), + InlineVariable.of("dyn_var", CEL.compile("2").getAst()))) + .build(); + + CelAbstractSyntaxTree optimized = optimizer.optimize(astToInline); + + String unparsed = CelUnparserFactory.newUnparser().unparse(optimized); + assertThat(unparsed).isEqualTo("2 + 2"); + } + + @Test + public void allowInliningDependentVariables_reverseOrder_inliningIsIndependent() + throws Exception { + String source = "int_var + dyn_var"; + CelAbstractSyntaxTree astToInline = CEL.compile(source).getAst(); + + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL) + .addAstOptimizers( + InliningOptimizer.newInstance( + InlineVariable.of("dyn_var", CEL.compile("2").getAst()), + InlineVariable.of("int_var", CEL.compile("dyn_var").getAst()))) + .build(); + + CelAbstractSyntaxTree optimized = optimizer.optimize(astToInline); + + String unparsed = CelUnparserFactory.newUnparser().unparse(optimized); + assertThat(unparsed).isEqualTo("dyn_var + 2"); + } +} diff --git a/optimizer/src/test/java/dev/cel/optimizer/optimizers/SubexpressionOptimizerBaselineTest.java b/optimizer/src/test/java/dev/cel/optimizer/optimizers/SubexpressionOptimizerBaselineTest.java new file mode 100644 index 000000000..04e4e6a1d --- /dev/null +++ b/optimizer/src/test/java/dev/cel/optimizer/optimizers/SubexpressionOptimizerBaselineTest.java @@ -0,0 +1,600 @@ +// Copyright 2024 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.optimizer.optimizers; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; + +import com.google.common.base.Ascii; +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +// import com.google.testing.testsize.MediumTest; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelBuilder; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.expr.conformance.proto3.NestedTestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelExtensions; +import dev.cel.optimizer.CelOptimizer; +import dev.cel.optimizer.CelOptimizerFactory; +import dev.cel.optimizer.optimizers.SubexpressionOptimizer.SubexpressionOptimizerOptions; +import dev.cel.parser.CelStandardMacro; +import dev.cel.parser.CelUnparser; +import dev.cel.parser.CelUnparserFactory; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.testing.BaselineTestCase; +import dev.cel.testing.CelRuntimeFlavor; +import java.util.EnumSet; +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +// @MediumTest +@RunWith(TestParameterInjector.class) +public class SubexpressionOptimizerBaselineTest extends BaselineTestCase { + private static Cel setupCelEnv(CelBuilder celBuilder) { + return celBuilder + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setOptions( + CelOptions.current() + .populateMacroCalls(true) + .enableHeterogeneousNumericComparisons(true) + .build()) + .addCompilerLibraries( + CelExtensions.optional(), CelExtensions.bindings(), CelExtensions.comprehensions()) + .addRuntimeLibraries(CelExtensions.optional(), CelExtensions.comprehensions()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "pure_custom_func", + newGlobalOverload("pure_custom_func_overload", SimpleType.INT, SimpleType.INT)), + CelFunctionDecl.newFunctionDeclaration( + "non_pure_custom_func", + newGlobalOverload("non_pure_custom_func_overload", SimpleType.INT, SimpleType.INT))) + .addFunctionBindings( + // This is pure, but for the purposes of excluding it as a CSE candidate, pretend that + // it isn't. + CelFunctionBinding.fromOverloads( + "non_pure_custom_func", + CelFunctionBinding.from("non_pure_custom_func_overload", Long.class, val -> val))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "pure_custom_func", + CelFunctionBinding.from("pure_custom_func_overload", Long.class, val -> val))) + .addVar("x", SimpleType.DYN) + .addVar("y", SimpleType.DYN) + .addVar("opt_x", OptionalType.create(SimpleType.DYN)) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + } + + private static final CelUnparser CEL_UNPARSER = CelUnparserFactory.newUnparser(); + private static final TestAllTypes TEST_ALL_TYPES_INPUT = + TestAllTypes.newBuilder() + .setSingleInt64(3L) + .setSingleInt32(5) + .setOneofType( + NestedTestAllTypes.newBuilder() + .setPayload( + TestAllTypes.newBuilder() + .setSingleInt32(8) + .setSingleInt64(10L) + .putMapInt32Int64(0, 1) + .putMapInt32Int64(1, 5) + .putMapInt32Int64(2, 2) + .putMapStringString("key", "A"))) + .build(); + + private static final SubexpressionOptimizerOptions OPTIMIZER_COMMON_OPTIONS = + SubexpressionOptimizerOptions.newBuilder() + .populateMacroCalls(true) + .addEliminableFunctions("pure_custom_func") + .build(); + + private String overriddenBaseFilePath = ""; + + @Before + public void setUp() { + this.cel = setupCelEnv(runtimeFlavor.builder()); + overriddenBaseFilePath = ""; + } + + @Override + protected String baselineFileName() { + if (overriddenBaseFilePath.isEmpty()) { + return super.baselineFileName(); + } + return overriddenBaseFilePath; + } + + @TestParameter CelRuntimeFlavor runtimeFlavor; + + private Cel cel; + + @Test + public void allOptimizers_producesSameEvaluationResult( + @TestParameter CseTestOptimizer cseTestOptimizer, @TestParameter CseTestCase cseTestCase) + throws Exception { + skipBaselineVerification(); + CelAbstractSyntaxTree ast = cel.compile(cseTestCase.source).getAst(); + ImmutableMap inputMap = + ImmutableMap.of("msg", TEST_ALL_TYPES_INPUT, "x", 5L, "y", 6L, "opt_x", Optional.of(5L)); + Object expectedEvalResult = cel.createProgram(ast).eval(inputMap); + + CelAbstractSyntaxTree optimizedAst = cseTestOptimizer.newCseOptimizer(cel).optimize(ast); + + Object optimizedEvalResult = cel.createProgram(optimizedAst).eval(inputMap); + assertThat(optimizedEvalResult).isEqualTo(expectedEvalResult); + } + + @Test + public void allOptimizers_producesSameEvaluationResult_parsedOnly( + @TestParameter CseTestCase cseTestCase, @TestParameter CseTestOptimizer cseTestOptimizer) + throws Exception { + skipBaselineVerification(); + if (runtimeFlavor.equals(CelRuntimeFlavor.LEGACY)) { + return; + } + CelAbstractSyntaxTree ast = cel.compile(cseTestCase.source).getAst(); + ImmutableMap inputMap = + ImmutableMap.of("msg", TEST_ALL_TYPES_INPUT, "x", 5L, "y", 6L, "opt_x", Optional.of(5L)); + Object expectedEvalResult = cel.createProgram(ast).eval(inputMap); + + CelAbstractSyntaxTree optimizedAst = cseTestOptimizer.newCseOptimizer(cel).optimize(ast); + CelAbstractSyntaxTree parsedOnlyOptimizedAst = + CelAbstractSyntaxTree.newParsedAst(optimizedAst.getExpr(), optimizedAst.getSource()); + + Object optimizedEvalResult = cel.createProgram(parsedOnlyOptimizedAst).eval(inputMap); + assertThat(optimizedEvalResult).isEqualTo(expectedEvalResult); + } + + @Test + public void subexpression_unparsed() throws Exception { + for (CseTestCase cseTestCase : EnumSet.allOf(CseTestCase.class)) { + testOutput().println("Test case: " + cseTestCase.name()); + testOutput().println("Source: " + cseTestCase.source); + testOutput().println("=====>"); + CelAbstractSyntaxTree ast = cel.compile(cseTestCase.source).getAst(); + boolean resultPrinted = false; + for (CseTestOptimizer cseTestOptimizer : CseTestOptimizer.values()) { + String optimizerName = cseTestOptimizer.name(); + CelAbstractSyntaxTree optimizedAst; + try { + optimizedAst = cseTestOptimizer.newCseOptimizer(cel).optimize(ast); + } catch (Exception e) { + testOutput().printf("[%s]: Optimization Error: %s", optimizerName, e); + continue; + } + if (!resultPrinted) { + Object optimizedEvalResult = + cel.createProgram(optimizedAst) + .eval( + ImmutableMap.of( + "msg", TEST_ALL_TYPES_INPUT, "x", 5L, "y", 6L, "opt_x", Optional.of(5L))); + testOutput().println("Result: " + optimizedEvalResult); + resultPrinted = true; + } + try { + testOutput().printf("[%s]: %s", optimizerName, CEL_UNPARSER.unparse(optimizedAst)); + } catch (RuntimeException e) { + testOutput().printf("[%s]: Unparse Error: %s", optimizerName, e); + } + testOutput().println(); + } + testOutput().println(); + } + } + + @Test + public void constfold_before_subexpression_unparsed() throws Exception { + for (CseTestCase cseTestCase : EnumSet.allOf(CseTestCase.class)) { + testOutput().println("Test case: " + cseTestCase.name()); + testOutput().println("Source: " + cseTestCase.source); + testOutput().println("=====>"); + CelAbstractSyntaxTree ast = cel.compile(cseTestCase.source).getAst(); + boolean resultPrinted = false; + for (CseTestOptimizer cseTestOptimizer : EnumSet.allOf(CseTestOptimizer.class)) { + String optimizerName = cseTestOptimizer.name(); + CelAbstractSyntaxTree optimizedAst = + cseTestOptimizer.newCseWithConstFoldingOptimizer(cel).optimize(ast); + if (!resultPrinted) { + Object optimizedEvalResult = + cel.createProgram(optimizedAst) + .eval( + ImmutableMap.of( + "msg", TEST_ALL_TYPES_INPUT, "x", 5L, "y", 6L, "opt_x", Optional.of(5L))); + testOutput().println("Result: " + optimizedEvalResult); + resultPrinted = true; + } + try { + testOutput().printf("[%s]: %s", optimizerName, CEL_UNPARSER.unparse(optimizedAst)); + } catch (RuntimeException e) { + testOutput().printf("[%s]: Unparse Error: %s", optimizerName, e); + } + testOutput().println(); + } + testOutput().println(); + } + } + + @Test + public void subexpression_ast(@TestParameter CseTestOptimizer cseTestOptimizer) throws Exception { + String testBasefileName = "subexpression_ast_" + Ascii.toLowerCase(cseTestOptimizer.name()); + overriddenBaseFilePath = String.format("%s%s.baseline", testdataDir(), testBasefileName); + for (CseTestCase cseTestCase : EnumSet.allOf(CseTestCase.class)) { + testOutput().println("Test case: " + cseTestCase.name()); + testOutput().println("Source: " + cseTestCase.source); + testOutput().println("=====>"); + CelAbstractSyntaxTree ast = cel.compile(cseTestCase.source).getAst(); + CelAbstractSyntaxTree optimizedAst = + newCseOptimizer(cel, cseTestOptimizer.option).optimize(ast); + testOutput().println(optimizedAst.getExpr()); + } + } + + @Test + public void large_expressions_block_common_subexpr() throws Exception { + CelOptimizer celOptimizer = + newCseOptimizer( + cel, SubexpressionOptimizerOptions.newBuilder().populateMacroCalls(true).build()); + + runLargeTestCases(celOptimizer); + } + + @Test + public void large_expressions_block_recursion_depth_1() throws Exception { + CelOptimizer celOptimizer = + newCseOptimizer( + cel, + SubexpressionOptimizerOptions.newBuilder() + .populateMacroCalls(true) + .subexpressionMaxRecursionDepth(1) + .build()); + + runLargeTestCases(celOptimizer); + } + + @Test + public void large_expressions_block_recursion_depth_2() throws Exception { + CelOptimizer celOptimizer = + newCseOptimizer( + cel, + SubexpressionOptimizerOptions.newBuilder() + .populateMacroCalls(true) + .subexpressionMaxRecursionDepth(2) + .build()); + + runLargeTestCases(celOptimizer); + } + + @Test + public void large_expressions_block_recursion_depth_3() throws Exception { + CelOptimizer celOptimizer = + newCseOptimizer( + cel, + SubexpressionOptimizerOptions.newBuilder() + .populateMacroCalls(true) + .subexpressionMaxRecursionDepth(3) + .build()); + + runLargeTestCases(celOptimizer); + } + + private void runLargeTestCases(CelOptimizer celOptimizer) throws Exception { + for (CseLargeTestCase cseTestCase : EnumSet.allOf(CseLargeTestCase.class)) { + testOutput().println("Test case: " + cseTestCase.name()); + testOutput().println("Source: " + cseTestCase.source); + testOutput().println("=====>"); + CelAbstractSyntaxTree ast = cel.compile(cseTestCase.source).getAst(); + CelAbstractSyntaxTree optimizedAst = celOptimizer.optimize(ast); + Object optimizedEvalResult = + cel.createProgram(optimizedAst) + .eval( + ImmutableMap.of("msg", TEST_ALL_TYPES_INPUT, "x", 5L, "opt_x", Optional.of(5L))); + testOutput().println("Result: " + optimizedEvalResult); + try { + testOutput().printf("Unparsed: %s", CEL_UNPARSER.unparse(optimizedAst)); + } catch (RuntimeException e) { + testOutput().printf("Unparse Error: %s", e); + } + testOutput().println(); + testOutput().println(); + } + } + + private static CelOptimizer newCseOptimizer(Cel cel, SubexpressionOptimizerOptions options) { + return CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers(SubexpressionOptimizer.newInstance(options)) + .build(); + } + + @SuppressWarnings("Immutable") // Test only + private enum CseTestOptimizer { + BLOCK_COMMON_SUBEXPR_ONLY(OPTIMIZER_COMMON_OPTIONS), + BLOCK_RECURSION_DEPTH_1( + OPTIMIZER_COMMON_OPTIONS.toBuilder().subexpressionMaxRecursionDepth(1).build()), + BLOCK_RECURSION_DEPTH_2( + OPTIMIZER_COMMON_OPTIONS.toBuilder().subexpressionMaxRecursionDepth(2).build()), + BLOCK_RECURSION_DEPTH_3( + OPTIMIZER_COMMON_OPTIONS.toBuilder().subexpressionMaxRecursionDepth(3).build()), + BLOCK_RECURSION_DEPTH_4( + OPTIMIZER_COMMON_OPTIONS.toBuilder().subexpressionMaxRecursionDepth(4).build()), + BLOCK_RECURSION_DEPTH_5( + OPTIMIZER_COMMON_OPTIONS.toBuilder().subexpressionMaxRecursionDepth(5).build()), + BLOCK_RECURSION_DEPTH_6( + OPTIMIZER_COMMON_OPTIONS.toBuilder().subexpressionMaxRecursionDepth(6).build()), + BLOCK_RECURSION_DEPTH_7( + OPTIMIZER_COMMON_OPTIONS.toBuilder().subexpressionMaxRecursionDepth(7).build()), + BLOCK_RECURSION_DEPTH_8( + OPTIMIZER_COMMON_OPTIONS.toBuilder().subexpressionMaxRecursionDepth(8).build()), + BLOCK_RECURSION_DEPTH_9( + OPTIMIZER_COMMON_OPTIONS.toBuilder().subexpressionMaxRecursionDepth(9).build()); + + private final SubexpressionOptimizerOptions option; + + CseTestOptimizer(SubexpressionOptimizerOptions option) { + this.option = option; + } + + // Defers building the optimizer until the test runs + private CelOptimizer newCseOptimizer(Cel cel) { + return SubexpressionOptimizerBaselineTest.newCseOptimizer(cel, option); + } + + // Defers building the optimizer until the test runs + private CelOptimizer newCseWithConstFoldingOptimizer(Cel cel) { + return CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers( + ConstantFoldingOptimizer.getInstance(), SubexpressionOptimizer.newInstance(option)) + .build(); + } + } + + private enum CseTestCase { + SIZE_1("size([1,2]) + size([1,2]) + 1 == 5"), + SIZE_2("2 + size([1,2]) + size([1,2]) + 1 == 7"), + SIZE_3("size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6"), + SIZE_4( + "5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + " + + "size([1,2,3]) + size([1,2,3]) == 17"), + TIMESTAMP( + "timestamp(int(timestamp(1000000000))).getFullYear() +" + + " timestamp(int(timestamp(75))).getFullYear() + " + + " timestamp(int(timestamp(50))).getFullYear() + " + + " timestamp(int(timestamp(1000000000))).getFullYear() + " + + " timestamp(int(timestamp(50))).getSeconds() + " + + " timestamp(int(timestamp(200))).getFullYear() + " + + " timestamp(int(timestamp(200))).getFullYear() + " + + " timestamp(int(timestamp(75))).getMinutes() + " + + " timestamp(int(timestamp(1000000000))).getFullYear() == 13934"), + MAP_INDEX("{\"a\": 2}[\"a\"] + {\"a\": 2}[\"a\"] * {\"a\": 2}[\"a\"] == 6"), + /** + * Input map is: + * + * 

{@code
+     * {
+     *    "a": { "b": 1 },
+     *    "c": { "b": 1 },
+     *    "d": {
+     *       "e": { "b": 1 }
+     *    },
+     *    "e":{
+     *       "e": { "b": 1 }
+     *    }
+     * }
+     * }
+ */ + NESTED_MAP_CONSTRUCTION( + "{'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}}"), + NESTED_LIST_CONSTRUCTION( + "[1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]]"), + SELECT("msg.single_int64 + msg.single_int64 == 6"), + SELECT_NESTED_1( + "msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + " + + "msg.oneof_type.payload.single_int64 + " + + "msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31"), + SELECT_NESTED_2( + "true ||" + + " msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool" + + " || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool"), + SELECT_NESTED_MESSAGE_MAP_INDEX_1( + "msg.oneof_type.payload.map_int32_int64[1] + " + + "msg.oneof_type.payload.map_int32_int64[1] + " + + "msg.oneof_type.payload.map_int32_int64[1] == 15"), + SELECT_NESTED_MESSAGE_MAP_INDEX_2( + "msg.oneof_type.payload.map_int32_int64[0] + " + + "msg.oneof_type.payload.map_int32_int64[1] + " + + "msg.oneof_type.payload.map_int32_int64[2] == 8"), + SELECT_NESTED_NO_COMMON_SUBEXPR( + "msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64"), + TERNARY("(msg.single_int64 > 0 ? msg.single_int64 : 0) == 3"), + TERNARY_BIND_RHS_ONLY( + "false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11"), + NESTED_TERNARY( + "(msg.single_int64 > 0 ? (msg.single_int32 > 0 ? " + + "msg.single_int64 + msg.single_int32 : 0) : 0) == 8"), + MULTIPLE_MACROS_1( + // Note that all of these have different iteration variables, but they are still logically + // the same. + "size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + " + + "size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4"), + MULTIPLE_MACROS_2( + "[[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] +" + + " [['a'].exists(l, l == 'a')] == [true, true, true, true]"), + MULTIPLE_MACROS_3( + "[1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l >" + + " 1)"), + MULTIPLE_MACROS_COMP_V2_1( + // Note that all of these have different iteration variables, but they are still logically + // the same. + "size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + " + + "size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) " + + " == 4"), + MULTIPLE_MACROS_COMP_V2_2( + "[1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && " + + "[1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0)"), + NESTED_MACROS("[1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]]"), + NESTED_MACROS_2("[1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]]"), + NESTED_MACROS_3("[1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2)"), + NESTED_MACROS_COMP_V2_1( + "[1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == " + + "[[2, 4, 6], [2, 4, 6], [2, 4, 6]]"), + NESTED_MACROS_COMP_V2_2( + "[1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]]"), + ADJACENT_NESTED_MACROS( + "[1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1))"), + ADJACENT_NESTED_MACROS_COMP_V2( + "[1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) ==" + + " [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1))"), + INCLUSION_LIST("1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3]"), + INCLUSION_MAP("2 in {'a': 1, 2: {true: false}, 3: {true: false}}"), + MACRO_ITER_VAR_NOT_REFERENCED( + "[1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]]"), + MACRO_ITER_VAR2_NOT_REFERENCED( + "[1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == " + + "[[[3, 4], [3, 4]], [[3, 4], [3, 4]]]"), + MACRO_SHADOWED_VARIABLE("[x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3"), + MACRO_SHADOWED_VARIABLE_2("[\"foo\", \"bar\"].map(x, [x + x, x + x]).map(x, [x + x, x + x])"), + MACRO_SHADOWED_VARIABLE_COMP_V2_1( + "[x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3"), + MACRO_SHADOWED_VARIABLE_COMP_V2_2( + "[\"foo\", \"bar\"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y])"), + PRESENCE_TEST("has({'a': true}.a) && {'a':true}['a']"), + PRESENCE_TEST_2("has({'a': true}.a) && has({'a': true}.a)"), + PRESENCE_TEST_WITH_TERNARY( + "(has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10"), + PRESENCE_TEST_WITH_TERNARY_2( + "(has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 :" + + " msg.oneof_type.payload.single_int64 * 0) == 10"), + PRESENCE_TEST_WITH_TERNARY_3( + "(has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 :" + + " msg.oneof_type.payload.single_int64 * 0) == 10"), + /** + * Input: + * + * 
{@code
+     * (
+     *   has(msg.oneof_type) &&
+     *   has(msg.oneof_type.payload) &&
+     *   has(msg.oneof_type.payload.single_int64)
+     * ) ?
+     *   (
+     *     (
+     *       has(msg.oneof_type.payload.map_string_string) &&
+     *       has(msg.oneof_type.payload.map_string_string.key)
+     *     ) ?
+     *       msg.oneof_type.payload.map_string_string.key == "A"
+     *     : false
+     *   )
+     * : false
+     * }
+ */ + PRESENCE_TEST_WITH_TERNARY_NESTED( + "(has(msg.oneof_type) && has(msg.oneof_type.payload) &&" + + " has(msg.oneof_type.payload.single_int64)) ?" + + " ((has(msg.oneof_type.payload.map_string_string) &&" + + " has(msg.oneof_type.payload.map_string_string.key)) ?" + + " msg.oneof_type.payload.map_string_string.key == 'A' : false) : false"), + OPTIONAL_LIST( + "[10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10," + + " [5], [5]]"), + OPTIONAL_MAP( + "{?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] ==" + + " 'hellohello'"), + OPTIONAL_MAP_CHAINED( + "{?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key':" + + " 'test'}['key']) == 'test'"), + OPTIONAL_MESSAGE( + "TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32:" + + " optional.of(4)}.single_int32 + TestAllTypes{?single_int64:" + + " optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5"), + CALL("('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o')"), + CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR("'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o')"), + CALL_TARGET_NESTED_NO_COMMON_SUBEXPR( + "('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello')"), + CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR( + "('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd')"), + CUSTOM_FUNCTION_INELIMINABLE( + "non_pure_custom_func(msg.oneof_type.payload.single_int64) +" + + " non_pure_custom_func(msg.oneof_type.payload.single_int32) +" + + " non_pure_custom_func(msg.oneof_type.payload.single_int64) +" + + " non_pure_custom_func(msg.single_int64)"), + CUSTOM_FUNCTION_ELIMINABLE( + "pure_custom_func(msg.oneof_type.payload.single_int64) +" + + " pure_custom_func(msg.oneof_type.payload.single_int32) +" + + " pure_custom_func(msg.oneof_type.payload.single_int64) +" + + " pure_custom_func(msg.single_int64)"); + private final String source; + + CseTestCase(String source) { + this.source = source; + } + } + + private enum CseLargeTestCase { + CALC_FOUR_COMMON_SUBEXPR( + "[1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] +" + + " [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] +" + + " [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] +" + + " [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2]" + + " + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] +" + + " [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] +" + + " [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2]" + + " + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] +" + + " [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] +" + + " [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2]" + + " + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] +" + + " [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] +" + + " [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2]" + + " + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] +" + + " [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] +" + + " [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2]" + + " + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] +" + + " [1,2,3,4]"), + CALC_ALL_COMMON_SUBEXPR( + "[0, 1] + [0, 1] + [1, 2] + [1, 2] + [2, 3] + [2, 3] + [3, 4] + [3, 4] + [4, 5] + [4, 5] +" + + " [5, 6] + [5, 6] + [6, 7] + [6, 7] + [7, 8] + [7, 8] + [8, 9] + [8, 9] + [9, 10] +" + + " [9, 10] + [10, 11] + [10, 11] + [11, 12] + [11, 12] + [12, 13] + [12, 13] + [13," + + " 14] + [13, 14] + [14, 15] + [14, 15] + [15, 16] + [15, 16] + [16, 17] + [16, 17] +" + + " [17, 18] + [17, 18] + [18, 19] + [18, 19] + [19, 20] + [19, 20] + [20, 21] + [20," + + " 21] + [21, 22] + [21, 22] + [22, 23] + [22, 23] + [23, 24] + [23, 24] + [24, 25] +" + + " [24, 25] + [25, 26] + [25, 26] + [26, 27] + [26, 27] + [27, 28] + [27, 28] + [28," + + " 29] + [28, 29] + [29, 30] + [29, 30] + [30, 31] + [30, 31] + [31, 32] + [31, 32] +" + + " [32, 33] + [32, 33] + [33, 34] + [33, 34] + [34, 35] + [34, 35] + [35, 36] + [35," + + " 36] + [36, 37] + [36, 37] + [37, 38] + [37, 38] + [38, 39] + [38, 39] + [39, 40] +" + + " [39, 40] + [40, 41] + [40, 41] + [41, 42] + [41, 42] + [42, 43] + [42, 43] + [43," + + " 44] + [43, 44] + [44, 45] + [44, 45] + [45, 46] + [45, 46] + [46, 47] + [46, 47] +" + + " [47, 48] + [47, 48] + [48, 49] + [48, 49] + [49, 50] + [49, 50]"), + NESTED_MACROS( + "[1,2,3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i," + + " [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3]))))))))"); + ; + + private final String source; + + CseLargeTestCase(String source) { + this.source = source; + } + } +} diff --git a/optimizer/src/test/java/dev/cel/optimizer/optimizers/SubexpressionOptimizerTest.java b/optimizer/src/test/java/dev/cel/optimizer/optimizers/SubexpressionOptimizerTest.java new file mode 100644 index 000000000..e7387d7d8 --- /dev/null +++ b/optimizer/src/test/java/dev/cel/optimizer/optimizers/SubexpressionOptimizerTest.java @@ -0,0 +1,729 @@ +// Copyright 2024 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.optimizer.optimizers; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; +import static org.junit.Assert.assertThrows; + +import com.google.common.base.VerifyException; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelBuilder; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelMutableAst; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelSource.Extension; +import dev.cel.common.CelSource.Extension.Component; +import dev.cel.common.CelSource.Extension.Version; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelVarDecl; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.navigation.CelNavigableMutableAst; +import dev.cel.common.navigation.CelNavigableMutableExpr; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelExtensions; +import dev.cel.optimizer.CelOptimizationException; +import dev.cel.optimizer.CelOptimizer; +import dev.cel.optimizer.CelOptimizerFactory; +import dev.cel.optimizer.optimizers.SubexpressionOptimizer.SubexpressionOptimizerOptions; +import dev.cel.parser.CelStandardMacro; +import dev.cel.parser.CelUnparser; +import dev.cel.parser.CelUnparserFactory; +import dev.cel.runtime.CelAttributePattern; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.runtime.CelUnknownSet; +import dev.cel.runtime.PartialVars; +import dev.cel.runtime.Program; +import dev.cel.testing.CelRuntimeFlavor; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class SubexpressionOptimizerTest { + + private static Cel setupCelEnv(CelBuilder celBuilder) { + return celBuilder + .addMessageTypes(TestAllTypes.getDescriptor()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setOptions( + CelOptions.current() + .populateMacroCalls(true) + .enableHeterogeneousNumericComparisons(true) + .build()) + .addCompilerLibraries(CelExtensions.bindings(), CelExtensions.strings()) + .addRuntimeLibraries(CelExtensions.strings()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "non_pure_custom_func", + newGlobalOverload("non_pure_custom_func_overload", SimpleType.INT, SimpleType.INT))) + .addVar("x", SimpleType.DYN) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + } + + private static Cel setupCelForEvaluatingBlock(CelBuilder celBuilder) { + return celBuilder + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addFunctionDeclarations( + // These are test only declarations, as the actual function is made internal using @ + // symbol. + // If the main function declaration needs updating, be sure to update the test + // declaration as well. + CelFunctionDecl.newFunctionDeclaration( + "cel.block", + CelOverloadDecl.newGlobalOverload( + "block_test_only_overload", + SimpleType.DYN, + ListType.create(SimpleType.DYN), + SimpleType.DYN)), + SubexpressionOptimizer.newCelBlockFunctionDecl(SimpleType.DYN), + CelFunctionDecl.newFunctionDeclaration( + "get_true", + CelOverloadDecl.newGlobalOverload("get_true_overload", SimpleType.BOOL))) + // Similarly, this is a test only decl (index0 -> @index0) + .addVarDeclarations( + CelVarDecl.newVarDeclaration("c0", SimpleType.DYN), + CelVarDecl.newVarDeclaration("c1", SimpleType.DYN), + CelVarDecl.newVarDeclaration("index0", SimpleType.DYN), + CelVarDecl.newVarDeclaration("index1", SimpleType.DYN), + CelVarDecl.newVarDeclaration("index2", SimpleType.DYN), + CelVarDecl.newVarDeclaration("@index0", SimpleType.DYN), + CelVarDecl.newVarDeclaration("@index1", SimpleType.DYN), + CelVarDecl.newVarDeclaration("@index2", SimpleType.DYN)) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .build(); + } + + @TestParameter CelRuntimeFlavor runtimeFlavor; + + private Cel cel; + private Cel celForEvaluatingBlock; + + @Before + public void setUp() { + this.cel = setupCelEnv(runtimeFlavor.builder()); + this.celForEvaluatingBlock = setupCelForEvaluatingBlock(runtimeFlavor.builder()); + } + + private static final CelUnparser CEL_UNPARSER = CelUnparserFactory.newUnparser(); + + private static CelBuilder newCelBuilder() { + return CelFactory.standardCelBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .setOptions(CelOptions.current().populateMacroCalls(true).build()) + .addCompilerLibraries(CelExtensions.bindings()) + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "non_pure_custom_func", + newGlobalOverload("non_pure_custom_func_overload", SimpleType.INT, SimpleType.INT))) + .addVar("x", SimpleType.DYN) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + } + + private CelOptimizer newCseOptimizer(SubexpressionOptimizerOptions options) { + return CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers(SubexpressionOptimizer.newInstance(options)) + .build(); + } + + @Test + public void cse_resultTypeSet_celBlockOptimizationSuccess() throws Exception { + Cel cel = newCelBuilder().setResultType(SimpleType.BOOL).build(); + CelOptimizer celOptimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers( + SubexpressionOptimizer.newInstance( + SubexpressionOptimizerOptions.newBuilder().build())) + .build(); + CelAbstractSyntaxTree ast = cel.compile("size('a') + size('a') == 2").getAst(); + + CelAbstractSyntaxTree optimizedAst = celOptimizer.optimize(ast); + + assertThat(cel.createProgram(optimizedAst).eval()).isEqualTo(true); + assertThat(CEL_UNPARSER.unparse(optimizedAst)) + .isEqualTo("cel.@block([size(\"a\")], @index0 + @index0 == 2)"); + } + + @Test + public void cse_indexEvaluationErrors_throws() throws Exception { + CelAbstractSyntaxTree ast = cel.compile("\"abc\".charAt(10) + \"abc\".charAt(10)").getAst(); + CelOptimizer optimizedOptimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers(SubexpressionOptimizer.getInstance()) + .build(); + + CelAbstractSyntaxTree optimizedAst = optimizedOptimizer.optimize(ast); + + String unparsed = CEL_UNPARSER.unparse(optimizedAst); + assertThat(unparsed).isEqualTo("cel.@block([\"abc\".charAt(10)], @index0 + @index0)"); + + Program program = cel.createProgram(optimizedAst); + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> program.eval(ImmutableMap.of())); + assertThat(e).hasMessageThat().contains("charAt failure: Index out of range: 10"); + } + + @Test + public void cse_withUnknownAttributes() throws Exception { + CelAbstractSyntaxTree ast = cel.compile("size(\"a\") == 1 ? x.y : x.y").getAst(); + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers(SubexpressionOptimizer.getInstance()) + .build(); + + CelAbstractSyntaxTree optimizedAst = optimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)) + .isEqualTo("cel.@block([x.y], (size(\"a\") == 1) ? @index0 : @index0)"); + + Object result = + cel.createProgram(optimizedAst) + .eval(PartialVars.of(CelAttributePattern.fromQualifiedIdentifier("x"))); + assertThat(result).isInstanceOf(CelUnknownSet.class); + } + + private enum CseNoOpTestCase { + // Nothing to optimize + NO_COMMON_SUBEXPR("size(\"hello\")"), + // Constants and identifiers + INT_CONST_ONLY("2 + 2 + 2 + 2"), + IDENT_ONLY("x + x + x + x"), + BOOL_CONST_ONLY("true == true && false == false"), + // Constants and identifiers within a function + CONST_WITHIN_FUNCTION("size(\"hello\" + \"hello\" + \"hello\")"), + IDENT_WITHIN_FUNCTION("string(x + x + x)"), + // Non-standard functions that have not been explicitly added as a candidate are not + // optimized. + NON_STANDARD_FUNCTION_1("non_pure_custom_func(1) + non_pure_custom_func(1)"), + NON_STANDARD_FUNCTION_2("1 + non_pure_custom_func(1) + 1 + non_pure_custom_func(1)"), + // Duplicated but nested calls. + NESTED_FUNCTION("int(timestamp(int(timestamp(1000000000))))"), + // This cannot be optimized. Extracting the common subexpression would presence test + // the bound identifier (e.g: has(@r0)), which is not valid. + UNOPTIMIZABLE_TERNARY("has(msg.single_any) ? msg.single_any : 10"), + MACRO("[1, 2, 3].exists(x, x > 0)"); + + private final String source; + + CseNoOpTestCase(String source) { + this.source = source; + } + } + + @Test + public void cse_withCelBind_noop(@TestParameter CseNoOpTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(testCase.source).getAst(); + + CelAbstractSyntaxTree optimizedAst = + newCseOptimizer(SubexpressionOptimizerOptions.newBuilder().populateMacroCalls(true).build()) + .optimize(ast); + + assertThat(ast.getExpr()).isEqualTo(optimizedAst.getExpr()); + assertThat(CEL_UNPARSER.unparse(optimizedAst)).isEqualTo(testCase.source); + } + + @Test + public void cse_withCelBlock_noop(@TestParameter CseNoOpTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = cel.compile(testCase.source).getAst(); + + CelAbstractSyntaxTree optimizedAst = + newCseOptimizer(SubexpressionOptimizerOptions.newBuilder().populateMacroCalls(true).build()) + .optimize(ast); + + assertThat(ast.getExpr()).isEqualTo(optimizedAst.getExpr()); + assertThat(CEL_UNPARSER.unparse(optimizedAst)).isEqualTo(testCase.source); + } + + @Test + public void cse_withComprehensionStructureRetained() throws Exception { + CelAbstractSyntaxTree ast = + cel.compile("['foo'].map(x, [x+x]) + ['foo'].map(x, [x+x, x+x])").getAst(); + CelOptimizer celOptimizer = + newCseOptimizer( + SubexpressionOptimizerOptions.newBuilder().populateMacroCalls(true).build()); + + CelAbstractSyntaxTree optimizedAst = celOptimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)) + .isEqualTo( + "cel.@block([[\"foo\"]], @index0.map(@it:0:0, [@it:0:0 + @it:0:0]) +" + + " @index0.map(@it:0:0, [@it:0:0 + @it:0:0, @it:0:0 + @it:0:0]))"); + } + + @Test + public void cse_applyConstFoldingBefore() throws Exception { + CelAbstractSyntaxTree ast = + cel.compile("size([1+1+1]) + size([1+1+1]) + size([1,1+1+1]) + size([1,1+1+1]) + x") + .getAst(); + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers( + ConstantFoldingOptimizer.getInstance(), + SubexpressionOptimizer.newInstance( + SubexpressionOptimizerOptions.newBuilder().build())) + .build(); + + CelAbstractSyntaxTree optimizedAst = optimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)).isEqualTo("6 + x"); + } + + @Test + public void cse_applyConstFoldingAfter() throws Exception { + CelAbstractSyntaxTree ast = + cel.compile("size([1+1+1]) + size([1+1+1]) + size([1,1+1+1]) + size([1,1+1+1]) + x") + .getAst(); + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers( + SubexpressionOptimizer.newInstance( + SubexpressionOptimizerOptions.newBuilder().build()), + ConstantFoldingOptimizer.getInstance()) + .build(); + + CelAbstractSyntaxTree optimizedAst = optimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)) + .isEqualTo("cel.@block([1, 2], @index0 + @index0 + @index1 + @index1 + x)"); + } + + @Test + public void cse_applyConstFoldingAfter_nothingToFold() throws Exception { + CelAbstractSyntaxTree ast = cel.compile("size(x) + size(x)").getAst(); + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers( + SubexpressionOptimizer.newInstance( + SubexpressionOptimizerOptions.newBuilder().populateMacroCalls(true).build()), + ConstantFoldingOptimizer.getInstance()) + .build(); + + CelAbstractSyntaxTree optimizedAst = optimizer.optimize(ast); + + assertThat(CEL_UNPARSER.unparse(optimizedAst)) + .isEqualTo("cel.@block([size(x)], @index0 + @index0)"); + } + + @Test + public void iterationLimitReached_throws() throws Exception { + StringBuilder largeExprBuilder = new StringBuilder(); + int iterationLimit = 100; + for (int i = 0; i < iterationLimit; i++) { + largeExprBuilder.append("[1,2]"); + if (i < iterationLimit - 1) { + largeExprBuilder.append("+"); + } + } + CelAbstractSyntaxTree ast = cel.compile(largeExprBuilder.toString()).getAst(); + + CelOptimizationException e = + assertThrows( + CelOptimizationException.class, + () -> + newCseOptimizer( + SubexpressionOptimizerOptions.newBuilder() + .iterationLimit(iterationLimit) + .build()) + .optimize(ast)); + assertThat(e).hasMessageThat().isEqualTo("Optimization failure: Max iteration count reached."); + } + + @Test + public void celBlock_astExtensionTagged() throws Exception { + CelAbstractSyntaxTree ast = cel.compile("size(x) + size(x)").getAst(); + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers( + SubexpressionOptimizer.newInstance( + SubexpressionOptimizerOptions.newBuilder().populateMacroCalls(true).build()), + ConstantFoldingOptimizer.getInstance()) + .build(); + + CelAbstractSyntaxTree optimizedAst = optimizer.optimize(ast); + + assertThat(optimizedAst.getSource().getExtensions()) + .containsExactly( + Extension.create("cel_block", Version.of(1L, 1L), Component.COMPONENT_RUNTIME)); + } + + private enum BlockTestCase { + BOOL_LITERAL("cel.block([true, false], index0 || index1)"), + STRING_CONCAT("cel.block(['a' + 'b', index0 + 'c'], index1 + 'd') == 'abcd'"), + + BLOCK_WITH_EXISTS_TRUE("cel.block([[1, 2, 3], [3, 4, 5].exists(e, e in index0)], index1)"), + BLOCK_WITH_EXISTS_FALSE("cel.block([[1, 2, 3], ![4, 5].exists(e, e in index0)], index1)"), + ; + + private final String source; + + BlockTestCase(String source) { + this.source = source; + } + } + + @Test + public void block_success(@TestParameter BlockTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = compileUsingInternalFunctions(testCase.source); + + Object evaluatedResult = celForEvaluatingBlock.createProgram(ast).eval(); + + assertThat(evaluatedResult).isNotNull(); + } + + @Test + public void block_success_parsedOnly(@TestParameter BlockTestCase testCase) throws Exception { + if (runtimeFlavor.equals(CelRuntimeFlavor.LEGACY)) { + return; + } + CelAbstractSyntaxTree ast = + compileUsingInternalFunctions(testCase.source, /* parsedOnly= */ true); + + Object evaluatedResult = celForEvaluatingBlock.createProgram(ast).eval(); + + assertThat(evaluatedResult).isNotNull(); + } + + @Test + @SuppressWarnings("Immutable") // Test only + public void lazyEval_blockIndexNeverReferenced() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addFunctionBindings( + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + })) + .build(); + CelAbstractSyntaxTree ast = + compileUsingInternalFunctions( + "cel.block([get_true()], has(msg.single_int64) ? index0 : false)"); + + boolean result = + (boolean) + celRuntime + .createProgram(ast) + .eval(ImmutableMap.of("msg", TestAllTypes.getDefaultInstance())); + + assertThat(result).isFalse(); + assertThat(invocation.get()).isEqualTo(0); + } + + @Test + @SuppressWarnings("Immutable") // Test only + public void lazyEval_blockIndexEvaluatedOnlyOnce() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addFunctionBindings( + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + })) + .build(); + CelAbstractSyntaxTree ast = + compileUsingInternalFunctions("cel.block([get_true()], index0 && index0 && index0)"); + + boolean result = (boolean) celRuntime.createProgram(ast).eval(); + + assertThat(result).isTrue(); + assertThat(invocation.get()).isEqualTo(1); + } + + @Test + @SuppressWarnings({"Immutable", "unchecked"}) // Test only + public void lazyEval_withinComprehension_blockIndexEvaluatedOnlyOnce() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addFunctionBindings( + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + })) + .build(); + CelAbstractSyntaxTree ast = + compileUsingInternalFunctions("cel.block([get_true()], [1,2,3].map(x, x < 0 || index0))"); + + List result = (List) celRuntime.createProgram(ast).eval(); + + assertThat(result).containsExactly(true, true, true); + assertThat(invocation.get()).isEqualTo(1); + } + + @Test + @SuppressWarnings("Immutable") // Test only + public void lazyEval_multipleBlockIndices_inResultExpr() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addFunctionBindings( + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + })) + .build(); + CelAbstractSyntaxTree ast = + compileUsingInternalFunctions( + "cel.block([get_true(), get_true(), get_true()], index0 && index0 && index1 && index1" + + " && index2 && index2)"); + + boolean result = (boolean) celRuntime.createProgram(ast).eval(); + + assertThat(result).isTrue(); + assertThat(invocation.get()).isEqualTo(3); + } + + @Test + @SuppressWarnings("Immutable") // Test only + public void lazyEval_multipleBlockIndices_cascaded() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addFunctionBindings( + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + })) + .build(); + CelAbstractSyntaxTree ast = + compileUsingInternalFunctions("cel.block([get_true(), index0, index1], index2)"); + + boolean result = (boolean) celRuntime.createProgram(ast).eval(); + + assertThat(result).isTrue(); + assertThat(invocation.get()).isEqualTo(1); + } + + @Test + @SuppressWarnings("Immutable") // Test only + public void lazyEval_nestedComprehension_indexReferencedInNestedScopes() throws Exception { + AtomicInteger invocation = new AtomicInteger(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addFunctionBindings( + CelFunctionBinding.from( + "get_true_overload", + ImmutableList.of(), + arg -> { + invocation.getAndIncrement(); + return true; + })) + .build(); + // Equivalent of [true, false, true].map(c0, [c0].map(c1, [c0, c1, true])) + CelAbstractSyntaxTree ast = + compileUsingInternalFunctions( + "cel.block([true, false, get_true()], [index2, false, index2].map(c0, [c0].map(c1, [c0," + + " c1, index2]))) == [[[true, true, true]], [[false, false, true]], [[true, true," + + " true]]]"); + + boolean result = (boolean) celRuntime.createProgram(ast).eval(); + + assertThat(result).isTrue(); + // Even though the function get_true() is referenced across different comprehension scopes, + // it still gets memoized only once. + assertThat(invocation.get()).isEqualTo(1); + } + + @Test + @TestParameters("{source: 'cel.block([])'}") + @TestParameters("{source: 'cel.block([1])'}") + @TestParameters("{source: 'cel.block(1, 2)'}") + @TestParameters("{source: 'cel.block(1, [1])'}") + public void block_invalidArguments_throws(String source) { + CelValidationException e = + assertThrows(CelValidationException.class, () -> compileUsingInternalFunctions(source)); + + assertThat(e).hasMessageThat().contains("found no matching overload for 'cel.block'"); + } + + @Test + public void blockIndex_invalidArgument_throws() { + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> compileUsingInternalFunctions("cel.block([1], index)")); + + assertThat(e).hasMessageThat().contains("undeclared reference"); + } + + @Test + public void verifyOptimizedAstCorrectness_twoCelBlocks_throws() throws Exception { + CelAbstractSyntaxTree ast = + compileUsingInternalFunctions("cel.block([1, 2], cel.block([2], 3))"); + + VerifyException e = + assertThrows( + VerifyException.class, () -> SubexpressionOptimizer.verifyOptimizedAstCorrectness(ast)); + assertThat(e) + .hasMessageThat() + .isEqualTo("Expected 1 cel.block function to be present but found 2"); + } + + @Test + public void verifyOptimizedAstCorrectness_celBlockNotAtRoot_throws() throws Exception { + CelAbstractSyntaxTree ast = compileUsingInternalFunctions("1 + cel.block([1, 2], index0)"); + + VerifyException e = + assertThrows( + VerifyException.class, () -> SubexpressionOptimizer.verifyOptimizedAstCorrectness(ast)); + assertThat(e).hasMessageThat().isEqualTo("Expected cel.block to be present at root"); + } + + @Test + public void verifyOptimizedAstCorrectness_blockContainsNoIndexResult_throws() throws Exception { + CelAbstractSyntaxTree ast = compileUsingInternalFunctions("cel.block([1, index0], 2)"); + + VerifyException e = + assertThrows( + VerifyException.class, () -> SubexpressionOptimizer.verifyOptimizedAstCorrectness(ast)); + assertThat(e) + .hasMessageThat() + .isEqualTo("Expected at least one reference of index in cel.block result"); + } + + @Test + @TestParameters("{source: 'cel.block([], index0)'}") + @TestParameters("{source: 'cel.block([1, 2], index2)'}") + public void verifyOptimizedAstCorrectness_indexOutOfBounds_throws(String source) + throws Exception { + CelAbstractSyntaxTree ast = compileUsingInternalFunctions(source); + + VerifyException e = + assertThrows( + VerifyException.class, () -> SubexpressionOptimizer.verifyOptimizedAstCorrectness(ast)); + assertThat(e) + .hasMessageThat() + .contains("Illegal block index found. The index value must be less than"); + } + + @Test + @TestParameters("{source: 'cel.block([index0], index0)'}") + @TestParameters("{source: 'cel.block([1, index1, 2], index2)'}") + @TestParameters("{source: 'cel.block([1, 2, index2], index2)'}") + @TestParameters("{source: 'cel.block([index2, 1, 2], index2)'}") + public void verifyOptimizedAstCorrectness_indexIsNotForwardReferencing_throws(String source) + throws Exception { + CelAbstractSyntaxTree ast = compileUsingInternalFunctions(source); + + VerifyException e = + assertThrows( + VerifyException.class, () -> SubexpressionOptimizer.verifyOptimizedAstCorrectness(ast)); + assertThat(e) + .hasMessageThat() + .contains("Illegal block index found. The index value must be less than"); + } + + @Test + public void block_containsCycle_throws() throws Exception { + CelAbstractSyntaxTree ast = compileUsingInternalFunctions("cel.block([index1,index0],index0)"); + + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + assertThat(e).hasMessageThat().contains("Cycle detected: @index0"); + } + + @Test + public void block_lazyEvaluationContainsError_cleansUpCycleState() throws Exception { + CelAbstractSyntaxTree ast = + compileUsingInternalFunctions( + "cel.block([1/0 > 0], (index0 && false) || (index0 && true))"); + + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + + assertThat(e).hasMessageThat().contains("/ by zero"); + assertThat(e).hasMessageThat().doesNotContain("Cycle detected"); + } + + /** + * Converts AST containing cel.block related test functions to internal functions (e.g: cel.block + * -> cel.@block) + */ + private CelAbstractSyntaxTree compileUsingInternalFunctions(String expression, boolean parsedOnly) + throws CelValidationException { + CelAbstractSyntaxTree astToModify = celForEvaluatingBlock.compile(expression).getAst(); + CelMutableAst mutableAst = CelMutableAst.fromCelAst(astToModify); + CelNavigableMutableAst.fromAst(mutableAst) + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.CALL)) + .map(CelNavigableMutableExpr::expr) + .filter(expr -> expr.call().function().equals("cel.block")) + .forEach(expr -> expr.call().setFunction("cel.@block")); + + CelNavigableMutableAst.fromAst(mutableAst) + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.IDENT)) + .map(CelNavigableMutableExpr::expr) + .filter(expr -> expr.ident().name().startsWith("index")) + .forEach( + indexExpr -> { + String internalIdentName = "@" + indexExpr.ident().name(); + indexExpr.ident().setName(internalIdentName); + }); + + if (parsedOnly) { + return mutableAst.toParsedAst(); + } + return celForEvaluatingBlock.check(mutableAst.toParsedAst()).getAst(); + } + + private CelAbstractSyntaxTree compileUsingInternalFunctions(String expression) + throws CelValidationException { + return compileUsingInternalFunctions(expression, false); + } +} diff --git a/optimizer/src/test/resources/BUILD.bazel b/optimizer/src/test/resources/BUILD.bazel new file mode 100644 index 000000000..10fb339f9 --- /dev/null +++ b/optimizer/src/test/resources/BUILD.bazel @@ -0,0 +1,15 @@ +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//optimizer:__subpackages__", + ], +) + +filegroup( + name = "baselines", + testonly = True, + srcs = glob(["*.baseline"]), +) diff --git a/optimizer/src/test/resources/constfold_before_subexpression_unparsed.baseline b/optimizer/src/test/resources/constfold_before_subexpression_unparsed.baseline new file mode 100644 index 000000000..9139c7a35 --- /dev/null +++ b/optimizer/src/test/resources/constfold_before_subexpression_unparsed.baseline @@ -0,0 +1,794 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +Result: {a={b=1}, c={b=1}, d={e={b=1}}, e={e={b=1}}} +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([{"b": 1}, {"e": @index0}], {"a": @index0, "c": @index0, "d": @index1, "e": @index1}) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([{"b": 1}, {"e": @index0}], {"a": @index0, "c": @index0, "d": @index1, "e": @index1}) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) + +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +Result: [1, [1, 2, 3, 4], 2, [1, 2, 3, 4], 5, [1, 2, 3, 4], 7, [[1, 2], [1, 2, 3, 4]], [1, 2]] +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2, 3, 4], [1, 2], [@index1, @index0]], [1, @index0, 2, @index0, 5, @index0, 7, @index2, @index1]) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) + +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.single_int64, @index0 + @index0], @index1 == 6) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.single_int64], @index0 + @index0 == 6) + +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload, @index0.single_int64], @index1 + @index0.single_int32 + @index1 + msg.single_int64 + @index0.oneof_type.payload.single_int64 == 31) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64, @index1.single_int32, @index2 + @index3, @index4 + @index2, msg.single_int64, @index5 + @index6, @index1.oneof_type, @index8.payload, @index9.single_int64, @index7 + @index10], @index11 == 31) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.single_int64, @index1 + @index0.single_int32, @index2 + @index1 + msg.single_int64, @index0.oneof_type.payload, @index3 + @index4.single_int64], @index5 == 31) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload, @index0 + @index1.single_int32 + @index0, @index1.oneof_type.payload.single_int64, @index2 + msg.single_int64 + @index3], @index4 == 31) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload, @index0 + @index1.single_int32 + @index0 + msg.single_int64, @index2 + @index1.oneof_type.payload.single_int64], @index3 == 31) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload, @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64], @index2 == 31) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload], @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64 == 31) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload], @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64 == 31) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload], @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64 == 31) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload], @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64 == 31) + +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.map_int32_int64, @index2[1], @index3 + @index3, @index4 + @index3], @index5 == 15) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.map_int32_int64[1], @index1 + @index1 + @index1], @index2 == 15) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.map_int32_int64, @index0[1]], @index1 + @index1 + @index1 == 15) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) + +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.map_int32_int64, @index2[0], @index2[1], @index3 + @index4, @index2[2], @index5 + @index6], @index7 == 8) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.map_int32_int64, @index1[0] + @index1[1], @index2 + @index1[2]], @index3 == 8) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.map_int32_int64, @index0[0] + @index0[1] + @index0[2]], @index1 == 8) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) + +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +Result: 0 +[BLOCK_COMMON_SUBEXPR_ONLY]: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.oneof_type, @index2.payload, @index3.oneof_type, @index4.payload, @index5.oneof_type, @index6.payload], @index7.single_int64) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.oneof_type.payload, @index1.oneof_type.payload, @index2.oneof_type.payload], @index3.single_int64) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.oneof_type, @index0.payload.oneof_type.payload], @index1.oneof_type.payload.single_int64) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.oneof_type.payload, @index0.oneof_type.payload.oneof_type.payload], @index1.single_int64) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type], @index0.payload.oneof_type.payload.single_int64) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type.payload], @index0.oneof_type.payload.single_int64) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type], @index0.payload.single_int64) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload], @index0.single_int64) +[BLOCK_RECURSION_DEPTH_9]: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 + +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.single_int64, @index0 > 0, @index1 ? @index0 : 0], @index2 == 3) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.single_int64, (@index0 > 0) ? @index0 : 0], @index1 == 3) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) + +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.single_int64], @index0 + (@index0 + 1) * 2 == 11) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.single_int64, @index0 + 1, @index1 * 2, @index0 + @index2], @index3 == 11) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.single_int64, (@index0 + 1) * 2], @index0 + @index1 == 11) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.single_int64, @index0 + (@index0 + 1) * 2], @index1 == 11) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.single_int64], @index0 + (@index0 + 1) * 2 == 11) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.single_int64], @index0 + (@index0 + 1) * 2 == 11) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.single_int64], @index0 + (@index0 + 1) * 2 == 11) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.single_int64], @index0 + (@index0 + 1) * 2 == 11) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.single_int64], @index0 + (@index0 + 1) * 2 == 11) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.single_int64], @index0 + (@index0 + 1) * 2 == 11) + +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.single_int64, msg.single_int32, @index0 > 0, @index1 > 0, @index0 + @index1, @index3 ? @index4 : 0, @index2 ? @index5 : 0], @index6 == 8) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.single_int64, msg.single_int32, (@index1 > 0) ? (@index0 + @index1) : 0, (@index0 > 0) ? @index2 : 0], @index3 == 8) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.single_int64, msg.single_int32, (@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0], @index2 == 8) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) + +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +Result: false +[BLOCK_COMMON_SUBEXPR_ONLY]: false +[BLOCK_RECURSION_DEPTH_1]: false +[BLOCK_RECURSION_DEPTH_2]: false +[BLOCK_RECURSION_DEPTH_3]: false +[BLOCK_RECURSION_DEPTH_4]: false +[BLOCK_RECURSION_DEPTH_5]: false +[BLOCK_RECURSION_DEPTH_6]: false +[BLOCK_RECURSION_DEPTH_7]: false +[BLOCK_RECURSION_DEPTH_8]: false +[BLOCK_RECURSION_DEPTH_9]: false + +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +Result: false +[BLOCK_COMMON_SUBEXPR_ONLY]: false +[BLOCK_RECURSION_DEPTH_1]: false +[BLOCK_RECURSION_DEPTH_2]: false +[BLOCK_RECURSION_DEPTH_3]: false +[BLOCK_RECURSION_DEPTH_4]: false +[BLOCK_RECURSION_DEPTH_5]: false +[BLOCK_RECURSION_DEPTH_6]: false +[BLOCK_RECURSION_DEPTH_7]: false +[BLOCK_RECURSION_DEPTH_8]: false +[BLOCK_RECURSION_DEPTH_9]: false + +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +Result: [2, 4, 6, 4, 8, 12] +[BLOCK_COMMON_SUBEXPR_ONLY]: [2, 4, 6, 4, 8, 12] +[BLOCK_RECURSION_DEPTH_1]: [2, 4, 6, 4, 8, 12] +[BLOCK_RECURSION_DEPTH_2]: [2, 4, 6, 4, 8, 12] +[BLOCK_RECURSION_DEPTH_3]: [2, 4, 6, 4, 8, 12] +[BLOCK_RECURSION_DEPTH_4]: [2, 4, 6, 4, 8, 12] +[BLOCK_RECURSION_DEPTH_5]: [2, 4, 6, 4, 8, 12] +[BLOCK_RECURSION_DEPTH_6]: [2, 4, 6, 4, 8, 12] +[BLOCK_RECURSION_DEPTH_7]: [2, 4, 6, 4, 8, 12] +[BLOCK_RECURSION_DEPTH_8]: [2, 4, 6, 4, 8, 12] +[BLOCK_RECURSION_DEPTH_9]: [2, 4, 6, 4, 8, 12] + +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([x - 1, @index0 > 3], [@index1 ? @index0 : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index1) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([x - 1, @index0 > 3, @index1 ? @index0 : 5, [@index2]], @index3.exists(@it:0:0, @it:0:0 - 1 > 3) || @index1) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([x - 1 > 3, @index0 ? (x - 1) : 5, [@index1]], @index2.exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([x - 1 > 3, [@index0 ? (x - 1) : 5]], @index1.exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) + +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +Result: [[[foofoo, foofoo, foofoo, foofoo], [foofoo, foofoo, foofoo, foofoo]], [[barbar, barbar, barbar, barbar], [barbar, barbar, barbar, barbar]]] +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"]], [[@index0, @index0], [@index1, @index1]]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"], [@index0, @index0], [@index1, @index1]], [@index2, @index3]) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"]], [[@index0, @index0], [@index1, @index1]]) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"]], [[@index0, @index0], [@index1, @index1]]) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"]], [[@index0, @index0], [@index1, @index1]]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"]], [[@index0, @index0], [@index1, @index1]]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"]], [[@index0, @index0], [@index1, @index1]]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"]], [[@index0, @index0], [@index1, @index1]]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"]], [[@index0, @index0], [@index1, @index1]]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([["foofoo", "foofoo", "foofoo", "foofoo"], ["barbar", "barbar", "barbar", "barbar"]], [[@index0, @index0], [@index1, @index1]]) + +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +Result: false +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([x - y - 1, @index0 > 3], [@index1 ? @index0 : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index1) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([x - y, @index0 - 1, @index1 > 3, @index2 ? @index1 : 5, [@index3]], @index4.exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index2) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([x - y - 1, @index0 > 3, [@index1 ? @index0 : 5]], @index2.exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index1) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([x - y - 1 > 3, @index0 ? (x - y - 1) : 5, [@index1]], @index2.exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([x - y - 1 > 3, [@index0 ? (x - y - 1) : 5]], @index1.exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) + +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +Result: {0=[0, [0, foofoo, 0, foofoo]], 1=[2, [2, barbar, 2, barbar]]} +[BLOCK_COMMON_SUBEXPR_ONLY]: {0: [0, [0, "foofoo", 0, "foofoo"]], 1: [2, [2, "barbar", 2, "barbar"]]} +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[0, "foofoo", 0, "foofoo"], [0, @index0], [2, "barbar", 2, "barbar"], [2, @index2]], {0: @index1, 1: @index3}) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[0, [0, "foofoo", 0, "foofoo"]], [2, [2, "barbar", 2, "barbar"]]], {0: @index0, 1: @index1}) +[BLOCK_RECURSION_DEPTH_3]: {0: [0, [0, "foofoo", 0, "foofoo"]], 1: [2, [2, "barbar", 2, "barbar"]]} +[BLOCK_RECURSION_DEPTH_4]: {0: [0, [0, "foofoo", 0, "foofoo"]], 1: [2, [2, "barbar", 2, "barbar"]]} +[BLOCK_RECURSION_DEPTH_5]: {0: [0, [0, "foofoo", 0, "foofoo"]], 1: [2, [2, "barbar", 2, "barbar"]]} +[BLOCK_RECURSION_DEPTH_6]: {0: [0, [0, "foofoo", 0, "foofoo"]], 1: [2, [2, "barbar", 2, "barbar"]]} +[BLOCK_RECURSION_DEPTH_7]: {0: [0, [0, "foofoo", 0, "foofoo"]], 1: [2, [2, "barbar", 2, "barbar"]]} +[BLOCK_RECURSION_DEPTH_8]: {0: [0, [0, "foofoo", 0, "foofoo"]], 1: [2, [2, "barbar", 2, "barbar"]]} +[BLOCK_RECURSION_DEPTH_9]: {0: [0, [0, "foofoo", 0, "foofoo"]], 1: [2, [2, "barbar", 2, "barbar"]]} + +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, has(@index0.payload), @index0.payload, @index2.single_int64, @index1 ? @index3 : 0], @index4 == 10) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type, @index0.payload.single_int64, has(@index0.payload) ? @index1 : 0], @index2 == 10) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type, has(@index0.payload) ? @index0.payload.single_int64 : 0], @index1 == 10) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) + +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type, @index0.payload.single_int64], (has(@index0.payload) ? @index1 : (@index1 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64, has(@index0.payload), @index2 * 0, @index3 ? @index2 : @index4], @index5 == 10) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.single_int64, has(msg.oneof_type.payload), @index2 ? @index1 : (@index1 * 0)], @index3 == 10) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64, has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)], @index1 == 10) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) + +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload, @index0.single_int64], (has(@index0.single_int64) ? @index1 : (@index1 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64, has(@index1.single_int64), @index2 * 0, @index3 ? @index2 : @index4], @index5 == 10) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.single_int64, has(@index0.single_int64) ? @index1 : (@index1 * 0)], @index2 == 10) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64, has(msg.oneof_type.payload.single_int64)], (@index1 ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.single_int64, has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)], @index1 == 10) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) + +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type, @index0.payload, @index1.map_string_string], (has(msg.oneof_type) && has(@index0.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index2.key)) ? (@index2.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.map_string_string, has(msg.oneof_type), has(@index0.payload), @index3 && @index4, has(@index1.single_int64), @index5 && @index6, has(@index1.map_string_string), has(@index2.key), @index8 && @index9, @index2.key, @index11 == "A", @index10 ? @index12 : false], @index7 ? @index13 : false) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.map_string_string, has(msg.oneof_type.payload), has(msg.oneof_type) && @index2, @index3 && has(@index0.single_int64), has(@index0.map_string_string) && has(@index1.key), @index1.key == "A"], @index4 ? (@index5 ? @index6 : false) : false) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload, has(msg.oneof_type) && has(msg.oneof_type.payload), (has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false], (@index2 && has(@index1.single_int64)) ? @index3 : false) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload, has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)], @index2 ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) + +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[?opt_x], [5]], [10, @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[?opt_x], [5], [10, @index0, @index0], [10, @index1, @index1]], @index2 == @index3) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[?opt_x], [5]], [10, @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[?opt_x], [5]], [10, @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[?opt_x], [5]], [10, @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[?opt_x], [5]], [10, @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[?opt_x], [5]], [10, @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[?opt_x], [5]], [10, @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[?opt_x], [5]], [10, @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[?opt_x], [5]], [10, @index0, @index0] == [10, @index1, @index1]) + +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: true +[BLOCK_RECURSION_DEPTH_1]: true +[BLOCK_RECURSION_DEPTH_2]: true +[BLOCK_RECURSION_DEPTH_3]: true +[BLOCK_RECURSION_DEPTH_4]: true +[BLOCK_RECURSION_DEPTH_5]: true +[BLOCK_RECURSION_DEPTH_6]: true +[BLOCK_RECURSION_DEPTH_7]: true +[BLOCK_RECURSION_DEPTH_8]: true +[BLOCK_RECURSION_DEPTH_9]: true + +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +Result: 31 +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload, @index0.single_int64], non_pure_custom_func(@index1) + non_pure_custom_func(@index0.single_int32) + non_pure_custom_func(@index1) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64], non_pure_custom_func(@index2) + non_pure_custom_func(@index1.single_int32) + non_pure_custom_func(@index2) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.single_int64], non_pure_custom_func(@index1) + non_pure_custom_func(@index0.single_int32) + non_pure_custom_func(@index1) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) + +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +Result: 31 +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload, pure_custom_func(@index0.single_int64)], @index1 + pure_custom_func(@index0.single_int32) + @index1 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64, pure_custom_func(@index2), @index1.single_int32, pure_custom_func(@index4), @index3 + @index5, @index6 + @index3, msg.single_int64, pure_custom_func(@index8)], @index7 + @index9) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, pure_custom_func(@index0.single_int64), pure_custom_func(@index0.single_int32), @index1 + @index2 + @index1, pure_custom_func(msg.single_int64)], @index3 + @index4) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64, pure_custom_func(@index0), msg.oneof_type.payload.single_int32, @index1 + pure_custom_func(@index2) + @index1], @index3 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64), pure_custom_func(msg.oneof_type.payload.single_int32)], @index0 + @index1 + @index0 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64), @index0 + pure_custom_func(msg.oneof_type.payload.single_int32)], @index1 + @index0 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64), @index0 + pure_custom_func(msg.oneof_type.payload.single_int32) + @index0], @index1 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64)], @index0 + pure_custom_func(msg.oneof_type.payload.single_int32) + @index0 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64)], @index0 + pure_custom_func(msg.oneof_type.payload.single_int32) + @index0 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64)], @index0 + pure_custom_func(msg.oneof_type.payload.single_int32) + @index0 + pure_custom_func(msg.single_int64)) \ No newline at end of file diff --git a/optimizer/src/test/resources/large_expressions_block_common_subexpr.baseline b/optimizer/src/test/resources/large_expressions_block_common_subexpr.baseline new file mode 100644 index 000000000..fc5498563 --- /dev/null +++ b/optimizer/src/test/resources/large_expressions_block_common_subexpr.baseline @@ -0,0 +1,17 @@ +Test case: CALC_FOUR_COMMON_SUBEXPR +Source: [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] +=====> +Result: [1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4] +Unparsed: cel.@block([[1], [1, 2], [1, 2, 3], [1, 2, 3, 4]], @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3 + @index0 + @index1 + @index2 + @index3) + +Test case: CALC_ALL_COMMON_SUBEXPR +Source: [0, 1] + [0, 1] + [1, 2] + [1, 2] + [2, 3] + [2, 3] + [3, 4] + [3, 4] + [4, 5] + [4, 5] + [5, 6] + [5, 6] + [6, 7] + [6, 7] + [7, 8] + [7, 8] + [8, 9] + [8, 9] + [9, 10] + [9, 10] + [10, 11] + [10, 11] + [11, 12] + [11, 12] + [12, 13] + [12, 13] + [13, 14] + [13, 14] + [14, 15] + [14, 15] + [15, 16] + [15, 16] + [16, 17] + [16, 17] + [17, 18] + [17, 18] + [18, 19] + [18, 19] + [19, 20] + [19, 20] + [20, 21] + [20, 21] + [21, 22] + [21, 22] + [22, 23] + [22, 23] + [23, 24] + [23, 24] + [24, 25] + [24, 25] + [25, 26] + [25, 26] + [26, 27] + [26, 27] + [27, 28] + [27, 28] + [28, 29] + [28, 29] + [29, 30] + [29, 30] + [30, 31] + [30, 31] + [31, 32] + [31, 32] + [32, 33] + [32, 33] + [33, 34] + [33, 34] + [34, 35] + [34, 35] + [35, 36] + [35, 36] + [36, 37] + [36, 37] + [37, 38] + [37, 38] + [38, 39] + [38, 39] + [39, 40] + [39, 40] + [40, 41] + [40, 41] + [41, 42] + [41, 42] + [42, 43] + [42, 43] + [43, 44] + [43, 44] + [44, 45] + [44, 45] + [45, 46] + [45, 46] + [46, 47] + [46, 47] + [47, 48] + [47, 48] + [48, 49] + [48, 49] + [49, 50] + [49, 50] +=====> +Result: [0, 1, 0, 1, 1, 2, 1, 2, 2, 3, 2, 3, 3, 4, 3, 4, 4, 5, 4, 5, 5, 6, 5, 6, 6, 7, 6, 7, 7, 8, 7, 8, 8, 9, 8, 9, 9, 10, 9, 10, 10, 11, 10, 11, 11, 12, 11, 12, 12, 13, 12, 13, 13, 14, 13, 14, 14, 15, 14, 15, 15, 16, 15, 16, 16, 17, 16, 17, 17, 18, 17, 18, 18, 19, 18, 19, 19, 20, 19, 20, 20, 21, 20, 21, 21, 22, 21, 22, 22, 23, 22, 23, 23, 24, 23, 24, 24, 25, 24, 25, 25, 26, 25, 26, 26, 27, 26, 27, 27, 28, 27, 28, 28, 29, 28, 29, 29, 30, 29, 30, 30, 31, 30, 31, 31, 32, 31, 32, 32, 33, 32, 33, 33, 34, 33, 34, 34, 35, 34, 35, 35, 36, 35, 36, 36, 37, 36, 37, 37, 38, 37, 38, 38, 39, 38, 39, 39, 40, 39, 40, 40, 41, 40, 41, 41, 42, 41, 42, 42, 43, 42, 43, 43, 44, 43, 44, 44, 45, 44, 45, 45, 46, 45, 46, 46, 47, 46, 47, 47, 48, 47, 48, 48, 49, 48, 49, 49, 50, 49, 50] +Unparsed: cel.@block([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], [11, 12], [12, 13], [13, 14], [14, 15], [15, 16], [16, 17], [17, 18], [18, 19], [19, 20], [20, 21], [21, 22], [22, 23], [23, 24], [24, 25], [25, 26], [26, 27], [27, 28], [28, 29], [29, 30], [30, 31], [31, 32], [32, 33], [33, 34], [34, 35], [35, 36], [36, 37], [37, 38], [38, 39], [39, 40], [40, 41], [41, 42], [42, 43], [43, 44], [44, 45], [45, 46], [46, 47], [47, 48], [48, 49], [49, 50]], @index0 + @index0 + @index1 + @index1 + @index2 + @index2 + @index3 + @index3 + @index4 + @index4 + @index5 + @index5 + @index6 + @index6 + @index7 + @index7 + @index8 + @index8 + @index9 + @index9 + @index10 + @index10 + @index11 + @index11 + @index12 + @index12 + @index13 + @index13 + @index14 + @index14 + @index15 + @index15 + @index16 + @index16 + @index17 + @index17 + @index18 + @index18 + @index19 + @index19 + @index20 + @index20 + @index21 + @index21 + @index22 + @index22 + @index23 + @index23 + @index24 + @index24 + @index25 + @index25 + @index26 + @index26 + @index27 + @index27 + @index28 + @index28 + @index29 + @index29 + @index30 + @index30 + @index31 + @index31 + @index32 + @index32 + @index33 + @index33 + @index34 + @index34 + @index35 + @index35 + @index36 + @index36 + @index37 + @index37 + @index38 + @index38 + @index39 + @index39 + @index40 + @index40 + @index41 + @index41 + @index42 + @index42 + @index43 + @index43 + @index44 + @index44 + @index45 + @index45 + @index46 + @index46 + @index47 + @index47 + @index48 + @index48 + @index49 + @index49) + +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3])))))))) +=====> +Result: [[[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]], [[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]], [[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]]] +Unparsed: cel.@block([[1, 2, 3]], @index0.map(@it:7:0, @index0.map(@it:6:0, @index0.map(@it:5:0, @index0.map(@it:4:0, @index0.map(@it:3:0, @index0.map(@it:2:0, @index0.map(@it:1:0, @index0.map(@it:0:0, @index0))))))))) \ No newline at end of file diff --git a/optimizer/src/test/resources/large_expressions_block_recursion_depth_1.baseline b/optimizer/src/test/resources/large_expressions_block_recursion_depth_1.baseline new file mode 100644 index 000000000..5d7b20381 --- /dev/null +++ b/optimizer/src/test/resources/large_expressions_block_recursion_depth_1.baseline @@ -0,0 +1,17 @@ +Test case: CALC_FOUR_COMMON_SUBEXPR +Source: [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] +=====> +Result: [1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4] +Unparsed: cel.@block([[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], @index0 + @index1, @index4 + @index2, @index5 + @index3, @index6 + @index0, @index7 + @index1, @index8 + @index2, @index9 + @index3, @index10 + @index0, @index11 + @index1, @index12 + @index2, @index13 + @index3, @index14 + @index0, @index15 + @index1, @index16 + @index2, @index17 + @index3, @index18 + @index0, @index19 + @index1, @index20 + @index2, @index21 + @index3, @index22 + @index0, @index23 + @index1, @index24 + @index2, @index25 + @index3, @index26 + @index0, @index27 + @index1, @index28 + @index2, @index29 + @index3, @index30 + @index0, @index31 + @index1, @index32 + @index2, @index33 + @index3, @index34 + @index0, @index35 + @index1, @index36 + @index2, @index37 + @index3, @index38 + @index0, @index39 + @index1, @index40 + @index2, @index41 + @index3, @index42 + @index0, @index43 + @index1, @index44 + @index2, @index45 + @index3, @index46 + @index0, @index47 + @index1, @index48 + @index2, @index49 + @index3, @index50 + @index0, @index51 + @index1, @index52 + @index2, @index53 + @index3, @index54 + @index0, @index55 + @index1, @index56 + @index2, @index57 + @index3, @index58 + @index0, @index59 + @index1, @index60 + @index2, @index61 + @index3, @index62 + @index0, @index63 + @index1, @index64 + @index2, @index65 + @index3, @index66 + @index0, @index67 + @index1, @index68 + @index2, @index69 + @index3, @index70 + @index0, @index71 + @index1, @index72 + @index2, @index73 + @index3, @index74 + @index0, @index75 + @index1, @index76 + @index2, @index77 + @index3, @index78 + @index0, @index79 + @index1, @index80 + @index2, @index81 + @index3, @index82 + @index0, @index83 + @index1, @index84 + @index2, @index85 + @index3, @index86 + @index0, @index87 + @index1, @index88 + @index2, @index89 + @index3, @index90 + @index0, @index91 + @index1, @index92 + @index2, @index93 + @index3, @index94 + @index0, @index95 + @index1, @index96 + @index2, @index97 + @index3, @index98 + @index0, @index99 + @index1, @index100 + @index2, @index101 + @index3, @index102 + @index0, @index103 + @index1, @index104 + @index2, @index105 + @index3, @index106 + @index0, @index107 + @index1, @index108 + @index2, @index109 + @index3, @index110 + @index0, @index111 + @index1, @index112 + @index2, @index113 + @index3, @index114 + @index0, @index115 + @index1, @index116 + @index2, @index117 + @index3, @index118 + @index0, @index119 + @index1, @index120 + @index2, @index121 + @index3, @index122 + @index0, @index123 + @index1, @index124 + @index2, @index125 + @index3, @index126 + @index0, @index127 + @index1, @index128 + @index2, @index129 + @index3, @index130 + @index0, @index131 + @index1, @index132 + @index2, @index133 + @index3, @index134 + @index0, @index135 + @index1, @index136 + @index2, @index137 + @index3, @index138 + @index0, @index139 + @index1, @index140 + @index2, @index141 + @index3, @index142 + @index0, @index143 + @index1, @index144 + @index2, @index145 + @index3, @index146 + @index0, @index147 + @index1, @index148 + @index2, @index149 + @index3, @index150 + @index0, @index151 + @index1, @index152 + @index2, @index153 + @index3, @index154 + @index0, @index155 + @index1, @index156 + @index2, @index157 + @index3, @index158 + @index0, @index159 + @index1, @index160 + @index2], @index161 + @index3) + +Test case: CALC_ALL_COMMON_SUBEXPR +Source: [0, 1] + [0, 1] + [1, 2] + [1, 2] + [2, 3] + [2, 3] + [3, 4] + [3, 4] + [4, 5] + [4, 5] + [5, 6] + [5, 6] + [6, 7] + [6, 7] + [7, 8] + [7, 8] + [8, 9] + [8, 9] + [9, 10] + [9, 10] + [10, 11] + [10, 11] + [11, 12] + [11, 12] + [12, 13] + [12, 13] + [13, 14] + [13, 14] + [14, 15] + [14, 15] + [15, 16] + [15, 16] + [16, 17] + [16, 17] + [17, 18] + [17, 18] + [18, 19] + [18, 19] + [19, 20] + [19, 20] + [20, 21] + [20, 21] + [21, 22] + [21, 22] + [22, 23] + [22, 23] + [23, 24] + [23, 24] + [24, 25] + [24, 25] + [25, 26] + [25, 26] + [26, 27] + [26, 27] + [27, 28] + [27, 28] + [28, 29] + [28, 29] + [29, 30] + [29, 30] + [30, 31] + [30, 31] + [31, 32] + [31, 32] + [32, 33] + [32, 33] + [33, 34] + [33, 34] + [34, 35] + [34, 35] + [35, 36] + [35, 36] + [36, 37] + [36, 37] + [37, 38] + [37, 38] + [38, 39] + [38, 39] + [39, 40] + [39, 40] + [40, 41] + [40, 41] + [41, 42] + [41, 42] + [42, 43] + [42, 43] + [43, 44] + [43, 44] + [44, 45] + [44, 45] + [45, 46] + [45, 46] + [46, 47] + [46, 47] + [47, 48] + [47, 48] + [48, 49] + [48, 49] + [49, 50] + [49, 50] +=====> +Result: [0, 1, 0, 1, 1, 2, 1, 2, 2, 3, 2, 3, 3, 4, 3, 4, 4, 5, 4, 5, 5, 6, 5, 6, 6, 7, 6, 7, 7, 8, 7, 8, 8, 9, 8, 9, 9, 10, 9, 10, 10, 11, 10, 11, 11, 12, 11, 12, 12, 13, 12, 13, 13, 14, 13, 14, 14, 15, 14, 15, 15, 16, 15, 16, 16, 17, 16, 17, 17, 18, 17, 18, 18, 19, 18, 19, 19, 20, 19, 20, 20, 21, 20, 21, 21, 22, 21, 22, 22, 23, 22, 23, 23, 24, 23, 24, 24, 25, 24, 25, 25, 26, 25, 26, 26, 27, 26, 27, 27, 28, 27, 28, 28, 29, 28, 29, 29, 30, 29, 30, 30, 31, 30, 31, 31, 32, 31, 32, 32, 33, 32, 33, 33, 34, 33, 34, 34, 35, 34, 35, 35, 36, 35, 36, 36, 37, 36, 37, 37, 38, 37, 38, 38, 39, 38, 39, 39, 40, 39, 40, 40, 41, 40, 41, 41, 42, 41, 42, 42, 43, 42, 43, 43, 44, 43, 44, 44, 45, 44, 45, 45, 46, 45, 46, 46, 47, 46, 47, 47, 48, 47, 48, 48, 49, 48, 49, 49, 50, 49, 50] +Unparsed: cel.@block([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], [11, 12], [12, 13], [13, 14], [14, 15], [15, 16], [16, 17], [17, 18], [18, 19], [19, 20], [20, 21], [21, 22], [22, 23], [23, 24], [24, 25], [25, 26], [26, 27], [27, 28], [28, 29], [29, 30], [30, 31], [31, 32], [32, 33], [33, 34], [34, 35], [35, 36], [36, 37], [37, 38], [38, 39], [39, 40], [40, 41], [41, 42], [42, 43], [43, 44], [44, 45], [45, 46], [46, 47], [47, 48], [48, 49], [49, 50], @index0 + @index0, @index50 + @index1, @index51 + @index1, @index52 + @index2, @index53 + @index2, @index54 + @index3, @index55 + @index3, @index56 + @index4, @index57 + @index4, @index58 + @index5, @index59 + @index5, @index60 + @index6, @index61 + @index6, @index62 + @index7, @index63 + @index7, @index64 + @index8, @index65 + @index8, @index66 + @index9, @index67 + @index9, @index68 + @index10, @index69 + @index10, @index70 + @index11, @index71 + @index11, @index72 + @index12, @index73 + @index12, @index74 + @index13, @index75 + @index13, @index76 + @index14, @index77 + @index14, @index78 + @index15, @index79 + @index15, @index80 + @index16, @index81 + @index16, @index82 + @index17, @index83 + @index17, @index84 + @index18, @index85 + @index18, @index86 + @index19, @index87 + @index19, @index88 + @index20, @index89 + @index20, @index90 + @index21, @index91 + @index21, @index92 + @index22, @index93 + @index22, @index94 + @index23, @index95 + @index23, @index96 + @index24, @index97 + @index24, @index98 + @index25, @index99 + @index25, @index100 + @index26, @index101 + @index26, @index102 + @index27, @index103 + @index27, @index104 + @index28, @index105 + @index28, @index106 + @index29, @index107 + @index29, @index108 + @index30, @index109 + @index30, @index110 + @index31, @index111 + @index31, @index112 + @index32, @index113 + @index32, @index114 + @index33, @index115 + @index33, @index116 + @index34, @index117 + @index34, @index118 + @index35, @index119 + @index35, @index120 + @index36, @index121 + @index36, @index122 + @index37, @index123 + @index37, @index124 + @index38, @index125 + @index38, @index126 + @index39, @index127 + @index39, @index128 + @index40, @index129 + @index40, @index130 + @index41, @index131 + @index41, @index132 + @index42, @index133 + @index42, @index134 + @index43, @index135 + @index43, @index136 + @index44, @index137 + @index44, @index138 + @index45, @index139 + @index45, @index140 + @index46, @index141 + @index46, @index142 + @index47, @index143 + @index47, @index144 + @index48, @index145 + @index48, @index146 + @index49], @index147 + @index49) + +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3])))))))) +=====> +Result: [[[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]], [[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]], [[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]]] +Unparsed: cel.@block([[1, 2, 3], [@index0]], @index0.map(@it:7:0, @index0.map(@it:6:0, @index0.map(@it:5:0, @index0.map(@it:4:0, @index0.map(@it:3:0, @index0.map(@it:2:0, @index0.map(@it:1:0, @index0.map(@it:0:0, @index0))))))))) \ No newline at end of file diff --git a/optimizer/src/test/resources/large_expressions_block_recursion_depth_2.baseline b/optimizer/src/test/resources/large_expressions_block_recursion_depth_2.baseline new file mode 100644 index 000000000..aba464e22 --- /dev/null +++ b/optimizer/src/test/resources/large_expressions_block_recursion_depth_2.baseline @@ -0,0 +1,17 @@ +Test case: CALC_FOUR_COMMON_SUBEXPR +Source: [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] +=====> +Result: [1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4] +Unparsed: cel.@block([[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], @index0 + @index1 + @index2, @index4 + @index3 + @index0, @index5 + @index1 + @index2, @index6 + @index3 + @index0, @index7 + @index1 + @index2, @index8 + @index3 + @index0, @index9 + @index1 + @index2, @index10 + @index3 + @index0, @index11 + @index1 + @index2, @index12 + @index3 + @index0, @index13 + @index1 + @index2, @index14 + @index3 + @index0, @index15 + @index1 + @index2, @index16 + @index3 + @index0, @index17 + @index1 + @index2, @index18 + @index3 + @index0, @index19 + @index1 + @index2, @index20 + @index3 + @index0, @index21 + @index1 + @index2, @index22 + @index3 + @index0, @index23 + @index1 + @index2, @index24 + @index3 + @index0, @index25 + @index1 + @index2, @index26 + @index3 + @index0, @index27 + @index1 + @index2, @index28 + @index3 + @index0, @index29 + @index1 + @index2, @index30 + @index3 + @index0, @index31 + @index1 + @index2, @index32 + @index3 + @index0, @index33 + @index1 + @index2, @index34 + @index3 + @index0, @index35 + @index1 + @index2, @index36 + @index3 + @index0, @index37 + @index1 + @index2, @index38 + @index3 + @index0, @index39 + @index1 + @index2, @index40 + @index3 + @index0, @index41 + @index1 + @index2, @index42 + @index3 + @index0, @index43 + @index1 + @index2, @index44 + @index3 + @index0, @index45 + @index1 + @index2, @index46 + @index3 + @index0, @index47 + @index1 + @index2, @index48 + @index3 + @index0, @index49 + @index1 + @index2, @index50 + @index3 + @index0, @index51 + @index1 + @index2, @index52 + @index3 + @index0, @index53 + @index1 + @index2, @index54 + @index3 + @index0, @index55 + @index1 + @index2, @index56 + @index3 + @index0, @index57 + @index1 + @index2, @index58 + @index3 + @index0, @index59 + @index1 + @index2, @index60 + @index3 + @index0, @index61 + @index1 + @index2, @index62 + @index3 + @index0, @index63 + @index1 + @index2, @index64 + @index3 + @index0, @index65 + @index1 + @index2, @index66 + @index3 + @index0, @index67 + @index1 + @index2, @index68 + @index3 + @index0, @index69 + @index1 + @index2, @index70 + @index3 + @index0, @index71 + @index1 + @index2, @index72 + @index3 + @index0, @index73 + @index1 + @index2, @index74 + @index3 + @index0, @index75 + @index1 + @index2, @index76 + @index3 + @index0, @index77 + @index1 + @index2, @index78 + @index3 + @index0, @index79 + @index1 + @index2, @index80 + @index3 + @index0, @index81 + @index1 + @index2], @index82 + @index3) + +Test case: CALC_ALL_COMMON_SUBEXPR +Source: [0, 1] + [0, 1] + [1, 2] + [1, 2] + [2, 3] + [2, 3] + [3, 4] + [3, 4] + [4, 5] + [4, 5] + [5, 6] + [5, 6] + [6, 7] + [6, 7] + [7, 8] + [7, 8] + [8, 9] + [8, 9] + [9, 10] + [9, 10] + [10, 11] + [10, 11] + [11, 12] + [11, 12] + [12, 13] + [12, 13] + [13, 14] + [13, 14] + [14, 15] + [14, 15] + [15, 16] + [15, 16] + [16, 17] + [16, 17] + [17, 18] + [17, 18] + [18, 19] + [18, 19] + [19, 20] + [19, 20] + [20, 21] + [20, 21] + [21, 22] + [21, 22] + [22, 23] + [22, 23] + [23, 24] + [23, 24] + [24, 25] + [24, 25] + [25, 26] + [25, 26] + [26, 27] + [26, 27] + [27, 28] + [27, 28] + [28, 29] + [28, 29] + [29, 30] + [29, 30] + [30, 31] + [30, 31] + [31, 32] + [31, 32] + [32, 33] + [32, 33] + [33, 34] + [33, 34] + [34, 35] + [34, 35] + [35, 36] + [35, 36] + [36, 37] + [36, 37] + [37, 38] + [37, 38] + [38, 39] + [38, 39] + [39, 40] + [39, 40] + [40, 41] + [40, 41] + [41, 42] + [41, 42] + [42, 43] + [42, 43] + [43, 44] + [43, 44] + [44, 45] + [44, 45] + [45, 46] + [45, 46] + [46, 47] + [46, 47] + [47, 48] + [47, 48] + [48, 49] + [48, 49] + [49, 50] + [49, 50] +=====> +Result: [0, 1, 0, 1, 1, 2, 1, 2, 2, 3, 2, 3, 3, 4, 3, 4, 4, 5, 4, 5, 5, 6, 5, 6, 6, 7, 6, 7, 7, 8, 7, 8, 8, 9, 8, 9, 9, 10, 9, 10, 10, 11, 10, 11, 11, 12, 11, 12, 12, 13, 12, 13, 13, 14, 13, 14, 14, 15, 14, 15, 15, 16, 15, 16, 16, 17, 16, 17, 17, 18, 17, 18, 18, 19, 18, 19, 19, 20, 19, 20, 20, 21, 20, 21, 21, 22, 21, 22, 22, 23, 22, 23, 23, 24, 23, 24, 24, 25, 24, 25, 25, 26, 25, 26, 26, 27, 26, 27, 27, 28, 27, 28, 28, 29, 28, 29, 29, 30, 29, 30, 30, 31, 30, 31, 31, 32, 31, 32, 32, 33, 32, 33, 33, 34, 33, 34, 34, 35, 34, 35, 35, 36, 35, 36, 36, 37, 36, 37, 37, 38, 37, 38, 38, 39, 38, 39, 39, 40, 39, 40, 40, 41, 40, 41, 41, 42, 41, 42, 42, 43, 42, 43, 43, 44, 43, 44, 44, 45, 44, 45, 45, 46, 45, 46, 46, 47, 46, 47, 47, 48, 47, 48, 48, 49, 48, 49, 49, 50, 49, 50] +Unparsed: cel.@block([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], [11, 12], [12, 13], [13, 14], [14, 15], [15, 16], [16, 17], [17, 18], [18, 19], [19, 20], [20, 21], [21, 22], [22, 23], [23, 24], [24, 25], [25, 26], [26, 27], [27, 28], [28, 29], [29, 30], [30, 31], [31, 32], [32, 33], [33, 34], [34, 35], [35, 36], [36, 37], [37, 38], [38, 39], [39, 40], [40, 41], [41, 42], [42, 43], [43, 44], [44, 45], [45, 46], [46, 47], [47, 48], [48, 49], [49, 50], @index0 + @index0 + @index1, @index50 + @index1 + @index2, @index51 + @index2 + @index3, @index52 + @index3 + @index4, @index53 + @index4 + @index5, @index54 + @index5 + @index6, @index55 + @index6 + @index7, @index56 + @index7 + @index8, @index57 + @index8 + @index9, @index58 + @index9 + @index10, @index59 + @index10 + @index11, @index60 + @index11 + @index12, @index61 + @index12 + @index13, @index62 + @index13 + @index14, @index63 + @index14 + @index15, @index64 + @index15 + @index16, @index65 + @index16 + @index17, @index66 + @index17 + @index18, @index67 + @index18 + @index19, @index68 + @index19 + @index20, @index69 + @index20 + @index21, @index70 + @index21 + @index22, @index71 + @index22 + @index23, @index72 + @index23 + @index24, @index73 + @index24 + @index25, @index74 + @index25 + @index26, @index75 + @index26 + @index27, @index76 + @index27 + @index28, @index77 + @index28 + @index29, @index78 + @index29 + @index30, @index79 + @index30 + @index31, @index80 + @index31 + @index32, @index81 + @index32 + @index33, @index82 + @index33 + @index34, @index83 + @index34 + @index35, @index84 + @index35 + @index36, @index85 + @index36 + @index37, @index86 + @index37 + @index38, @index87 + @index38 + @index39, @index88 + @index39 + @index40, @index89 + @index40 + @index41, @index90 + @index41 + @index42, @index91 + @index42 + @index43, @index92 + @index43 + @index44, @index93 + @index44 + @index45, @index94 + @index45 + @index46, @index95 + @index46 + @index47, @index96 + @index47 + @index48, @index97 + @index48 + @index49], @index98 + @index49) + +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3])))))))) +=====> +Result: [[[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]], [[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]], [[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]]] +Unparsed: cel.@block([[1, 2, 3], [@index0], @index0.map(@it:0:0, @index0), [@index2], @index0.map(@it:1:0, @index2), [@index4], @index0.map(@it:2:0, @index4), [@index6], @index0.map(@it:3:0, @index6), [@index8], @index0.map(@it:4:0, @index8), [@index10], @index0.map(@it:5:0, @index10), [@index12], @index0.map(@it:6:0, @index12), [@index14]], @index0.map(@it:7:0, @index14)) \ No newline at end of file diff --git a/optimizer/src/test/resources/large_expressions_block_recursion_depth_3.baseline b/optimizer/src/test/resources/large_expressions_block_recursion_depth_3.baseline new file mode 100644 index 000000000..e5a542ac4 --- /dev/null +++ b/optimizer/src/test/resources/large_expressions_block_recursion_depth_3.baseline @@ -0,0 +1,17 @@ +Test case: CALC_FOUR_COMMON_SUBEXPR +Source: [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] + [1] + [1,2] + [1,2,3] + [1,2,3,4] +=====> +Result: [1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4] +Unparsed: cel.@block([[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], @index0 + @index1 + @index2 + @index3, @index4 + @index0 + @index1 + @index2, @index5 + @index3 + @index0 + @index1, @index6 + @index2 + @index3 + @index0, @index7 + @index1 + @index2 + @index3, @index8 + @index0 + @index1 + @index2, @index9 + @index3 + @index0 + @index1, @index10 + @index2 + @index3 + @index0, @index11 + @index1 + @index2 + @index3, @index12 + @index0 + @index1 + @index2, @index13 + @index3 + @index0 + @index1, @index14 + @index2 + @index3 + @index0, @index15 + @index1 + @index2 + @index3, @index16 + @index0 + @index1 + @index2, @index17 + @index3 + @index0 + @index1, @index18 + @index2 + @index3 + @index0, @index19 + @index1 + @index2 + @index3, @index20 + @index0 + @index1 + @index2, @index21 + @index3 + @index0 + @index1, @index22 + @index2 + @index3 + @index0, @index23 + @index1 + @index2 + @index3, @index24 + @index0 + @index1 + @index2, @index25 + @index3 + @index0 + @index1, @index26 + @index2 + @index3 + @index0, @index27 + @index1 + @index2 + @index3, @index28 + @index0 + @index1 + @index2, @index29 + @index3 + @index0 + @index1, @index30 + @index2 + @index3 + @index0, @index31 + @index1 + @index2 + @index3, @index32 + @index0 + @index1 + @index2, @index33 + @index3 + @index0 + @index1, @index34 + @index2 + @index3 + @index0, @index35 + @index1 + @index2 + @index3, @index36 + @index0 + @index1 + @index2, @index37 + @index3 + @index0 + @index1, @index38 + @index2 + @index3 + @index0, @index39 + @index1 + @index2 + @index3, @index40 + @index0 + @index1 + @index2, @index41 + @index3 + @index0 + @index1, @index42 + @index2 + @index3 + @index0, @index43 + @index1 + @index2 + @index3, @index44 + @index0 + @index1 + @index2, @index45 + @index3 + @index0 + @index1, @index46 + @index2 + @index3 + @index0, @index47 + @index1 + @index2 + @index3, @index48 + @index0 + @index1 + @index2, @index49 + @index3 + @index0 + @index1, @index50 + @index2 + @index3 + @index0, @index51 + @index1 + @index2 + @index3, @index52 + @index0 + @index1 + @index2, @index53 + @index3 + @index0 + @index1, @index54 + @index2 + @index3 + @index0], @index55 + @index1 + @index2 + @index3) + +Test case: CALC_ALL_COMMON_SUBEXPR +Source: [0, 1] + [0, 1] + [1, 2] + [1, 2] + [2, 3] + [2, 3] + [3, 4] + [3, 4] + [4, 5] + [4, 5] + [5, 6] + [5, 6] + [6, 7] + [6, 7] + [7, 8] + [7, 8] + [8, 9] + [8, 9] + [9, 10] + [9, 10] + [10, 11] + [10, 11] + [11, 12] + [11, 12] + [12, 13] + [12, 13] + [13, 14] + [13, 14] + [14, 15] + [14, 15] + [15, 16] + [15, 16] + [16, 17] + [16, 17] + [17, 18] + [17, 18] + [18, 19] + [18, 19] + [19, 20] + [19, 20] + [20, 21] + [20, 21] + [21, 22] + [21, 22] + [22, 23] + [22, 23] + [23, 24] + [23, 24] + [24, 25] + [24, 25] + [25, 26] + [25, 26] + [26, 27] + [26, 27] + [27, 28] + [27, 28] + [28, 29] + [28, 29] + [29, 30] + [29, 30] + [30, 31] + [30, 31] + [31, 32] + [31, 32] + [32, 33] + [32, 33] + [33, 34] + [33, 34] + [34, 35] + [34, 35] + [35, 36] + [35, 36] + [36, 37] + [36, 37] + [37, 38] + [37, 38] + [38, 39] + [38, 39] + [39, 40] + [39, 40] + [40, 41] + [40, 41] + [41, 42] + [41, 42] + [42, 43] + [42, 43] + [43, 44] + [43, 44] + [44, 45] + [44, 45] + [45, 46] + [45, 46] + [46, 47] + [46, 47] + [47, 48] + [47, 48] + [48, 49] + [48, 49] + [49, 50] + [49, 50] +=====> +Result: [0, 1, 0, 1, 1, 2, 1, 2, 2, 3, 2, 3, 3, 4, 3, 4, 4, 5, 4, 5, 5, 6, 5, 6, 6, 7, 6, 7, 7, 8, 7, 8, 8, 9, 8, 9, 9, 10, 9, 10, 10, 11, 10, 11, 11, 12, 11, 12, 12, 13, 12, 13, 13, 14, 13, 14, 14, 15, 14, 15, 15, 16, 15, 16, 16, 17, 16, 17, 17, 18, 17, 18, 18, 19, 18, 19, 19, 20, 19, 20, 20, 21, 20, 21, 21, 22, 21, 22, 22, 23, 22, 23, 23, 24, 23, 24, 24, 25, 24, 25, 25, 26, 25, 26, 26, 27, 26, 27, 27, 28, 27, 28, 28, 29, 28, 29, 29, 30, 29, 30, 30, 31, 30, 31, 31, 32, 31, 32, 32, 33, 32, 33, 33, 34, 33, 34, 34, 35, 34, 35, 35, 36, 35, 36, 36, 37, 36, 37, 37, 38, 37, 38, 38, 39, 38, 39, 39, 40, 39, 40, 40, 41, 40, 41, 41, 42, 41, 42, 42, 43, 42, 43, 43, 44, 43, 44, 44, 45, 44, 45, 45, 46, 45, 46, 46, 47, 46, 47, 47, 48, 47, 48, 48, 49, 48, 49, 49, 50, 49, 50] +Unparsed: cel.@block([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], [11, 12], [12, 13], [13, 14], [14, 15], [15, 16], [16, 17], [17, 18], [18, 19], [19, 20], [20, 21], [21, 22], [22, 23], [23, 24], [24, 25], [25, 26], [26, 27], [27, 28], [28, 29], [29, 30], [30, 31], [31, 32], [32, 33], [33, 34], [34, 35], [35, 36], [36, 37], [37, 38], [38, 39], [39, 40], [40, 41], [41, 42], [42, 43], [43, 44], [44, 45], [45, 46], [46, 47], [47, 48], [48, 49], [49, 50], @index0 + @index0 + @index1 + @index1, @index50 + @index2 + @index2 + @index3, @index51 + @index3 + @index4 + @index4, @index52 + @index5 + @index5 + @index6, @index53 + @index6 + @index7 + @index7, @index54 + @index8 + @index8 + @index9, @index55 + @index9 + @index10 + @index10, @index56 + @index11 + @index11 + @index12, @index57 + @index12 + @index13 + @index13, @index58 + @index14 + @index14 + @index15, @index59 + @index15 + @index16 + @index16, @index60 + @index17 + @index17 + @index18, @index61 + @index18 + @index19 + @index19, @index62 + @index20 + @index20 + @index21, @index63 + @index21 + @index22 + @index22, @index64 + @index23 + @index23 + @index24, @index65 + @index24 + @index25 + @index25, @index66 + @index26 + @index26 + @index27, @index67 + @index27 + @index28 + @index28, @index68 + @index29 + @index29 + @index30, @index69 + @index30 + @index31 + @index31, @index70 + @index32 + @index32 + @index33, @index71 + @index33 + @index34 + @index34, @index72 + @index35 + @index35 + @index36, @index73 + @index36 + @index37 + @index37, @index74 + @index38 + @index38 + @index39, @index75 + @index39 + @index40 + @index40, @index76 + @index41 + @index41 + @index42, @index77 + @index42 + @index43 + @index43, @index78 + @index44 + @index44 + @index45, @index79 + @index45 + @index46 + @index46, @index80 + @index47 + @index47 + @index48], @index81 + @index48 + @index49 + @index49) + +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3].map(i, [1, 2, 3])))))))) +=====> +Result: [[[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]], [[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]], [[[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]], [[[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]], [[[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]], [[[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]], [[[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]], [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]]]]]]] +Unparsed: cel.@block([[1, 2, 3], @index0.map(@it:0:0, @index0), @index0.map(@it:1:0, @index1), @index0.map(@it:2:0, @index2), @index0.map(@it:3:0, @index3), @index0.map(@it:4:0, @index4), @index0.map(@it:5:0, @index5), @index0.map(@it:6:0, @index6)], @index0.map(@it:7:0, @index7)) \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_common_subexpr_comprehension_structure_retained.baseline b/optimizer/src/test/resources/subexpression_ast_block_common_subexpr_comprehension_structure_retained.baseline new file mode 100644 index 000000000..61dc23350 --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_common_subexpr_comprehension_structure_retained.baseline @@ -0,0 +1,3422 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + IDENT [11] { + name: @index0 + } + } + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CONSTANT [11] { value: 2 } + IDENT [12] { + name: @index0 + } + } + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + IDENT [15] { + name: @index0 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + IDENT [17] { + name: @index1 + } + } + } + CONSTANT [18] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + CALL [20] { + function: _+_ + args: { + CALL [21] { + function: _+_ + args: { + CONSTANT [22] { value: 5 } + IDENT [23] { + name: @index0 + } + } + } + IDENT [24] { + name: @index0 + } + } + } + IDENT [25] { + name: @index1 + } + } + } + IDENT [26] { + name: @index1 + } + } + } + IDENT [27] { + name: @index2 + } + } + } + IDENT [28] { + name: @index2 + } + } + } + CONSTANT [29] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: getFullYear + target: { + CALL [4] { + function: timestamp + args: { + CALL [5] { + function: int + args: { + CALL [6] { + function: timestamp + args: { + CONSTANT [7] { value: 1000000000 } + } + } + } + } + } + } + } + args: { + } + } + CALL [8] { + function: timestamp + args: { + CALL [9] { + function: int + args: { + CALL [10] { + function: timestamp + args: { + CONSTANT [11] { value: 50 } + } + } + } + } + } + } + CALL [12] { + function: getFullYear + target: { + CALL [13] { + function: timestamp + args: { + CALL [14] { + function: int + args: { + CALL [15] { + function: timestamp + args: { + CONSTANT [16] { value: 200 } + } + } + } + } + } + } + } + args: { + } + } + CALL [17] { + function: timestamp + args: { + CALL [18] { + function: int + args: { + CALL [19] { + function: timestamp + args: { + CONSTANT [20] { value: 75 } + } + } + } + } + } + } + } + } + CALL [21] { + function: _==_ + args: { + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + CALL [25] { + function: _+_ + args: { + CALL [26] { + function: _+_ + args: { + CALL [27] { + function: _+_ + args: { + CALL [28] { + function: _+_ + args: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @index0 + } + CALL [31] { + function: getFullYear + target: { + IDENT [32] { + name: @index3 + } + } + args: { + } + } + } + } + CALL [33] { + function: getFullYear + target: { + IDENT [34] { + name: @index1 + } + } + args: { + } + } + } + } + IDENT [35] { + name: @index0 + } + } + } + CALL [36] { + function: getSeconds + target: { + IDENT [37] { + name: @index1 + } + } + args: { + } + } + } + } + IDENT [38] { + name: @index2 + } + } + } + IDENT [39] { + name: @index2 + } + } + } + CALL [40] { + function: getMinutes + target: { + IDENT [41] { + name: @index3 + } + } + args: { + } + } + } + } + IDENT [42] { + name: @index0 + } + } + } + CONSTANT [43] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + } + } + CONSTANT [15] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "b" } + } + value: { + CONSTANT [6] { value: 1 } + } + } + } + MAP [7] { + MAP_ENTRY [8] { + key: { + CONSTANT [9] { value: "e" } + } + value: { + IDENT [10] { + name: @index0 + } + } + } + } + } + } + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "a" } + } + value: { + IDENT [14] { + name: @index0 + } + } + } + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "c" } + } + value: { + IDENT [17] { + name: @index0 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "d" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "e" } + } + value: { + IDENT [23] { + name: @index1 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + } + } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index1 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int32 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + SELECT [17] { + IDENT [18] { + name: msg + }.single_int64 + } + } + } + SELECT [19] { + SELECT [20] { + SELECT [21] { + IDENT [22] { + name: @index0 + }.oneof_type + }.payload + }.single_int64 + } + } + } + CONSTANT [23] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + } + } + CALL [9] { + function: _||_ + args: { + CALL [10] { + function: _||_ + args: { + CONSTANT [11] { value: true } + SELECT [12] { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: @index0 + }.payload + }.oneof_type + }.payload + }.single_bool + } + } + } + SELECT [17] { + SELECT [18] { + SELECT [19] { + SELECT [20] { + IDENT [21] { + name: @index0 + }.child + }.child + }.payload + }.single_bool + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CONSTANT [8] { value: 1 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + IDENT [14] { + name: @index0 + } + } + } + CONSTANT [15] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: 0 } + } + } + CALL [13] { + function: _[_] + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + CALL [16] { + function: _[_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 2 } + } + } + } + } + CONSTANT [19] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +SELECT [10] { + SELECT [9] { + SELECT [8] { + SELECT [7] { + SELECT [6] { + SELECT [5] { + SELECT [4] { + SELECT [3] { + SELECT [2] { + IDENT [1] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.single_int64 +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CONSTANT [12] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _?_:_ + args: { + CONSTANT [6] { value: false } + CONSTANT [7] { value: false } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: _*_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 2 } + } + } + } + } + CONSTANT [16] { value: 11 } + } + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _?_:_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index0 + } + IDENT [18] { + name: @index1 + } + } + } + CONSTANT [19] { value: 0 } + } + } + CONSTANT [20] { value: 0 } + } + } + CONSTANT [21] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + CALL [16] { + function: size + args: { + LIST [17] { + elements: { + IDENT [18] { + name: @index0 + } + } + } + } + } + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_range: { + LIST [20] { + elements: { + CONSTANT [21] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [22] { value: false } + } + loop_condition: { + CALL [23] { + function: @not_strictly_false + args: { + CALL [24] { + function: !_ + args: { + IDENT [25] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [26] { + function: _||_ + args: { + IDENT [27] { + name: @ac:0:0 + } + CALL [28] { + function: _>_ + args: { + IDENT [29] { + name: @it:0:0 + } + CONSTANT [30] { value: 1 } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + CALL [32] { + function: size + args: { + LIST [33] { + elements: { + IDENT [34] { + name: @index2 + } + } + } + } + } + } + } + CALL [35] { + function: _==_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index1 + } + IDENT [40] { + name: @index1 + } + } + } + IDENT [41] { + name: @index3 + } + } + } + IDENT [42] { + name: @index3 + } + } + } + CONSTANT [43] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + LIST [16] { + elements: { + IDENT [17] { + name: @index0 + } + } + } + COMPREHENSION [18] { + iter_var: @it:0:1 + iter_range: { + LIST [19] { + elements: { + CONSTANT [20] { value: "a" } + } + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [21] { value: false } + } + loop_condition: { + CALL [22] { + function: @not_strictly_false + args: { + CALL [23] { + function: !_ + args: { + IDENT [24] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [25] { + function: _||_ + args: { + IDENT [26] { + name: @ac:0:1 + } + CALL [27] { + function: _==_ + args: { + IDENT [28] { + name: @it:0:1 + } + CONSTANT [29] { value: "a" } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:0:1 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + CALL [33] { + function: _==_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + IDENT [37] { + name: @index1 + } + IDENT [38] { + name: @index1 + } + } + } + IDENT [39] { + name: @index3 + } + } + } + IDENT [40] { + name: @index3 + } + } + } + LIST [41] { + elements: { + CONSTANT [42] { value: true } + CONSTANT [43] { value: true } + CONSTANT [44] { value: true } + CONSTANT [45] { value: true } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @index0 + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _&&_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + LIST [22] { + elements: { + CONSTANT [23] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [24] { value: false } + } + loop_condition: { + CALL [25] { + function: @not_strictly_false + args: { + CALL [26] { + function: !_ + args: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [28] { + function: _||_ + args: { + IDENT [29] { + name: @ac:0:0 + } + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [37] { value: false } + } + loop_condition: { + CALL [38] { + function: @not_strictly_false + args: { + CALL [39] { + function: !_ + args: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [41] { + function: _||_ + args: { + IDENT [42] { + name: @ac:0:0 + } + CALL [43] { + function: _>_ + args: { + IDENT [44] { + name: @it:0:0 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + } + } + CALL [11] { + function: _==_ + args: { + COMPREHENSION [12] { + iter_var: @it:0:0 + iter_range: { + IDENT [13] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [14] { + elements: { + } + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @ac:0:0 + } + LIST [18] { + elements: { + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:1:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _+_ + args: { + IDENT [27] { + name: @it:1:0 + } + CONSTANT [28] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:0:0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + IDENT [33] { + name: @index1 + } + IDENT [34] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [31] { + function: _==_ + args: { + COMPREHENSION [30] { + iter_var: @it:0:0 + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [24] { + elements: { + } + } + } + loop_condition: { + CONSTANT [25] { value: true } + } + loop_step: { + CALL [28] { + function: _+_ + args: { + IDENT [26] { + name: @ac:0:0 + } + LIST [27] { + elements: { + COMPREHENSION [23] { + iter_var: @it:1:0 + iter_range: { + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [21] { + function: _?_:_ + args: { + CALL [13] { + function: _==_ + args: { + IDENT [12] { + name: @it:1:0 + } + IDENT [14] { + name: @it:0:0 + } + } + } + CALL [19] { + function: _+_ + args: { + IDENT [17] { + name: @ac:1:0 + } + LIST [18] { + elements: { + IDENT [11] { + name: @it:1:0 + } + } + } + } + } + IDENT [20] { + name: @ac:1:0 + } + } + } + } + result: { + IDENT [22] { + name: @ac:1:0 + } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:0:0 + } + } + } + LIST [32] { + elements: { + LIST [33] { + elements: { + CONSTANT [34] { value: 1 } + } + } + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + COMPREHENSION [7] { + iter_var: @it:0:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [9] { + elements: { + } + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @ac:0:0 + } + LIST [13] { + elements: { + COMPREHENSION [14] { + iter_var: @it:1:0 + iter_range: { + IDENT [15] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [16] { + elements: { + } + } + } + loop_condition: { + CONSTANT [17] { value: true } + } + loop_step: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @ac:1:0 + } + LIST [20] { + elements: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @it:1:0 + } + CONSTANT [23] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [24] { + name: @ac:1:0 + } + } + } + } + } + } + } + } + result: { + IDENT [25] { + name: @ac:0:0 + } + } + } + } + } + CALL [26] { + function: _==_ + args: { + IDENT [27] { + name: @index1 + } + IDENT [28] { + name: @index1 + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 1 } + IDENT [9] { + name: @index0 + } + } + } + } + } + CALL [10] { + function: _&&_ + args: { + CALL [11] { + function: _&&_ + args: { + IDENT [12] { + name: @index1 + } + CALL [13] { + function: @in + args: { + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: @in + args: { + CONSTANT [18] { value: 3 } + LIST [19] { + elements: { + CONSTANT [20] { value: 3 } + IDENT [21] { + name: @index0 + } + } + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 3 } + CONSTANT [8] { value: 4 } + } + } + LIST [9] { + elements: { + IDENT [10] { + name: @index1 + } + IDENT [11] { + name: @index1 + } + } + } + } + } + CALL [12] { + function: _==_ + args: { + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_range: { + IDENT [14] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @ac:0:0 + } + LIST [19] { + elements: { + COMPREHENSION [20] { + iter_var: @it:1:0 + iter_range: { + IDENT [21] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:1:0 + } + LIST [26] { + elements: { + IDENT [27] { + name: @index1 + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:1:0 + } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:0:0 + } + } + } + LIST [30] { + elements: { + IDENT [31] { + name: @index2 + } + IDENT [32] { + name: @index2 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _-_ + args: { + IDENT [4] { + name: x + } + CONSTANT [5] { value: 1 } + } + } + CALL [6] { + function: _>_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: 3 } + } + } + } + } + CALL [9] { + function: _||_ + args: { + COMPREHENSION [10] { + iter_var: @it:0:0 + iter_range: { + LIST [11] { + elements: { + CALL [12] { + function: _?_:_ + args: { + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [16] { value: false } + } + loop_condition: { + CALL [17] { + function: @not_strictly_false + args: { + CALL [18] { + function: !_ + args: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [20] { + function: _||_ + args: { + IDENT [21] { + name: @ac:0:0 + } + CALL [22] { + function: _>_ + args: { + CALL [23] { + function: _-_ + args: { + IDENT [24] { + name: @it:0:0 + } + CONSTANT [25] { value: 1 } + } + } + CONSTANT [26] { value: 3 } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:0:0 + } + } + } + IDENT [28] { + name: @index1 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +COMPREHENSION [35] { + iter_var: @it:0:0 + iter_range: { + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [15] { + name: @ac:1:0 + } + LIST [16] { + elements: { + LIST [6] { + elements: { + CALL [8] { + function: _+_ + args: { + IDENT [7] { + name: @it:1:0 + } + IDENT [9] { + name: @it:1:0 + } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [10] { + name: @it:1:0 + } + IDENT [12] { + name: @it:1:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @ac:1:0 + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @ac:0:0 + } + LIST [32] { + elements: { + LIST [22] { + elements: { + CALL [24] { + function: _+_ + args: { + IDENT [23] { + name: @it:0:0 + } + IDENT [25] { + name: @it:0:0 + } + } + } + CALL [27] { + function: _+_ + args: { + IDENT [26] { + name: @it:0:0 + } + IDENT [28] { + name: @it:0:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:0:0 + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.payload~presence_test + } + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload + }.single_int64 + } + CONSTANT [12] { value: 0 } + } + } + CONSTANT [13] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: @index0 + }.payload + }.single_int64 + } + } + } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _?_:_ + args: { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload~presence_test + } + IDENT [12] { + name: @index1 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + } + } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _?_:_ + args: { + SELECT [10] { + IDENT [11] { + name: @index0 + }.single_int64~presence_test + } + IDENT [12] { + name: @index1 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.map_string_string + } + } + } + CALL [9] { + function: _?_:_ + args: { + CALL [10] { + function: _&&_ + args: { + CALL [11] { + function: _&&_ + args: { + SELECT [12] { + IDENT [13] { + name: msg + }.oneof_type~presence_test + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.payload~presence_test + } + } + } + SELECT [16] { + IDENT [17] { + name: @index1 + }.single_int64~presence_test + } + } + } + CALL [18] { + function: _?_:_ + args: { + CALL [19] { + function: _&&_ + args: { + SELECT [20] { + IDENT [21] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [22] { + IDENT [23] { + name: @index2 + }.key~presence_test + } + } + } + CALL [24] { + function: _==_ + args: { + SELECT [25] { + IDENT [26] { + name: @index2 + }.key + } + CONSTANT [27] { value: "A" } + } + } + CONSTANT [28] { value: false } + } + } + CONSTANT [29] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: optional.none + args: { + } + } + LIST [4] { + elements: { + IDENT [5] { + name: @index0 + } + IDENT [6] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [7] { + elements: { + CONSTANT [8] { value: 5 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + LIST [10] { + elements: { + CONSTANT [11] { value: 10 } + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + optional_indices: [0] + } + LIST [15] { + elements: { + CONSTANT [16] { value: 10 } + IDENT [17] { + name: @index2 + } + IDENT [18] { + name: @index2 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "hello" } + } + optional_entry: true + value: { + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "hello" } + } + } + } + } + } + CONSTANT [9] { value: "hello" } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: orValue + target: { + CALL [9] { + function: or + target: { + CALL [10] { + function: _[?_] + args: { + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "key" } + } + optional_entry: true + value: { + CALL [14] { + function: optional.of + args: { + CONSTANT [15] { value: "test" } + } + } + } + } + } + CONSTANT [16] { value: "bogus" } + } + } + } + args: { + CALL [17] { + function: _[?_] + args: { + IDENT [18] { + name: @index0 + } + CONSTANT [19] { value: "bogus" } + } + } + } + } + } + args: { + CALL [20] { + function: _[_] + args: { + IDENT [21] { + name: @index0 + } + CONSTANT [22] { value: "key" } + } + } + } + } + CONSTANT [23] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int64 + } + } + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + IDENT [16] { + name: @index0 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [2] { + function: matches + target: { + CONSTANT [1] { value: "hello world" } + } + args: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [3] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CONSTANT [13] { value: "hello" } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CALL [20] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CONSTANT [13] { value: "w" } + CONSTANT [15] { value: "o" } + } + } + CONSTANT [17] { value: "r" } + } + } + CONSTANT [19] { value: "l" } + } + } + CONSTANT [21] { value: "d" } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: non_pure_custom_func + args: { + IDENT [12] { + name: @index1 + } + } + } + CALL [13] { + function: non_pure_custom_func + args: { + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int32 + } + } + } + } + } + CALL [16] { + function: non_pure_custom_func + args: { + IDENT [17] { + name: @index1 + } + } + } + } + } + CALL [18] { + function: non_pure_custom_func + args: { + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + CALL [6] { + function: pure_custom_func + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.single_int64 + } + } + } + } + } + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index1 + } + CALL [13] { + function: pure_custom_func + args: { + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int32 + } + } + } + } + } + IDENT [16] { + name: @index1 + } + } + } + CALL [17] { + function: pure_custom_func + args: { + SELECT [18] { + IDENT [19] { + name: msg + }.single_int64 + } + } + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_common_subexpr_only.baseline b/optimizer/src/test/resources/subexpression_ast_block_common_subexpr_only.baseline new file mode 100644 index 000000000..9782b5dc2 --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_common_subexpr_only.baseline @@ -0,0 +1,4758 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + IDENT [11] { + name: @index0 + } + } + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CONSTANT [11] { value: 2 } + IDENT [12] { + name: @index0 + } + } + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + IDENT [15] { + name: @index0 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + IDENT [17] { + name: @index1 + } + } + } + CONSTANT [18] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + CALL [20] { + function: _+_ + args: { + CALL [21] { + function: _+_ + args: { + CONSTANT [22] { value: 5 } + IDENT [23] { + name: @index0 + } + } + } + IDENT [24] { + name: @index0 + } + } + } + IDENT [25] { + name: @index1 + } + } + } + IDENT [26] { + name: @index1 + } + } + } + IDENT [27] { + name: @index2 + } + } + } + IDENT [28] { + name: @index2 + } + } + } + CONSTANT [29] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: getFullYear + target: { + CALL [4] { + function: timestamp + args: { + CALL [5] { + function: int + args: { + CALL [6] { + function: timestamp + args: { + CONSTANT [7] { value: 1000000000 } + } + } + } + } + } + } + } + args: { + } + } + CALL [8] { + function: timestamp + args: { + CALL [9] { + function: int + args: { + CALL [10] { + function: timestamp + args: { + CONSTANT [11] { value: 50 } + } + } + } + } + } + } + CALL [12] { + function: getFullYear + target: { + CALL [13] { + function: timestamp + args: { + CALL [14] { + function: int + args: { + CALL [15] { + function: timestamp + args: { + CONSTANT [16] { value: 200 } + } + } + } + } + } + } + } + args: { + } + } + CALL [17] { + function: timestamp + args: { + CALL [18] { + function: int + args: { + CALL [19] { + function: timestamp + args: { + CONSTANT [20] { value: 75 } + } + } + } + } + } + } + } + } + CALL [21] { + function: _==_ + args: { + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + CALL [25] { + function: _+_ + args: { + CALL [26] { + function: _+_ + args: { + CALL [27] { + function: _+_ + args: { + CALL [28] { + function: _+_ + args: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @index0 + } + CALL [31] { + function: getFullYear + target: { + IDENT [32] { + name: @index3 + } + } + args: { + } + } + } + } + CALL [33] { + function: getFullYear + target: { + IDENT [34] { + name: @index1 + } + } + args: { + } + } + } + } + IDENT [35] { + name: @index0 + } + } + } + CALL [36] { + function: getSeconds + target: { + IDENT [37] { + name: @index1 + } + } + args: { + } + } + } + } + IDENT [38] { + name: @index2 + } + } + } + IDENT [39] { + name: @index2 + } + } + } + CALL [40] { + function: getMinutes + target: { + IDENT [41] { + name: @index3 + } + } + args: { + } + } + } + } + IDENT [42] { + name: @index0 + } + } + } + CONSTANT [43] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + } + } + CONSTANT [15] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "b" } + } + value: { + CONSTANT [6] { value: 1 } + } + } + } + MAP [7] { + MAP_ENTRY [8] { + key: { + CONSTANT [9] { value: "e" } + } + value: { + IDENT [10] { + name: @index0 + } + } + } + } + } + } + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "a" } + } + value: { + IDENT [14] { + name: @index0 + } + } + } + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "c" } + } + value: { + IDENT [17] { + name: @index0 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "d" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "e" } + } + value: { + IDENT [23] { + name: @index1 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + } + } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index1 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int32 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + SELECT [17] { + IDENT [18] { + name: msg + }.single_int64 + } + } + } + SELECT [19] { + SELECT [20] { + SELECT [21] { + IDENT [22] { + name: @index0 + }.oneof_type + }.payload + }.single_int64 + } + } + } + CONSTANT [23] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + } + } + CALL [9] { + function: _||_ + args: { + CALL [10] { + function: _||_ + args: { + CONSTANT [11] { value: true } + SELECT [12] { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: @index0 + }.payload + }.oneof_type + }.payload + }.single_bool + } + } + } + SELECT [17] { + SELECT [18] { + SELECT [19] { + SELECT [20] { + IDENT [21] { + name: @index0 + }.child + }.child + }.payload + }.single_bool + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CONSTANT [8] { value: 1 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + IDENT [14] { + name: @index0 + } + } + } + CONSTANT [15] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: 0 } + } + } + CALL [13] { + function: _[_] + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + CALL [16] { + function: _[_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 2 } + } + } + } + } + CONSTANT [19] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +SELECT [10] { + SELECT [9] { + SELECT [8] { + SELECT [7] { + SELECT [6] { + SELECT [5] { + SELECT [4] { + SELECT [3] { + SELECT [2] { + IDENT [1] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.single_int64 +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CONSTANT [12] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _?_:_ + args: { + CONSTANT [6] { value: false } + CONSTANT [7] { value: false } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: _*_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 2 } + } + } + } + } + CONSTANT [16] { value: 11 } + } + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _?_:_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index0 + } + IDENT [18] { + name: @index1 + } + } + } + CONSTANT [19] { value: 0 } + } + } + CONSTANT [20] { value: 0 } + } + } + CONSTANT [21] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + CALL [16] { + function: size + args: { + LIST [17] { + elements: { + IDENT [18] { + name: @index0 + } + } + } + } + } + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_range: { + LIST [20] { + elements: { + CONSTANT [21] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [22] { value: false } + } + loop_condition: { + CALL [23] { + function: @not_strictly_false + args: { + CALL [24] { + function: !_ + args: { + IDENT [25] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [26] { + function: _||_ + args: { + IDENT [27] { + name: @ac:0:0 + } + CALL [28] { + function: _>_ + args: { + IDENT [29] { + name: @it:0:0 + } + CONSTANT [30] { value: 1 } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + CALL [32] { + function: size + args: { + LIST [33] { + elements: { + IDENT [34] { + name: @index2 + } + } + } + } + } + } + } + CALL [35] { + function: _==_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index1 + } + IDENT [40] { + name: @index1 + } + } + } + IDENT [41] { + name: @index3 + } + } + } + IDENT [42] { + name: @index3 + } + } + } + CONSTANT [43] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + LIST [16] { + elements: { + IDENT [17] { + name: @index0 + } + } + } + COMPREHENSION [18] { + iter_var: @it:0:1 + iter_range: { + LIST [19] { + elements: { + CONSTANT [20] { value: "a" } + } + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [21] { value: false } + } + loop_condition: { + CALL [22] { + function: @not_strictly_false + args: { + CALL [23] { + function: !_ + args: { + IDENT [24] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [25] { + function: _||_ + args: { + IDENT [26] { + name: @ac:0:1 + } + CALL [27] { + function: _==_ + args: { + IDENT [28] { + name: @it:0:1 + } + CONSTANT [29] { value: "a" } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:0:1 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + CALL [33] { + function: _==_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + IDENT [37] { + name: @index1 + } + IDENT [38] { + name: @index1 + } + } + } + IDENT [39] { + name: @index3 + } + } + } + IDENT [40] { + name: @index3 + } + } + } + LIST [41] { + elements: { + CONSTANT [42] { value: true } + CONSTANT [43] { value: true } + CONSTANT [44] { value: true } + CONSTANT [45] { value: true } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @index0 + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _&&_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + LIST [22] { + elements: { + CONSTANT [23] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [24] { value: false } + } + loop_condition: { + CALL [25] { + function: @not_strictly_false + args: { + CALL [26] { + function: !_ + args: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [28] { + function: _||_ + args: { + IDENT [29] { + name: @ac:0:0 + } + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [37] { value: false } + } + loop_condition: { + CALL [38] { + function: @not_strictly_false + args: { + CALL [39] { + function: !_ + args: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [41] { + function: _||_ + args: { + IDENT [42] { + name: @ac:0:0 + } + CALL [43] { + function: _>_ + args: { + IDENT [44] { + name: @it:0:0 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>=_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + CALL [20] { + function: size + args: { + LIST [21] { + elements: { + IDENT [22] { + name: @index0 + } + } + } + } + } + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [24] { + elements: { + CONSTANT [25] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [26] { value: false } + } + loop_condition: { + CALL [27] { + function: @not_strictly_false + args: { + CALL [28] { + function: !_ + args: { + IDENT [29] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [30] { + function: _||_ + args: { + IDENT [31] { + name: @ac:0:0 + } + CALL [32] { + function: _&&_ + args: { + CALL [33] { + function: _>_ + args: { + IDENT [34] { + name: @it:0:0 + } + CONSTANT [35] { value: 1 } + } + } + CALL [36] { + function: _>=_ + args: { + IDENT [37] { + name: @it2:0:0 + } + CONSTANT [38] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [39] { + name: @ac:0:0 + } + } + } + CALL [40] { + function: size + args: { + LIST [41] { + elements: { + IDENT [42] { + name: @index2 + } + } + } + } + } + } + } + CALL [43] { + function: _==_ + args: { + CALL [44] { + function: _+_ + args: { + CALL [45] { + function: _+_ + args: { + CALL [46] { + function: _+_ + args: { + IDENT [47] { + name: @index1 + } + IDENT [48] { + name: @index1 + } + } + } + IDENT [49] { + name: @index3 + } + } + } + IDENT [50] { + name: @index3 + } + } + } + CONSTANT [51] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + CALL [20] { + function: _&&_ + args: { + CALL [21] { + function: _&&_ + args: { + IDENT [22] { + name: @index0 + } + IDENT [23] { + name: @index0 + } + } + } + CALL [24] { + function: _&&_ + args: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [26] { + elements: { + CONSTANT [27] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [28] { value: false } + } + loop_condition: { + CALL [29] { + function: @not_strictly_false + args: { + CALL [30] { + function: !_ + args: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [32] { + function: _||_ + args: { + IDENT [33] { + name: @ac:0:0 + } + CALL [34] { + function: _&&_ + args: { + CALL [35] { + function: _>_ + args: { + IDENT [36] { + name: @it:0:0 + } + CONSTANT [37] { value: 1 } + } + } + CALL [38] { + function: _>_ + args: { + IDENT [39] { + name: @it2:0:0 + } + CONSTANT [40] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:0:0 + } + } + } + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [43] { + elements: { + CONSTANT [44] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [45] { value: false } + } + loop_condition: { + CALL [46] { + function: @not_strictly_false + args: { + CALL [47] { + function: !_ + args: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [49] { + function: _||_ + args: { + IDENT [50] { + name: @ac:0:0 + } + CALL [51] { + function: _&&_ + args: { + CALL [52] { + function: _>_ + args: { + IDENT [53] { + name: @it:0:0 + } + CONSTANT [54] { value: 1 } + } + } + CALL [55] { + function: _>_ + args: { + IDENT [56] { + name: @it2:0:0 + } + CONSTANT [57] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [58] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + } + } + CALL [11] { + function: _==_ + args: { + COMPREHENSION [12] { + iter_var: @it:1:0 + iter_range: { + IDENT [13] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [14] { + elements: { + } + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @ac:1:0 + } + LIST [18] { + elements: { + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:0:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _+_ + args: { + IDENT [27] { + name: @it:0:0 + } + CONSTANT [28] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:1:0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + IDENT [33] { + name: @index1 + } + IDENT [34] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [31] { + function: _==_ + args: { + COMPREHENSION [30] { + iter_var: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @result + accu_init: { + LIST [24] { + elements: { + } + } + } + loop_condition: { + CONSTANT [25] { value: true } + } + loop_step: { + CALL [28] { + function: _+_ + args: { + IDENT [26] { + name: @result + } + LIST [27] { + elements: { + COMPREHENSION [23] { + iter_var: x + iter_range: { + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + } + } + } + accu_var: @result + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [21] { + function: _?_:_ + args: { + CALL [13] { + function: _==_ + args: { + IDENT [12] { + name: x + } + IDENT [14] { + name: y + } + } + } + CALL [19] { + function: _+_ + args: { + IDENT [17] { + name: @result + } + LIST [18] { + elements: { + IDENT [11] { + name: x + } + } + } + } + } + IDENT [20] { + name: @result + } + } + } + } + result: { + IDENT [22] { + name: @result + } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @result + } + } + } + LIST [32] { + elements: { + LIST [33] { + elements: { + CONSTANT [34] { value: 1 } + } + } + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + } + } + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @index0 + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:1:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _*_ + args: { + IDENT [27] { + name: @it:1:0 + } + CONSTANT [28] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + } + } + CALL [11] { + function: _==_ + args: { + COMPREHENSION [12] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [13] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [14] { + elements: { + } + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @ac:1:0 + } + LIST [18] { + elements: { + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:0:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _+_ + args: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @it:0:0 + } + IDENT [29] { + name: @it2:0:0 + } + } + } + CONSTANT [30] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1:0 + } + } + } + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + IDENT [35] { + name: @index1 + } + IDENT [36] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [36] { + function: _==_ + args: { + COMPREHENSION [35] { + iter_var: i + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + COMPREHENSION [28] { + iter_var: x + iter_range: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + CONSTANT [10] { value: 3 } + } + } + } + accu_var: @result + accu_init: { + LIST [20] { + elements: { + } + } + } + loop_condition: { + CONSTANT [21] { value: true } + } + loop_step: { + CALL [26] { + function: _?_:_ + args: { + CALL [16] { + function: _&&_ + args: { + CALL [14] { + function: _==_ + args: { + IDENT [13] { + name: x + } + IDENT [15] { + name: y + } + } + } + CALL [18] { + function: _<_ + args: { + IDENT [17] { + name: i + } + IDENT [19] { + name: y + } + } + } + } + } + CALL [24] { + function: _+_ + args: { + IDENT [22] { + name: @result + } + LIST [23] { + elements: { + IDENT [12] { + name: x + } + } + } + } + } + IDENT [25] { + name: @result + } + } + } + } + result: { + IDENT [27] { + name: @result + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } + } + LIST [37] { + elements: { + LIST [38] { + elements: { + CONSTANT [39] { value: 1 } + } + } + LIST [40] { + elements: { + CONSTANT [41] { value: 2 } + } + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + COMPREHENSION [7] { + iter_var: @it:1:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [9] { + elements: { + } + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @ac:1:0 + } + LIST [13] { + elements: { + COMPREHENSION [14] { + iter_var: @it:0:0 + iter_range: { + IDENT [15] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [16] { + elements: { + } + } + } + loop_condition: { + CONSTANT [17] { value: true } + } + loop_step: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @ac:0:0 + } + LIST [20] { + elements: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @it:0:0 + } + CONSTANT [23] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [25] { + name: @ac:1:0 + } + } + } + } + } + CALL [26] { + function: _==_ + args: { + IDENT [27] { + name: @index1 + } + IDENT [28] { + name: @index1 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + COMPREHENSION [7] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [9] { + + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: cel.@mapInsert + args: { + IDENT [12] { + name: @ac:1:0 + } + IDENT [13] { + name: @it:1:0 + } + COMPREHENSION [14] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [15] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [16] { + + } + } + loop_condition: { + CONSTANT [17] { value: true } + } + loop_step: { + CALL [18] { + function: cel.@mapInsert + args: { + IDENT [19] { + name: @ac:0:0 + } + IDENT [20] { + name: @it:0:0 + } + CALL [21] { + function: _+_ + args: { + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @it:0:0 + } + IDENT [24] { + name: @it2:0:0 + } + } + } + CONSTANT [25] { value: 1 } + } + } + } + } + } + result: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:1:0 + } + } + } + } + } + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @index1 + } + IDENT [30] { + name: @index1 + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 1 } + IDENT [9] { + name: @index0 + } + } + } + } + } + CALL [10] { + function: _&&_ + args: { + CALL [11] { + function: _&&_ + args: { + IDENT [12] { + name: @index1 + } + CALL [13] { + function: @in + args: { + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: @in + args: { + CONSTANT [18] { value: 3 } + LIST [19] { + elements: { + CONSTANT [20] { value: 3 } + IDENT [21] { + name: @index0 + } + } + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 3 } + CONSTANT [8] { value: 4 } + } + } + LIST [9] { + elements: { + IDENT [10] { + name: @index1 + } + IDENT [11] { + name: @index1 + } + } + } + } + } + CALL [12] { + function: _==_ + args: { + COMPREHENSION [13] { + iter_var: @it:1:0 + iter_range: { + IDENT [14] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @ac:1:0 + } + LIST [19] { + elements: { + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_range: { + IDENT [21] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:0:0 + } + LIST [26] { + elements: { + IDENT [27] { + name: @index1 + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + LIST [30] { + elements: { + IDENT [31] { + name: @index2 + } + IDENT [32] { + name: @index2 + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 3 } + CONSTANT [8] { value: 4 } + } + } + LIST [9] { + elements: { + IDENT [10] { + name: @index1 + } + IDENT [11] { + name: @index1 + } + } + } + } + } + CALL [12] { + function: _==_ + args: { + COMPREHENSION [13] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [14] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @ac:1:0 + } + LIST [19] { + elements: { + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [21] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:0:0 + } + LIST [26] { + elements: { + IDENT [27] { + name: @index1 + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + LIST [30] { + elements: { + IDENT [31] { + name: @index2 + } + IDENT [32] { + name: @index2 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _-_ + args: { + IDENT [4] { + name: x + } + CONSTANT [5] { value: 1 } + } + } + CALL [6] { + function: _>_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: 3 } + } + } + } + } + CALL [9] { + function: _||_ + args: { + COMPREHENSION [10] { + iter_var: @it:0:0 + iter_range: { + LIST [11] { + elements: { + CALL [12] { + function: _?_:_ + args: { + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [16] { value: false } + } + loop_condition: { + CALL [17] { + function: @not_strictly_false + args: { + CALL [18] { + function: !_ + args: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [20] { + function: _||_ + args: { + IDENT [21] { + name: @ac:0:0 + } + CALL [22] { + function: _>_ + args: { + CALL [23] { + function: _-_ + args: { + IDENT [24] { + name: @it:0:0 + } + CONSTANT [25] { value: 1 } + } + } + CONSTANT [26] { value: 3 } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:0:0 + } + } + } + IDENT [28] { + name: @index1 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [15] { + name: @result + } + LIST [16] { + elements: { + LIST [6] { + elements: { + CALL [8] { + function: _+_ + args: { + IDENT [7] { + name: x + } + IDENT [9] { + name: x + } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [10] { + name: x + } + IDENT [12] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + LIST [22] { + elements: { + CALL [24] { + function: _+_ + args: { + IDENT [23] { + name: x + } + IDENT [25] { + name: x + } + } + } + CALL [27] { + function: _+_ + args: { + IDENT [26] { + name: x + } + IDENT [28] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _-_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + IDENT [6] { + name: y + } + } + } + CONSTANT [7] { value: 1 } + } + } + CALL [8] { + function: _>_ + args: { + IDENT [9] { + name: @index0 + } + CONSTANT [10] { value: 3 } + } + } + } + } + CALL [11] { + function: _||_ + args: { + COMPREHENSION [12] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [13] { + elements: { + CALL [14] { + function: _?_:_ + args: { + IDENT [15] { + name: @index1 + } + IDENT [16] { + name: @index0 + } + CONSTANT [17] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [18] { value: false } + } + loop_condition: { + CALL [19] { + function: @not_strictly_false + args: { + CALL [20] { + function: !_ + args: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [22] { + function: _||_ + args: { + IDENT [23] { + name: @ac:0:0 + } + CALL [24] { + function: _>_ + args: { + CALL [25] { + function: _-_ + args: { + CALL [26] { + function: _-_ + args: { + IDENT [27] { + name: @it:0:0 + } + IDENT [28] { + name: @it2:0:0 + } + } + } + CONSTANT [29] { value: 1 } + } + } + CONSTANT [30] { value: 3 } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + IDENT [32] { + name: @index1 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_var2: y + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + MAP [14] { + + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [17] { + function: cel.@mapInsert + args: { + IDENT [16] { + name: @result + } + IDENT [5] { + name: x + } + LIST [7] { + elements: { + CALL [9] { + function: _+_ + args: { + IDENT [8] { + name: x + } + IDENT [10] { + name: x + } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [11] { + name: y + } + IDENT [13] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + MAP [30] { + + } + } + loop_condition: { + CONSTANT [31] { value: true } + } + loop_step: { + CALL [33] { + function: cel.@mapInsert + args: { + IDENT [32] { + name: @result + } + IDENT [21] { + name: x + } + LIST [23] { + elements: { + CALL [25] { + function: _+_ + args: { + IDENT [24] { + name: x + } + IDENT [26] { + name: x + } + } + } + CALL [28] { + function: _+_ + args: { + IDENT [27] { + name: y + } + IDENT [29] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.payload~presence_test + } + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload + }.single_int64 + } + CONSTANT [12] { value: 0 } + } + } + CONSTANT [13] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: @index0 + }.payload + }.single_int64 + } + } + } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _?_:_ + args: { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload~presence_test + } + IDENT [12] { + name: @index1 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + } + } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _?_:_ + args: { + SELECT [10] { + IDENT [11] { + name: @index0 + }.single_int64~presence_test + } + IDENT [12] { + name: @index1 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.map_string_string + } + } + } + CALL [9] { + function: _?_:_ + args: { + CALL [10] { + function: _&&_ + args: { + CALL [11] { + function: _&&_ + args: { + SELECT [12] { + IDENT [13] { + name: msg + }.oneof_type~presence_test + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.payload~presence_test + } + } + } + SELECT [16] { + IDENT [17] { + name: @index1 + }.single_int64~presence_test + } + } + } + CALL [18] { + function: _?_:_ + args: { + CALL [19] { + function: _&&_ + args: { + SELECT [20] { + IDENT [21] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [22] { + IDENT [23] { + name: @index2 + }.key~presence_test + } + } + } + CALL [24] { + function: _==_ + args: { + SELECT [25] { + IDENT [26] { + name: @index2 + }.key + } + CONSTANT [27] { value: "A" } + } + } + CONSTANT [28] { value: false } + } + } + CONSTANT [29] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: optional.none + args: { + } + } + LIST [4] { + elements: { + IDENT [5] { + name: @index0 + } + IDENT [6] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [7] { + elements: { + CONSTANT [8] { value: 5 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + LIST [10] { + elements: { + CONSTANT [11] { value: 10 } + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + optional_indices: [0] + } + LIST [15] { + elements: { + CONSTANT [16] { value: 10 } + IDENT [17] { + name: @index2 + } + IDENT [18] { + name: @index2 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "hello" } + } + optional_entry: true + value: { + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "hello" } + } + } + } + } + } + CONSTANT [9] { value: "hello" } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: orValue + target: { + CALL [9] { + function: or + target: { + CALL [10] { + function: _[?_] + args: { + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "key" } + } + optional_entry: true + value: { + CALL [14] { + function: optional.of + args: { + CONSTANT [15] { value: "test" } + } + } + } + } + } + CONSTANT [16] { value: "bogus" } + } + } + } + args: { + CALL [17] { + function: _[?_] + args: { + IDENT [18] { + name: @index0 + } + CONSTANT [19] { value: "bogus" } + } + } + } + } + } + args: { + CALL [20] { + function: _[_] + args: { + IDENT [21] { + name: @index0 + } + CONSTANT [22] { value: "key" } + } + } + } + } + CONSTANT [23] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int64 + } + } + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + IDENT [16] { + name: @index0 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [2] { + function: matches + target: { + CONSTANT [1] { value: "hello world" } + } + args: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [3] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CONSTANT [13] { value: "hello" } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CALL [20] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CONSTANT [13] { value: "w" } + CONSTANT [15] { value: "o" } + } + } + CONSTANT [17] { value: "r" } + } + } + CONSTANT [19] { value: "l" } + } + } + CONSTANT [21] { value: "d" } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: non_pure_custom_func + args: { + IDENT [12] { + name: @index1 + } + } + } + CALL [13] { + function: non_pure_custom_func + args: { + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int32 + } + } + } + } + } + CALL [16] { + function: non_pure_custom_func + args: { + IDENT [17] { + name: @index1 + } + } + } + } + } + CALL [18] { + function: non_pure_custom_func + args: { + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + CALL [6] { + function: pure_custom_func + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.single_int64 + } + } + } + } + } + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index1 + } + CALL [13] { + function: pure_custom_func + args: { + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int32 + } + } + } + } + } + IDENT [16] { + name: @index1 + } + } + } + CALL [17] { + function: pure_custom_func + args: { + SELECT [18] { + IDENT [19] { + name: msg + }.single_int64 + } + } + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_1.baseline b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_1.baseline new file mode 100644 index 000000000..1b3146069 --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_1.baseline @@ -0,0 +1,6108 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + } + } + CALL [6] { + function: size + args: { + IDENT [7] { + name: @index0 + } + } + } + CALL [8] { + function: _+_ + args: { + IDENT [9] { + name: @index1 + } + IDENT [10] { + name: @index1 + } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index2 + } + CONSTANT [13] { value: 1 } + } + } + } + } + CALL [14] { + function: _==_ + args: { + IDENT [15] { + name: @index3 + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + } + } + CALL [6] { + function: size + args: { + IDENT [7] { + name: @index0 + } + } + } + CALL [8] { + function: _+_ + args: { + CONSTANT [9] { value: 2 } + IDENT [10] { + name: @index1 + } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index2 + } + IDENT [13] { + name: @index1 + } + } + } + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index3 + } + CONSTANT [16] { value: 1 } + } + } + } + } + CALL [17] { + function: _==_ + args: { + IDENT [18] { + name: @index4 + } + CONSTANT [19] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 0 } + } + } + CALL [5] { + function: size + args: { + IDENT [6] { + name: @index0 + } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + CALL [10] { + function: size + args: { + IDENT [11] { + name: @index2 + } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index4 + } + IDENT [17] { + name: @index3 + } + } + } + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @index5 + } + IDENT [20] { + name: @index3 + } + } + } + } + } + CALL [21] { + function: _==_ + args: { + IDENT [22] { + name: @index6 + } + CONSTANT [23] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 0 } + } + } + CALL [5] { + function: size + args: { + IDENT [6] { + name: @index0 + } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + CALL [10] { + function: size + args: { + IDENT [11] { + name: @index2 + } + } + } + LIST [12] { + elements: { + CONSTANT [13] { value: 1 } + CONSTANT [14] { value: 2 } + CONSTANT [15] { value: 3 } + } + } + CALL [16] { + function: size + args: { + IDENT [17] { + name: @index4 + } + } + } + CALL [18] { + function: _+_ + args: { + CONSTANT [19] { value: 5 } + IDENT [20] { + name: @index1 + } + } + } + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @index6 + } + IDENT [23] { + name: @index1 + } + } + } + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @index7 + } + IDENT [26] { + name: @index3 + } + } + } + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @index8 + } + IDENT [29] { + name: @index3 + } + } + } + CALL [30] { + function: _+_ + args: { + IDENT [31] { + name: @index9 + } + IDENT [32] { + name: @index5 + } + } + } + CALL [33] { + function: _+_ + args: { + IDENT [34] { + name: @index10 + } + IDENT [35] { + name: @index5 + } + } + } + } + } + CALL [36] { + function: _==_ + args: { + IDENT [37] { + name: @index11 + } + CONSTANT [38] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: timestamp + args: { + CONSTANT [4] { value: 1000000000 } + } + } + CALL [5] { + function: int + args: { + IDENT [6] { + name: @index0 + } + } + } + CALL [7] { + function: timestamp + args: { + IDENT [8] { + name: @index1 + } + } + } + CALL [9] { + function: getFullYear + target: { + IDENT [10] { + name: @index2 + } + } + args: { + } + } + CALL [11] { + function: timestamp + args: { + CONSTANT [12] { value: 50 } + } + } + CALL [13] { + function: int + args: { + IDENT [14] { + name: @index4 + } + } + } + CALL [15] { + function: timestamp + args: { + IDENT [16] { + name: @index5 + } + } + } + CALL [17] { + function: timestamp + args: { + CONSTANT [18] { value: 200 } + } + } + CALL [19] { + function: int + args: { + IDENT [20] { + name: @index7 + } + } + } + CALL [21] { + function: timestamp + args: { + IDENT [22] { + name: @index8 + } + } + } + CALL [23] { + function: getFullYear + target: { + IDENT [24] { + name: @index9 + } + } + args: { + } + } + CALL [25] { + function: timestamp + args: { + CONSTANT [26] { value: 75 } + } + } + CALL [27] { + function: int + args: { + IDENT [28] { + name: @index11 + } + } + } + CALL [29] { + function: timestamp + args: { + IDENT [30] { + name: @index12 + } + } + } + CALL [31] { + function: getFullYear + target: { + IDENT [32] { + name: @index13 + } + } + args: { + } + } + CALL [33] { + function: _+_ + args: { + IDENT [34] { + name: @index3 + } + IDENT [35] { + name: @index14 + } + } + } + CALL [36] { + function: getFullYear + target: { + IDENT [37] { + name: @index6 + } + } + args: { + } + } + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index15 + } + IDENT [40] { + name: @index16 + } + } + } + CALL [41] { + function: _+_ + args: { + IDENT [42] { + name: @index17 + } + IDENT [43] { + name: @index3 + } + } + } + CALL [44] { + function: getSeconds + target: { + IDENT [45] { + name: @index6 + } + } + args: { + } + } + CALL [46] { + function: _+_ + args: { + IDENT [47] { + name: @index18 + } + IDENT [48] { + name: @index19 + } + } + } + CALL [49] { + function: _+_ + args: { + IDENT [50] { + name: @index20 + } + IDENT [51] { + name: @index10 + } + } + } + CALL [52] { + function: _+_ + args: { + IDENT [53] { + name: @index21 + } + IDENT [54] { + name: @index10 + } + } + } + CALL [55] { + function: getMinutes + target: { + IDENT [56] { + name: @index13 + } + } + args: { + } + } + CALL [57] { + function: _+_ + args: { + IDENT [58] { + name: @index22 + } + IDENT [59] { + name: @index23 + } + } + } + CALL [60] { + function: _+_ + args: { + IDENT [61] { + name: @index24 + } + IDENT [62] { + name: @index3 + } + } + } + } + } + CALL [63] { + function: _==_ + args: { + IDENT [64] { + name: @index25 + } + CONSTANT [65] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: 2 } + } + } + } + CALL [7] { + function: _[_] + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: "a" } + } + } + CALL [10] { + function: _*_ + args: { + IDENT [11] { + name: @index1 + } + IDENT [12] { + name: @index1 + } + } + } + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index1 + } + IDENT [15] { + name: @index2 + } + } + } + } + } + CALL [16] { + function: _==_ + args: { + IDENT [17] { + name: @index3 + } + CONSTANT [18] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "b" } + } + value: { + CONSTANT [6] { value: 1 } + } + } + } + MAP [7] { + MAP_ENTRY [8] { + key: { + CONSTANT [9] { value: "e" } + } + value: { + IDENT [10] { + name: @index0 + } + } + } + } + } + } + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "a" } + } + value: { + IDENT [14] { + name: @index0 + } + } + } + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "c" } + } + value: { + IDENT [17] { + name: @index0 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "d" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "e" } + } + value: { + IDENT [23] { + name: @index1 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index0 + } + } + } + } + } + LIST [14] { + elements: { + CONSTANT [15] { value: 1 } + IDENT [16] { + name: @index0 + } + CONSTANT [17] { value: 2 } + IDENT [18] { + name: @index0 + } + CONSTANT [19] { value: 5 } + IDENT [20] { + name: @index0 + } + CONSTANT [21] { value: 7 } + IDENT [22] { + name: @index2 + } + IDENT [23] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + CALL [5] { + function: _+_ + args: { + IDENT [6] { + name: @index0 + } + IDENT [7] { + name: @index0 + } + } + } + } + } + CALL [8] { + function: _==_ + args: { + IDENT [9] { + name: @index1 + } + CONSTANT [10] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.single_int64 + } + SELECT [9] { + IDENT [10] { + name: @index1 + }.single_int32 + } + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index2 + } + IDENT [13] { + name: @index3 + } + } + } + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index4 + } + IDENT [16] { + name: @index2 + } + } + } + SELECT [17] { + IDENT [18] { + name: msg + }.single_int64 + } + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @index5 + } + IDENT [21] { + name: @index6 + } + } + } + SELECT [22] { + IDENT [23] { + name: @index1 + }.oneof_type + } + SELECT [24] { + IDENT [25] { + name: @index8 + }.payload + } + SELECT [26] { + IDENT [27] { + name: @index9 + }.single_int64 + } + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @index7 + } + IDENT [30] { + name: @index10 + } + } + } + } + } + CALL [31] { + function: _==_ + args: { + IDENT [32] { + name: @index11 + } + CONSTANT [33] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.oneof_type + } + SELECT [9] { + IDENT [10] { + name: @index2 + }.payload + } + SELECT [11] { + IDENT [12] { + name: @index3 + }.oneof_type + } + SELECT [13] { + IDENT [14] { + name: @index4 + }.payload + } + SELECT [15] { + IDENT [16] { + name: @index5 + }.oneof_type + } + SELECT [17] { + IDENT [18] { + name: @index6 + }.payload + } + SELECT [19] { + IDENT [20] { + name: @index7 + }.single_bool + } + CALL [21] { + function: _||_ + args: { + CONSTANT [22] { value: true } + IDENT [23] { + name: @index8 + } + } + } + SELECT [24] { + IDENT [25] { + name: @index4 + }.child + } + SELECT [26] { + IDENT [27] { + name: @index10 + }.child + } + SELECT [28] { + IDENT [29] { + name: @index11 + }.payload + } + SELECT [30] { + IDENT [31] { + name: @index12 + }.single_bool + } + } + } + CALL [32] { + function: _||_ + args: { + IDENT [33] { + name: @index9 + } + IDENT [34] { + name: @index13 + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.map_int32_int64 + } + CALL [9] { + function: _[_] + args: { + IDENT [10] { + name: @index2 + } + CONSTANT [11] { value: 1 } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index3 + } + IDENT [14] { + name: @index3 + } + } + } + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index4 + } + IDENT [17] { + name: @index3 + } + } + } + } + } + CALL [18] { + function: _==_ + args: { + IDENT [19] { + name: @index5 + } + CONSTANT [20] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.map_int32_int64 + } + CALL [9] { + function: _[_] + args: { + IDENT [10] { + name: @index2 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _[_] + args: { + IDENT [13] { + name: @index2 + } + CONSTANT [14] { value: 1 } + } + } + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index3 + } + IDENT [17] { + name: @index4 + } + } + } + CALL [18] { + function: _[_] + args: { + IDENT [19] { + name: @index2 + } + CONSTANT [20] { value: 2 } + } + } + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @index5 + } + IDENT [23] { + name: @index6 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + IDENT [25] { + name: @index7 + } + CONSTANT [26] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.oneof_type + } + SELECT [9] { + IDENT [10] { + name: @index2 + }.payload + } + SELECT [11] { + IDENT [12] { + name: @index3 + }.oneof_type + } + SELECT [13] { + IDENT [14] { + name: @index4 + }.payload + } + SELECT [15] { + IDENT [16] { + name: @index5 + }.oneof_type + } + SELECT [17] { + IDENT [18] { + name: @index6 + }.payload + } + } + } + SELECT [19] { + IDENT [20] { + name: @index7 + }.single_int64 + } + } +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + CALL [5] { + function: _>_ + args: { + IDENT [6] { + name: @index0 + } + CONSTANT [7] { value: 0 } + } + } + CALL [8] { + function: _?_:_ + args: { + IDENT [9] { + name: @index1 + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + } + } + CALL [12] { + function: _==_ + args: { + IDENT [13] { + name: @index2 + } + CONSTANT [14] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + CALL [5] { + function: _+_ + args: { + IDENT [6] { + name: @index0 + } + CONSTANT [7] { value: 1 } + } + } + CALL [8] { + function: _*_ + args: { + IDENT [9] { + name: @index1 + } + CONSTANT [10] { value: 2 } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index2 + } + } + } + CALL [14] { + function: _==_ + args: { + IDENT [15] { + name: @index3 + } + CONSTANT [16] { value: 11 } + } + } + } + } + CALL [17] { + function: _?_:_ + args: { + CONSTANT [18] { value: false } + CONSTANT [19] { value: false } + IDENT [20] { + name: @index4 + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + CALL [10] { + function: _>_ + args: { + IDENT [11] { + name: @index1 + } + CONSTANT [12] { value: 0 } + } + } + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + IDENT [15] { + name: @index1 + } + } + } + CALL [16] { + function: _?_:_ + args: { + IDENT [17] { + name: @index3 + } + IDENT [18] { + name: @index4 + } + CONSTANT [19] { value: 0 } + } + } + CALL [20] { + function: _?_:_ + args: { + IDENT [21] { + name: @index2 + } + IDENT [22] { + name: @index5 + } + CONSTANT [23] { value: 0 } + } + } + } + } + CALL [24] { + function: _==_ + args: { + IDENT [25] { + name: @index6 + } + CONSTANT [26] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: size + args: { + LIST [12] { + elements: { + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_range: { + IDENT [14] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [15] { value: false } + } + loop_condition: { + CALL [16] { + function: @not_strictly_false + args: { + CALL [17] { + function: !_ + args: { + IDENT [18] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [19] { + function: _||_ + args: { + IDENT [20] { + name: @ac:0:0 + } + CALL [21] { + function: _>_ + args: { + IDENT [22] { + name: @it:0:0 + } + CONSTANT [23] { value: 0 } + } + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + } + } + CALL [25] { + function: size + args: { + LIST [26] { + elements: { + COMPREHENSION [27] { + iter_var: @it:0:0 + iter_range: { + IDENT [28] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [29] { value: false } + } + loop_condition: { + CALL [30] { + function: @not_strictly_false + args: { + CALL [31] { + function: !_ + args: { + IDENT [32] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [33] { + function: _||_ + args: { + IDENT [34] { + name: @ac:0:0 + } + CALL [35] { + function: _>_ + args: { + IDENT [36] { + name: @it:0:0 + } + CONSTANT [37] { value: 0 } + } + } + } + } + } + result: { + IDENT [38] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [39] { + function: size + args: { + LIST [40] { + elements: { + COMPREHENSION [41] { + iter_var: @it:0:0 + iter_range: { + IDENT [42] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [43] { value: false } + } + loop_condition: { + CALL [44] { + function: @not_strictly_false + args: { + CALL [45] { + function: !_ + args: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [47] { + function: _||_ + args: { + IDENT [48] { + name: @ac:0:0 + } + CALL [49] { + function: _>_ + args: { + IDENT [50] { + name: @it:0:0 + } + CONSTANT [51] { value: 1 } + } + } + } + } + } + result: { + IDENT [52] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [53] { + function: size + args: { + LIST [54] { + elements: { + COMPREHENSION [55] { + iter_var: @it:0:0 + iter_range: { + IDENT [56] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [57] { value: false } + } + loop_condition: { + CALL [58] { + function: @not_strictly_false + args: { + CALL [59] { + function: !_ + args: { + IDENT [60] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [61] { + function: _||_ + args: { + IDENT [62] { + name: @ac:0:0 + } + CALL [63] { + function: _>_ + args: { + IDENT [64] { + name: @it:0:0 + } + CONSTANT [65] { value: 1 } + } + } + } + } + } + result: { + IDENT [66] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CONSTANT [67] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: "a" } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: true } + CONSTANT [9] { value: true } + CONSTANT [10] { value: true } + CONSTANT [11] { value: true } + } + } + } + } + CALL [12] { + function: _==_ + args: { + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CALL [15] { + function: _+_ + args: { + LIST [16] { + elements: { + COMPREHENSION [17] { + iter_var: @it:0:0 + iter_range: { + IDENT [18] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 0 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + LIST [29] { + elements: { + COMPREHENSION [30] { + iter_var: @it:0:0 + iter_range: { + IDENT [31] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [32] { value: false } + } + loop_condition: { + CALL [33] { + function: @not_strictly_false + args: { + CALL [34] { + function: !_ + args: { + IDENT [35] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [36] { + function: _||_ + args: { + IDENT [37] { + name: @ac:0:0 + } + CALL [38] { + function: _>_ + args: { + IDENT [39] { + name: @it:0:0 + } + CONSTANT [40] { value: 0 } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:0:0 + } + } + } + } + } + } + } + LIST [42] { + elements: { + COMPREHENSION [43] { + iter_var: @it:0:1 + iter_range: { + IDENT [44] { + name: @index1 + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [45] { value: false } + } + loop_condition: { + CALL [46] { + function: @not_strictly_false + args: { + CALL [47] { + function: !_ + args: { + IDENT [48] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [49] { + function: _||_ + args: { + IDENT [50] { + name: @ac:0:1 + } + CALL [51] { + function: _==_ + args: { + IDENT [52] { + name: @it:0:1 + } + CONSTANT [53] { value: "a" } + } + } + } + } + } + result: { + IDENT [54] { + name: @ac:0:1 + } + } + } + } + } + } + } + LIST [55] { + elements: { + COMPREHENSION [56] { + iter_var: @it:0:1 + iter_range: { + IDENT [57] { + name: @index1 + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [58] { value: false } + } + loop_condition: { + CALL [59] { + function: @not_strictly_false + args: { + CALL [60] { + function: !_ + args: { + IDENT [61] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [62] { + function: _||_ + args: { + IDENT [63] { + name: @ac:0:1 + } + CALL [64] { + function: _==_ + args: { + IDENT [65] { + name: @it:0:1 + } + CONSTANT [66] { value: "a" } + } + } + } + } + } + result: { + IDENT [67] { + name: @ac:0:1 + } + } + } + } + } + } + } + IDENT [68] { + name: @index2 + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + CALL [8] { + function: _&&_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_range: { + IDENT [10] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [11] { value: false } + } + loop_condition: { + CALL [12] { + function: @not_strictly_false + args: { + CALL [13] { + function: !_ + args: { + IDENT [14] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [15] { + function: _||_ + args: { + IDENT [16] { + name: @ac:0:0 + } + CALL [17] { + function: _>_ + args: { + IDENT [18] { + name: @it:0:0 + } + CONSTANT [19] { value: 0 } + } + } + } + } + } + result: { + IDENT [20] { + name: @ac:0:0 + } + } + } + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + IDENT [22] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:0:0 + } + CALL [29] { + function: _>_ + args: { + IDENT [30] { + name: @it:0:0 + } + CONSTANT [31] { value: 0 } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:0:0 + } + } + } + } + } + CALL [33] { + function: _&&_ + args: { + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + IDENT [35] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [36] { value: false } + } + loop_condition: { + CALL [37] { + function: @not_strictly_false + args: { + CALL [38] { + function: !_ + args: { + IDENT [39] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [40] { + function: _||_ + args: { + IDENT [41] { + name: @ac:0:0 + } + CALL [42] { + function: _>_ + args: { + IDENT [43] { + name: @it:0:0 + } + CONSTANT [44] { value: 1 } + } + } + } + } + } + result: { + IDENT [45] { + name: @ac:0:0 + } + } + } + COMPREHENSION [46] { + iter_var: @it:0:0 + iter_range: { + IDENT [47] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [48] { value: false } + } + loop_condition: { + CALL [49] { + function: @not_strictly_false + args: { + CALL [50] { + function: !_ + args: { + IDENT [51] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [52] { + function: _||_ + args: { + IDENT [53] { + name: @ac:0:0 + } + CALL [54] { + function: _>_ + args: { + IDENT [55] { + name: @it:0:0 + } + CONSTANT [56] { value: 1 } + } + } + } + } + } + result: { + IDENT [57] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: size + args: { + LIST [12] { + elements: { + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [14] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [15] { value: false } + } + loop_condition: { + CALL [16] { + function: @not_strictly_false + args: { + CALL [17] { + function: !_ + args: { + IDENT [18] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [19] { + function: _||_ + args: { + IDENT [20] { + name: @ac:0:0 + } + CALL [21] { + function: _&&_ + args: { + CALL [22] { + function: _>_ + args: { + IDENT [23] { + name: @it:0:0 + } + CONSTANT [24] { value: 0 } + } + } + CALL [25] { + function: _>=_ + args: { + IDENT [26] { + name: @it2:0:0 + } + CONSTANT [27] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + COMPREHENSION [31] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [32] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [33] { value: false } + } + loop_condition: { + CALL [34] { + function: @not_strictly_false + args: { + CALL [35] { + function: !_ + args: { + IDENT [36] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [37] { + function: _||_ + args: { + IDENT [38] { + name: @ac:0:0 + } + CALL [39] { + function: _&&_ + args: { + CALL [40] { + function: _>_ + args: { + IDENT [41] { + name: @it:0:0 + } + CONSTANT [42] { value: 0 } + } + } + CALL [43] { + function: _>=_ + args: { + IDENT [44] { + name: @it2:0:0 + } + CONSTANT [45] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [47] { + function: size + args: { + LIST [48] { + elements: { + COMPREHENSION [49] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [50] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [51] { value: false } + } + loop_condition: { + CALL [52] { + function: @not_strictly_false + args: { + CALL [53] { + function: !_ + args: { + IDENT [54] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [55] { + function: _||_ + args: { + IDENT [56] { + name: @ac:0:0 + } + CALL [57] { + function: _&&_ + args: { + CALL [58] { + function: _>_ + args: { + IDENT [59] { + name: @it:0:0 + } + CONSTANT [60] { value: 1 } + } + } + CALL [61] { + function: _>=_ + args: { + IDENT [62] { + name: @it2:0:0 + } + CONSTANT [63] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [64] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [65] { + function: size + args: { + LIST [66] { + elements: { + COMPREHENSION [67] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [68] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [69] { value: false } + } + loop_condition: { + CALL [70] { + function: @not_strictly_false + args: { + CALL [71] { + function: !_ + args: { + IDENT [72] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [73] { + function: _||_ + args: { + IDENT [74] { + name: @ac:0:0 + } + CALL [75] { + function: _&&_ + args: { + CALL [76] { + function: _>_ + args: { + IDENT [77] { + name: @it:0:0 + } + CONSTANT [78] { value: 1 } + } + } + CALL [79] { + function: _>=_ + args: { + IDENT [80] { + name: @it2:0:0 + } + CONSTANT [81] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [82] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CONSTANT [83] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + CALL [8] { + function: _&&_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [10] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [11] { value: false } + } + loop_condition: { + CALL [12] { + function: @not_strictly_false + args: { + CALL [13] { + function: !_ + args: { + IDENT [14] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [15] { + function: _||_ + args: { + IDENT [16] { + name: @ac:0:0 + } + CALL [17] { + function: _&&_ + args: { + CALL [18] { + function: _>_ + args: { + IDENT [19] { + name: @it:0:0 + } + CONSTANT [20] { value: 0 } + } + } + CALL [21] { + function: _>_ + args: { + IDENT [22] { + name: @it2:0:0 + } + CONSTANT [23] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [26] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [27] { value: false } + } + loop_condition: { + CALL [28] { + function: @not_strictly_false + args: { + CALL [29] { + function: !_ + args: { + IDENT [30] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [31] { + function: _||_ + args: { + IDENT [32] { + name: @ac:0:0 + } + CALL [33] { + function: _&&_ + args: { + CALL [34] { + function: _>_ + args: { + IDENT [35] { + name: @it:0:0 + } + CONSTANT [36] { value: 0 } + } + } + CALL [37] { + function: _>_ + args: { + IDENT [38] { + name: @it2:0:0 + } + CONSTANT [39] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + CALL [41] { + function: _&&_ + args: { + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [43] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [44] { value: false } + } + loop_condition: { + CALL [45] { + function: @not_strictly_false + args: { + CALL [46] { + function: !_ + args: { + IDENT [47] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [48] { + function: _||_ + args: { + IDENT [49] { + name: @ac:0:0 + } + CALL [50] { + function: _&&_ + args: { + CALL [51] { + function: _>_ + args: { + IDENT [52] { + name: @it:0:0 + } + CONSTANT [53] { value: 1 } + } + } + CALL [54] { + function: _>_ + args: { + IDENT [55] { + name: @it2:0:0 + } + CONSTANT [56] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [57] { + name: @ac:0:0 + } + } + } + COMPREHENSION [58] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [59] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [60] { value: false } + } + loop_condition: { + CALL [61] { + function: @not_strictly_false + args: { + CALL [62] { + function: !_ + args: { + IDENT [63] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [64] { + function: _||_ + args: { + IDENT [65] { + name: @ac:0:0 + } + CALL [66] { + function: _&&_ + args: { + CALL [67] { + function: _>_ + args: { + IDENT [68] { + name: @it:0:0 + } + CONSTANT [69] { value: 1 } + } + } + CALL [70] { + function: _>_ + args: { + IDENT [71] { + name: @it2:0:0 + } + CONSTANT [72] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [73] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + LIST [11] { + elements: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_range: { + IDENT [17] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:0:0 + } + LIST [29] { + elements: { + CALL [30] { + function: _+_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + IDENT [35] { + name: @index2 + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + } + } + LIST [12] { + elements: { + CONSTANT [13] { value: 2 } + } + } + LIST [14] { + elements: { + IDENT [15] { + name: @index2 + } + IDENT [16] { + name: @index3 + } + } + } + } + } + CALL [17] { + function: _==_ + args: { + COMPREHENSION [18] { + iter_var: @it:1:0 + iter_range: { + IDENT [19] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [20] { + elements: { + } + } + } + loop_condition: { + CONSTANT [21] { value: true } + } + loop_step: { + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @ac:1:0 + } + LIST [24] { + elements: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_range: { + IDENT [26] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _?_:_ + args: { + CALL [30] { + function: _==_ + args: { + IDENT [31] { + name: @it:0:0 + } + IDENT [32] { + name: @it:1:0 + } + } + } + CALL [33] { + function: _+_ + args: { + IDENT [34] { + name: @ac:0:0 + } + LIST [35] { + elements: { + IDENT [36] { + name: @it:0:0 + } + } + } + } + } + IDENT [37] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [38] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [39] { + name: @ac:1:0 + } + } + } + IDENT [40] { + name: @index4 + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + } + CALL [7] { + function: _+_ + args: { + COMPREHENSION [8] { + iter_var: @it:0:0 + iter_range: { + IDENT [9] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [10] { + elements: { + } + } + } + loop_condition: { + CONSTANT [11] { value: true } + } + loop_step: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @ac:0:0 + } + LIST [14] { + elements: { + CALL [15] { + function: _*_ + args: { + IDENT [16] { + name: @it:0:0 + } + CONSTANT [17] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @ac:0:0 + } + } + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_range: { + IDENT [21] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:0:0 + } + LIST [26] { + elements: { + CALL [27] { + function: _*_ + args: { + IDENT [28] { + name: @it:0:0 + } + CONSTANT [29] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [31] { + elements: { + } + } + } + loop_condition: { + CONSTANT [32] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [34] { + name: @ac:1:0 + } + LIST [35] { + elements: { + CALL [36] { + function: _*_ + args: { + IDENT [37] { + name: @it:1:0 + } + CONSTANT [38] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [39] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + LIST [11] { + elements: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [17] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:0:0 + } + LIST [29] { + elements: { + CALL [30] { + function: _+_ + args: { + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it:0:0 + } + IDENT [33] { + name: @it2:0:0 + } + } + } + CONSTANT [34] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [35] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:1:0 + } + } + } + IDENT [37] { + name: @index2 + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + } + } + LIST [12] { + elements: { + CONSTANT [13] { value: 2 } + } + } + LIST [14] { + elements: { + IDENT [15] { + name: @index2 + } + IDENT [16] { + name: @index3 + } + } + } + } + } + CALL [17] { + function: _==_ + args: { + COMPREHENSION [18] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [19] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [20] { + elements: { + } + } + } + loop_condition: { + CONSTANT [21] { value: true } + } + loop_step: { + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @ac:1:0 + } + LIST [24] { + elements: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_range: { + IDENT [26] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _?_:_ + args: { + CALL [30] { + function: _&&_ + args: { + CALL [31] { + function: _==_ + args: { + IDENT [32] { + name: @it:0:0 + } + IDENT [33] { + name: @it2:1:0 + } + } + } + CALL [34] { + function: _<_ + args: { + IDENT [35] { + name: @it:1:0 + } + IDENT [36] { + name: @it2:1:0 + } + } + } + } + } + CALL [37] { + function: _+_ + args: { + IDENT [38] { + name: @ac:0:0 + } + LIST [39] { + elements: { + IDENT [40] { + name: @it:0:0 + } + } + } + } + } + IDENT [41] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [42] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [43] { + name: @ac:1:0 + } + } + } + IDENT [44] { + name: @index4 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + COMPREHENSION [8] { + iter_var: @it:1:0 + iter_range: { + IDENT [9] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [10] { + elements: { + } + } + } + loop_condition: { + CONSTANT [11] { value: true } + } + loop_step: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @ac:1:0 + } + LIST [14] { + elements: { + COMPREHENSION [15] { + iter_var: @it:0:0 + iter_range: { + IDENT [16] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [17] { + elements: { + } + } + } + loop_condition: { + CONSTANT [18] { value: true } + } + loop_step: { + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @ac:0:0 + } + LIST [21] { + elements: { + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @it:0:0 + } + CONSTANT [24] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [25] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [26] { + name: @ac:1:0 + } + } + } + COMPREHENSION [27] { + iter_var: @it:1:0 + iter_range: { + IDENT [28] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @ac:1:0 + } + LIST [33] { + elements: { + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + IDENT [35] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [36] { + elements: { + } + } + } + loop_condition: { + CONSTANT [37] { value: true } + } + loop_step: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @ac:0:0 + } + LIST [40] { + elements: { + CALL [41] { + function: _+_ + args: { + IDENT [42] { + name: @it:0:0 + } + CONSTANT [43] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [44] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [45] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + COMPREHENSION [8] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [9] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [10] { + + } + } + loop_condition: { + CONSTANT [11] { value: true } + } + loop_step: { + CALL [12] { + function: cel.@mapInsert + args: { + IDENT [13] { + name: @ac:1:0 + } + IDENT [14] { + name: @it:1:0 + } + COMPREHENSION [15] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [16] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [17] { + + } + } + loop_condition: { + CONSTANT [18] { value: true } + } + loop_step: { + CALL [19] { + function: cel.@mapInsert + args: { + IDENT [20] { + name: @ac:0:0 + } + IDENT [21] { + name: @it:0:0 + } + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @it:0:0 + } + IDENT [25] { + name: @it2:0:0 + } + } + } + CONSTANT [26] { value: 1 } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:1:0 + } + } + } + COMPREHENSION [29] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [30] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [31] { + + } + } + loop_condition: { + CONSTANT [32] { value: true } + } + loop_step: { + CALL [33] { + function: cel.@mapInsert + args: { + IDENT [34] { + name: @ac:1:0 + } + IDENT [35] { + name: @it:1:0 + } + COMPREHENSION [36] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [37] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [38] { + + } + } + loop_condition: { + CONSTANT [39] { value: true } + } + loop_step: { + CALL [40] { + function: cel.@mapInsert + args: { + IDENT [41] { + name: @ac:0:0 + } + IDENT [42] { + name: @it:0:0 + } + CALL [43] { + function: _+_ + args: { + CALL [44] { + function: _+_ + args: { + IDENT [45] { + name: @it:0:0 + } + IDENT [46] { + name: @it2:0:0 + } + } + } + CONSTANT [47] { value: 1 } + } + } + } + } + } + result: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [49] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 1 } + IDENT [9] { + name: @index0 + } + } + } + CALL [10] { + function: @in + args: { + CONSTANT [11] { value: 2 } + IDENT [12] { + name: @index0 + } + } + } + CALL [13] { + function: _&&_ + args: { + IDENT [14] { + name: @index1 + } + IDENT [15] { + name: @index2 + } + } + } + LIST [16] { + elements: { + CONSTANT [17] { value: 3 } + IDENT [18] { + name: @index0 + } + } + } + CALL [19] { + function: @in + args: { + CONSTANT [20] { value: 3 } + IDENT [21] { + name: @index4 + } + } + } + CALL [22] { + function: _&&_ + args: { + IDENT [23] { + name: @index5 + } + IDENT [24] { + name: @index1 + } + } + } + } + } + CALL [25] { + function: _&&_ + args: { + IDENT [26] { + name: @index3 + } + IDENT [27] { + name: @index6 + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + MAP [7] { + MAP_ENTRY [8] { + key: { + CONSTANT [9] { value: "a" } + } + value: { + CONSTANT [10] { value: 1 } + } + } + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: 2 } + } + value: { + IDENT [13] { + name: @index0 + } + } + } + MAP_ENTRY [14] { + key: { + CONSTANT [15] { value: 3 } + } + value: { + IDENT [16] { + name: @index0 + } + } + } + } + } + } + CALL [17] { + function: @in + args: { + CONSTANT [18] { value: 2 } + IDENT [19] { + name: @index1 + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 3 } + CONSTANT [8] { value: 4 } + } + } + LIST [9] { + elements: { + IDENT [10] { + name: @index1 + } + IDENT [11] { + name: @index1 + } + } + } + LIST [12] { + elements: { + IDENT [13] { + name: @index1 + } + } + } + LIST [14] { + elements: { + IDENT [15] { + name: @index2 + } + IDENT [16] { + name: @index2 + } + } + } + } + } + CALL [17] { + function: _==_ + args: { + COMPREHENSION [18] { + iter_var: @it:1:0 + iter_range: { + IDENT [19] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [20] { + elements: { + } + } + } + loop_condition: { + CONSTANT [21] { value: true } + } + loop_step: { + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @ac:1:0 + } + LIST [24] { + elements: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_range: { + IDENT [26] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:0:0 + } + IDENT [31] { + name: @index3 + } + } + } + } + result: { + IDENT [32] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + IDENT [34] { + name: @index4 + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 3 } + CONSTANT [8] { value: 4 } + } + } + LIST [9] { + elements: { + IDENT [10] { + name: @index1 + } + IDENT [11] { + name: @index1 + } + } + } + LIST [12] { + elements: { + IDENT [13] { + name: @index1 + } + } + } + LIST [14] { + elements: { + IDENT [15] { + name: @index2 + } + IDENT [16] { + name: @index2 + } + } + } + } + } + CALL [17] { + function: _==_ + args: { + COMPREHENSION [18] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [19] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [20] { + elements: { + } + } + } + loop_condition: { + CONSTANT [21] { value: true } + } + loop_step: { + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @ac:1:0 + } + LIST [24] { + elements: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [26] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:0:0 + } + IDENT [31] { + name: @index3 + } + } + } + } + result: { + IDENT [32] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + IDENT [34] { + name: @index4 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _-_ + args: { + IDENT [4] { + name: x + } + CONSTANT [5] { value: 1 } + } + } + CALL [6] { + function: _>_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: 3 } + } + } + CALL [9] { + function: _?_:_ + args: { + IDENT [10] { + name: @index1 + } + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: 5 } + } + } + LIST [13] { + elements: { + IDENT [14] { + name: @index2 + } + } + } + } + } + CALL [15] { + function: _||_ + args: { + COMPREHENSION [16] { + iter_var: @it:0:0 + iter_range: { + IDENT [17] { + name: @index3 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [18] { value: false } + } + loop_condition: { + CALL [19] { + function: @not_strictly_false + args: { + CALL [20] { + function: !_ + args: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [22] { + function: _||_ + args: { + IDENT [23] { + name: @ac:0:0 + } + CALL [24] { + function: _>_ + args: { + CALL [25] { + function: _-_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 1 } + } + } + CONSTANT [28] { value: 3 } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:0:0 + } + } + } + IDENT [30] { + name: @index1 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: "foo" } + CONSTANT [5] { value: "bar" } + } + } + } + } + COMPREHENSION [6] { + iter_var: @it:1:0 + iter_range: { + COMPREHENSION [7] { + iter_var: @it:0:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [9] { + elements: { + } + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @ac:0:0 + } + LIST [13] { + elements: { + LIST [14] { + elements: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @it:0:0 + } + IDENT [17] { + name: @it:0:0 + } + } + } + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it:0:0 + } + IDENT [20] { + name: @it:0:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:1:0 + } + LIST [26] { + elements: { + LIST [27] { + elements: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @it:1:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it:1:0 + } + IDENT [33] { + name: @it:1:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _-_ + args: { + IDENT [4] { + name: x + } + IDENT [5] { + name: y + } + } + } + CALL [6] { + function: _-_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: 1 } + } + } + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @index1 + } + CONSTANT [11] { value: 3 } + } + } + CALL [12] { + function: _?_:_ + args: { + IDENT [13] { + name: @index2 + } + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 5 } + } + } + LIST [16] { + elements: { + IDENT [17] { + name: @index3 + } + } + } + } + } + CALL [18] { + function: _||_ + args: { + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [20] { + name: @index4 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [21] { value: false } + } + loop_condition: { + CALL [22] { + function: @not_strictly_false + args: { + CALL [23] { + function: !_ + args: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [25] { + function: _||_ + args: { + IDENT [26] { + name: @ac:0:0 + } + CALL [27] { + function: _>_ + args: { + CALL [28] { + function: _-_ + args: { + CALL [29] { + function: _-_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:0:0 + } + } + } + CONSTANT [32] { value: 1 } + } + } + CONSTANT [33] { value: 3 } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:0:0 + } + } + } + IDENT [35] { + name: @index2 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: "foo" } + CONSTANT [5] { value: "bar" } + } + } + } + } + COMPREHENSION [6] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + COMPREHENSION [7] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [9] { + + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: cel.@mapInsert + args: { + IDENT [12] { + name: @ac:0:0 + } + IDENT [13] { + name: @it:0:0 + } + LIST [14] { + elements: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @it:0:0 + } + IDENT [17] { + name: @it:0:0 + } + } + } + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it2:0:0 + } + IDENT [20] { + name: @it2:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [22] { + + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: cel.@mapInsert + args: { + IDENT [25] { + name: @ac:1:0 + } + IDENT [26] { + name: @it:1:0 + } + LIST [27] { + elements: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @it:1:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it2:1:0 + } + IDENT [33] { + name: @it2:1:0 + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + SELECT [7] { + IDENT [8] { + name: @index0 + }.a~presence_test + } + CALL [9] { + function: _[_] + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: "a" } + } + } + } + } + CALL [12] { + function: _&&_ + args: { + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index2 + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + SELECT [7] { + IDENT [8] { + name: @index0 + }.a~presence_test + } + } + } + CALL [9] { + function: _&&_ + args: { + IDENT [10] { + name: @index1 + } + IDENT [11] { + name: @index1 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload~presence_test + } + SELECT [7] { + IDENT [8] { + name: @index0 + }.payload + } + SELECT [9] { + IDENT [10] { + name: @index2 + }.single_int64 + } + CALL [11] { + function: _?_:_ + args: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index3 + } + CONSTANT [14] { value: 0 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + IDENT [16] { + name: @index4 + } + CONSTANT [17] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.single_int64 + } + SELECT [9] { + IDENT [10] { + name: @index0 + }.payload~presence_test + } + CALL [11] { + function: _*_ + args: { + IDENT [12] { + name: @index2 + } + CONSTANT [13] { value: 0 } + } + } + CALL [14] { + function: _?_:_ + args: { + IDENT [15] { + name: @index3 + } + IDENT [16] { + name: @index2 + } + IDENT [17] { + name: @index4 + } + } + } + } + } + CALL [18] { + function: _==_ + args: { + IDENT [19] { + name: @index5 + } + CONSTANT [20] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.single_int64 + } + SELECT [9] { + IDENT [10] { + name: @index1 + }.single_int64~presence_test + } + CALL [11] { + function: _*_ + args: { + IDENT [12] { + name: @index2 + } + CONSTANT [13] { value: 0 } + } + } + CALL [14] { + function: _?_:_ + args: { + IDENT [15] { + name: @index3 + } + IDENT [16] { + name: @index2 + } + IDENT [17] { + name: @index4 + } + } + } + } + } + CALL [18] { + function: _==_ + args: { + IDENT [19] { + name: @index5 + } + CONSTANT [20] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.map_string_string + } + SELECT [9] { + IDENT [10] { + name: msg + }.oneof_type~presence_test + } + SELECT [11] { + IDENT [12] { + name: @index0 + }.payload~presence_test + } + CALL [13] { + function: _&&_ + args: { + IDENT [14] { + name: @index3 + } + IDENT [15] { + name: @index4 + } + } + } + SELECT [16] { + IDENT [17] { + name: @index1 + }.single_int64~presence_test + } + CALL [18] { + function: _&&_ + args: { + IDENT [19] { + name: @index5 + } + IDENT [20] { + name: @index6 + } + } + } + SELECT [21] { + IDENT [22] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [23] { + IDENT [24] { + name: @index2 + }.key~presence_test + } + CALL [25] { + function: _&&_ + args: { + IDENT [26] { + name: @index8 + } + IDENT [27] { + name: @index9 + } + } + } + SELECT [28] { + IDENT [29] { + name: @index2 + }.key + } + CALL [30] { + function: _==_ + args: { + IDENT [31] { + name: @index11 + } + CONSTANT [32] { value: "A" } + } + } + CALL [33] { + function: _?_:_ + args: { + IDENT [34] { + name: @index10 + } + IDENT [35] { + name: @index12 + } + CONSTANT [36] { value: false } + } + } + } + } + CALL [37] { + function: _?_:_ + args: { + IDENT [38] { + name: @index7 + } + IDENT [39] { + name: @index13 + } + CONSTANT [40] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: optional.none + args: { + } + } + LIST [4] { + elements: { + IDENT [5] { + name: @index0 + } + IDENT [6] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [7] { + elements: { + CONSTANT [8] { value: 5 } + } + } + LIST [9] { + elements: { + CONSTANT [10] { value: 10 } + IDENT [11] { + name: @index0 + } + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index1 + } + } + optional_indices: [0] + } + LIST [14] { + elements: { + CONSTANT [15] { value: 10 } + IDENT [16] { + name: @index2 + } + IDENT [17] { + name: @index2 + } + } + } + } + } + CALL [18] { + function: _==_ + args: { + IDENT [19] { + name: @index3 + } + IDENT [20] { + name: @index4 + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: optional.of + args: { + CONSTANT [4] { value: "hello" } + } + } + MAP [5] { + MAP_ENTRY [6] { + key: { + CONSTANT [7] { value: "hello" } + } + optional_entry: true + value: { + IDENT [8] { + name: @index0 + } + } + } + } + CALL [9] { + function: _[_] + args: { + IDENT [10] { + name: @index1 + } + CONSTANT [11] { value: "hello" } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index2 + } + IDENT [14] { + name: @index2 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + IDENT [16] { + name: @index3 + } + CONSTANT [17] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "test" } + } + } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "key" } + } + optional_entry: true + value: { + IDENT [12] { + name: @index1 + } + } + } + } + CALL [13] { + function: _[?_] + args: { + IDENT [14] { + name: @index2 + } + CONSTANT [15] { value: "bogus" } + } + } + CALL [16] { + function: _[?_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: "bogus" } + } + } + CALL [19] { + function: or + target: { + IDENT [20] { + name: @index3 + } + } + args: { + IDENT [21] { + name: @index4 + } + } + } + CALL [22] { + function: _[_] + args: { + IDENT [23] { + name: @index0 + } + CONSTANT [24] { value: "key" } + } + } + CALL [25] { + function: orValue + target: { + IDENT [26] { + name: @index5 + } + } + args: { + IDENT [27] { + name: @index6 + } + } + } + } + } + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @index7 + } + CONSTANT [30] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: optional.ofNonZeroValue + args: { + CONSTANT [4] { value: 1 } + } + } + CALL [5] { + function: optional.of + args: { + CONSTANT [6] { value: 4 } + } + } + STRUCT [7] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [8] { + field_key: single_int64 + optional_entry: true + value: { + IDENT [9] { + name: @index0 + } + } + } + ENTRY [10] { + field_key: single_int32 + optional_entry: true + value: { + IDENT [11] { + name: @index1 + } + } + } + } + } + SELECT [12] { + IDENT [13] { + name: @index2 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index2 + }.single_int64 + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index3 + } + IDENT [18] { + name: @index4 + } + } + } + } + } + CALL [19] { + function: _==_ + args: { + IDENT [20] { + name: @index5 + } + CONSTANT [21] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CONSTANT [4] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: "l" } + } + } + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index1 + } + CONSTANT [11] { value: "l" } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index2 + } + CONSTANT [14] { value: "o" } + } + } + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index3 + } + CONSTANT [17] { value: " world" } + } + } + } + } + CALL [18] { + function: matches + target: { + IDENT [19] { + name: @index4 + } + } + args: { + IDENT [20] { + name: @index3 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CONSTANT [4] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: "l" } + } + } + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index1 + } + CONSTANT [11] { value: "l" } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index2 + } + CONSTANT [14] { value: "o" } + } + } + } + } + CALL [15] { + function: matches + target: { + CONSTANT [16] { value: "hello world" } + } + args: { + IDENT [17] { + name: @index3 + } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CONSTANT [4] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: "l" } + } + } + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index1 + } + CONSTANT [11] { value: "l" } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index2 + } + CONSTANT [14] { value: "o" } + } + } + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index3 + } + CONSTANT [17] { value: " world" } + } + } + } + } + CALL [18] { + function: matches + target: { + IDENT [19] { + name: @index4 + } + } + args: { + CONSTANT [20] { value: "hello" } + } + } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CONSTANT [4] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: "l" } + } + } + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index1 + } + CONSTANT [11] { value: "l" } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index2 + } + CONSTANT [14] { value: "o" } + } + } + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index3 + } + CONSTANT [17] { value: " world" } + } + } + CALL [18] { + function: _+_ + args: { + CONSTANT [19] { value: "w" } + CONSTANT [20] { value: "o" } + } + } + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @index5 + } + CONSTANT [23] { value: "r" } + } + } + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @index6 + } + CONSTANT [26] { value: "l" } + } + } + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @index7 + } + CONSTANT [29] { value: "d" } + } + } + } + } + CALL [30] { + function: matches + target: { + IDENT [31] { + name: @index4 + } + } + args: { + IDENT [32] { + name: @index8 + } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.single_int64 + } + } + } + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: non_pure_custom_func + args: { + IDENT [13] { + name: @index2 + } + } + } + CALL [14] { + function: non_pure_custom_func + args: { + SELECT [15] { + IDENT [16] { + name: @index1 + }.single_int32 + } + } + } + } + } + CALL [17] { + function: non_pure_custom_func + args: { + IDENT [18] { + name: @index2 + } + } + } + } + } + CALL [19] { + function: non_pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + IDENT [6] { + name: @index0 + }.payload + } + SELECT [7] { + IDENT [8] { + name: @index1 + }.single_int64 + } + CALL [9] { + function: pure_custom_func + args: { + IDENT [10] { + name: @index2 + } + } + } + SELECT [11] { + IDENT [12] { + name: @index1 + }.single_int32 + } + CALL [13] { + function: pure_custom_func + args: { + IDENT [14] { + name: @index4 + } + } + } + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index3 + } + IDENT [17] { + name: @index5 + } + } + } + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @index6 + } + IDENT [20] { + name: @index3 + } + } + } + SELECT [21] { + IDENT [22] { + name: msg + }.single_int64 + } + CALL [23] { + function: pure_custom_func + args: { + IDENT [24] { + name: @index8 + } + } + } + } + } + CALL [25] { + function: _+_ + args: { + IDENT [26] { + name: @index7 + } + IDENT [27] { + name: @index9 + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_2.baseline b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_2.baseline new file mode 100644 index 000000000..317bc87aa --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_2.baseline @@ -0,0 +1,5780 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + CONSTANT [11] { value: 1 } + } + } + } + } + CALL [12] { + function: _==_ + args: { + IDENT [13] { + name: @index1 + } + CONSTANT [14] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CONSTANT [9] { value: 2 } + IDENT [10] { + name: @index0 + } + } + } + IDENT [11] { + name: @index0 + } + } + } + } + } + CALL [12] { + function: _==_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 1 } + } + } + CONSTANT [16] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + IDENT [14] { + name: @index1 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index2 + } + IDENT [18] { + name: @index1 + } + } + } + CONSTANT [19] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CONSTANT [17] { value: 5 } + IDENT [18] { + name: @index0 + } + } + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _+_ + args: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @index3 + } + IDENT [23] { + name: @index1 + } + } + } + IDENT [24] { + name: @index1 + } + } + } + CALL [25] { + function: _+_ + args: { + CALL [26] { + function: _+_ + args: { + IDENT [27] { + name: @index4 + } + IDENT [28] { + name: @index2 + } + } + } + IDENT [29] { + name: @index2 + } + } + } + } + } + CALL [30] { + function: _==_ + args: { + IDENT [31] { + name: @index5 + } + CONSTANT [32] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: int + args: { + CALL [4] { + function: timestamp + args: { + CONSTANT [5] { value: 1000000000 } + } + } + } + } + CALL [6] { + function: getFullYear + target: { + CALL [7] { + function: timestamp + args: { + IDENT [8] { + name: @index0 + } + } + } + } + args: { + } + } + CALL [9] { + function: int + args: { + CALL [10] { + function: timestamp + args: { + CONSTANT [11] { value: 50 } + } + } + } + } + CALL [12] { + function: int + args: { + CALL [13] { + function: timestamp + args: { + CONSTANT [14] { value: 200 } + } + } + } + } + CALL [15] { + function: getFullYear + target: { + CALL [16] { + function: timestamp + args: { + IDENT [17] { + name: @index3 + } + } + } + } + args: { + } + } + CALL [18] { + function: int + args: { + CALL [19] { + function: timestamp + args: { + CONSTANT [20] { value: 75 } + } + } + } + } + CALL [21] { + function: timestamp + args: { + IDENT [22] { + name: @index2 + } + } + } + CALL [23] { + function: timestamp + args: { + IDENT [24] { + name: @index5 + } + } + } + CALL [25] { + function: _+_ + args: { + IDENT [26] { + name: @index1 + } + CALL [27] { + function: getFullYear + target: { + IDENT [28] { + name: @index7 + } + } + args: { + } + } + } + } + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @index8 + } + CALL [31] { + function: getFullYear + target: { + IDENT [32] { + name: @index6 + } + } + args: { + } + } + } + } + CALL [33] { + function: _+_ + args: { + CALL [34] { + function: _+_ + args: { + IDENT [35] { + name: @index9 + } + IDENT [36] { + name: @index1 + } + } + } + CALL [37] { + function: getSeconds + target: { + IDENT [38] { + name: @index6 + } + } + args: { + } + } + } + } + CALL [39] { + function: _+_ + args: { + CALL [40] { + function: _+_ + args: { + IDENT [41] { + name: @index10 + } + IDENT [42] { + name: @index4 + } + } + } + IDENT [43] { + name: @index4 + } + } + } + CALL [44] { + function: _+_ + args: { + IDENT [45] { + name: @index11 + } + CALL [46] { + function: getMinutes + target: { + IDENT [47] { + name: @index7 + } + } + args: { + } + } + } + } + } + } + CALL [48] { + function: _==_ + args: { + CALL [49] { + function: _+_ + args: { + IDENT [50] { + name: @index12 + } + IDENT [51] { + name: @index1 + } + } + } + CONSTANT [52] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: _*_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + } + } + } + } + CALL [14] { + function: _==_ + args: { + IDENT [15] { + name: @index1 + } + CONSTANT [16] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "e" } + } + value: { + MAP [6] { + MAP_ENTRY [7] { + key: { + CONSTANT [8] { value: "b" } + } + value: { + CONSTANT [9] { value: 1 } + } + } + } + } + } + } + MAP [10] { + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: "b" } + } + value: { + CONSTANT [13] { value: 1 } + } + } + } + } + } + MAP [14] { + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "a" } + } + value: { + IDENT [17] { + name: @index1 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "c" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "d" } + } + value: { + IDENT [23] { + name: @index0 + } + } + } + MAP_ENTRY [24] { + key: { + CONSTANT [25] { value: "e" } + } + value: { + IDENT [26] { + name: @index0 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + CALL [8] { + function: _+_ + args: { + IDENT [9] { + name: @index1 + } + SELECT [10] { + IDENT [11] { + name: @index0 + }.single_int32 + } + } + } + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index2 + } + IDENT [15] { + name: @index1 + } + } + } + SELECT [16] { + IDENT [17] { + name: msg + }.single_int64 + } + } + } + SELECT [18] { + SELECT [19] { + IDENT [20] { + name: @index0 + }.oneof_type + }.payload + } + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @index3 + } + SELECT [23] { + IDENT [24] { + name: @index4 + }.single_int64 + } + } + } + } + } + CALL [25] { + function: _==_ + args: { + IDENT [26] { + name: @index5 + } + CONSTANT [27] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: @index0 + }.oneof_type + }.payload + } + SELECT [9] { + IDENT [10] { + name: @index1 + }.oneof_type + } + SELECT [11] { + SELECT [12] { + IDENT [13] { + name: @index2 + }.payload + }.oneof_type + } + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: @index3 + }.payload + }.single_bool + } + SELECT [17] { + SELECT [18] { + IDENT [19] { + name: @index2 + }.child + }.child + } + SELECT [20] { + SELECT [21] { + IDENT [22] { + name: @index5 + }.payload + }.single_bool + } + } + } + CALL [23] { + function: _||_ + args: { + CALL [24] { + function: _||_ + args: { + CONSTANT [25] { value: true } + IDENT [26] { + name: @index4 + } + } + } + IDENT [27] { + name: @index6 + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + CALL [6] { + function: _[_] + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.map_int32_int64 + } + CONSTANT [9] { value: 1 } + } + } + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index1 + } + } + } + IDENT [14] { + name: @index1 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + IDENT [16] { + name: @index2 + } + CONSTANT [17] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.map_int32_int64 + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _[_] + args: { + IDENT [10] { + name: @index1 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _[_] + args: { + IDENT [13] { + name: @index1 + } + CONSTANT [14] { value: 1 } + } + } + } + } + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index2 + } + CALL [17] { + function: _[_] + args: { + IDENT [18] { + name: @index1 + } + CONSTANT [19] { value: 2 } + } + } + } + } + } + } + CALL [20] { + function: _==_ + args: { + IDENT [21] { + name: @index3 + } + CONSTANT [22] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: @index0 + }.oneof_type + }.payload + } + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: @index1 + }.oneof_type + }.payload + } + SELECT [12] { + SELECT [13] { + IDENT [14] { + name: @index2 + }.oneof_type + }.payload + } + } + } + SELECT [15] { + IDENT [16] { + name: @index3 + }.single_int64 + } + } +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + CALL [5] { + function: _?_:_ + args: { + CALL [6] { + function: _>_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: 0 } + } + } + IDENT [9] { + name: @index0 + } + CONSTANT [10] { value: 0 } + } + } + } + } + CALL [11] { + function: _==_ + args: { + IDENT [12] { + name: @index1 + } + CONSTANT [13] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + CALL [5] { + function: _*_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + CONSTANT [8] { value: 1 } + } + } + CONSTANT [9] { value: 2 } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index1 + } + } + } + CONSTANT [14] { value: 11 } + } + } + } + } + CALL [15] { + function: _?_:_ + args: { + CONSTANT [16] { value: false } + CONSTANT [17] { value: false } + IDENT [18] { + name: @index2 + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + CALL [7] { + function: _?_:_ + args: { + CALL [8] { + function: _>_ + args: { + IDENT [9] { + name: @index1 + } + CONSTANT [10] { value: 0 } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index1 + } + } + } + CONSTANT [14] { value: 0 } + } + } + CALL [15] { + function: _?_:_ + args: { + CALL [16] { + function: _>_ + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 0 } + } + } + IDENT [19] { + name: @index2 + } + CONSTANT [20] { value: 0 } + } + } + } + } + CALL [21] { + function: _==_ + args: { + IDENT [22] { + name: @index3 + } + CONSTANT [23] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: size + args: { + LIST [12] { + elements: { + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_range: { + IDENT [14] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [15] { value: false } + } + loop_condition: { + CALL [16] { + function: @not_strictly_false + args: { + CALL [17] { + function: !_ + args: { + IDENT [18] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [19] { + function: _||_ + args: { + IDENT [20] { + name: @ac:0:0 + } + CALL [21] { + function: _>_ + args: { + IDENT [22] { + name: @it:0:0 + } + CONSTANT [23] { value: 0 } + } + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + } + } + CALL [25] { + function: size + args: { + LIST [26] { + elements: { + COMPREHENSION [27] { + iter_var: @it:0:0 + iter_range: { + IDENT [28] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [29] { value: false } + } + loop_condition: { + CALL [30] { + function: @not_strictly_false + args: { + CALL [31] { + function: !_ + args: { + IDENT [32] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [33] { + function: _||_ + args: { + IDENT [34] { + name: @ac:0:0 + } + CALL [35] { + function: _>_ + args: { + IDENT [36] { + name: @it:0:0 + } + CONSTANT [37] { value: 0 } + } + } + } + } + } + result: { + IDENT [38] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [39] { + function: size + args: { + LIST [40] { + elements: { + COMPREHENSION [41] { + iter_var: @it:0:0 + iter_range: { + IDENT [42] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [43] { value: false } + } + loop_condition: { + CALL [44] { + function: @not_strictly_false + args: { + CALL [45] { + function: !_ + args: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [47] { + function: _||_ + args: { + IDENT [48] { + name: @ac:0:0 + } + CALL [49] { + function: _>_ + args: { + IDENT [50] { + name: @it:0:0 + } + CONSTANT [51] { value: 1 } + } + } + } + } + } + result: { + IDENT [52] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [53] { + function: size + args: { + LIST [54] { + elements: { + COMPREHENSION [55] { + iter_var: @it:0:0 + iter_range: { + IDENT [56] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [57] { value: false } + } + loop_condition: { + CALL [58] { + function: @not_strictly_false + args: { + CALL [59] { + function: !_ + args: { + IDENT [60] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [61] { + function: _||_ + args: { + IDENT [62] { + name: @ac:0:0 + } + CALL [63] { + function: _>_ + args: { + IDENT [64] { + name: @it:0:0 + } + CONSTANT [65] { value: 1 } + } + } + } + } + } + result: { + IDENT [66] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CONSTANT [67] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: "a" } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: true } + CONSTANT [9] { value: true } + CONSTANT [10] { value: true } + CONSTANT [11] { value: true } + } + } + } + } + CALL [12] { + function: _==_ + args: { + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CALL [15] { + function: _+_ + args: { + LIST [16] { + elements: { + COMPREHENSION [17] { + iter_var: @it:0:0 + iter_range: { + IDENT [18] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 0 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + LIST [29] { + elements: { + COMPREHENSION [30] { + iter_var: @it:0:0 + iter_range: { + IDENT [31] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [32] { value: false } + } + loop_condition: { + CALL [33] { + function: @not_strictly_false + args: { + CALL [34] { + function: !_ + args: { + IDENT [35] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [36] { + function: _||_ + args: { + IDENT [37] { + name: @ac:0:0 + } + CALL [38] { + function: _>_ + args: { + IDENT [39] { + name: @it:0:0 + } + CONSTANT [40] { value: 0 } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:0:0 + } + } + } + } + } + } + } + LIST [42] { + elements: { + COMPREHENSION [43] { + iter_var: @it:0:1 + iter_range: { + IDENT [44] { + name: @index1 + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [45] { value: false } + } + loop_condition: { + CALL [46] { + function: @not_strictly_false + args: { + CALL [47] { + function: !_ + args: { + IDENT [48] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [49] { + function: _||_ + args: { + IDENT [50] { + name: @ac:0:1 + } + CALL [51] { + function: _==_ + args: { + IDENT [52] { + name: @it:0:1 + } + CONSTANT [53] { value: "a" } + } + } + } + } + } + result: { + IDENT [54] { + name: @ac:0:1 + } + } + } + } + } + } + } + LIST [55] { + elements: { + COMPREHENSION [56] { + iter_var: @it:0:1 + iter_range: { + IDENT [57] { + name: @index1 + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [58] { value: false } + } + loop_condition: { + CALL [59] { + function: @not_strictly_false + args: { + CALL [60] { + function: !_ + args: { + IDENT [61] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [62] { + function: _||_ + args: { + IDENT [63] { + name: @ac:0:1 + } + CALL [64] { + function: _==_ + args: { + IDENT [65] { + name: @it:0:1 + } + CONSTANT [66] { value: "a" } + } + } + } + } + } + result: { + IDENT [67] { + name: @ac:0:1 + } + } + } + } + } + } + } + IDENT [68] { + name: @index2 + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + CALL [8] { + function: _&&_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_range: { + IDENT [10] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [11] { value: false } + } + loop_condition: { + CALL [12] { + function: @not_strictly_false + args: { + CALL [13] { + function: !_ + args: { + IDENT [14] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [15] { + function: _||_ + args: { + IDENT [16] { + name: @ac:0:0 + } + CALL [17] { + function: _>_ + args: { + IDENT [18] { + name: @it:0:0 + } + CONSTANT [19] { value: 0 } + } + } + } + } + } + result: { + IDENT [20] { + name: @ac:0:0 + } + } + } + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + IDENT [22] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:0:0 + } + CALL [29] { + function: _>_ + args: { + IDENT [30] { + name: @it:0:0 + } + CONSTANT [31] { value: 0 } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:0:0 + } + } + } + } + } + CALL [33] { + function: _&&_ + args: { + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + IDENT [35] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [36] { value: false } + } + loop_condition: { + CALL [37] { + function: @not_strictly_false + args: { + CALL [38] { + function: !_ + args: { + IDENT [39] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [40] { + function: _||_ + args: { + IDENT [41] { + name: @ac:0:0 + } + CALL [42] { + function: _>_ + args: { + IDENT [43] { + name: @it:0:0 + } + CONSTANT [44] { value: 1 } + } + } + } + } + } + result: { + IDENT [45] { + name: @ac:0:0 + } + } + } + COMPREHENSION [46] { + iter_var: @it:0:0 + iter_range: { + IDENT [47] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [48] { value: false } + } + loop_condition: { + CALL [49] { + function: @not_strictly_false + args: { + CALL [50] { + function: !_ + args: { + IDENT [51] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [52] { + function: _||_ + args: { + IDENT [53] { + name: @ac:0:0 + } + CALL [54] { + function: _>_ + args: { + IDENT [55] { + name: @it:0:0 + } + CONSTANT [56] { value: 1 } + } + } + } + } + } + result: { + IDENT [57] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: size + args: { + LIST [12] { + elements: { + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [14] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [15] { value: false } + } + loop_condition: { + CALL [16] { + function: @not_strictly_false + args: { + CALL [17] { + function: !_ + args: { + IDENT [18] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [19] { + function: _||_ + args: { + IDENT [20] { + name: @ac:0:0 + } + CALL [21] { + function: _&&_ + args: { + CALL [22] { + function: _>_ + args: { + IDENT [23] { + name: @it:0:0 + } + CONSTANT [24] { value: 0 } + } + } + CALL [25] { + function: _>=_ + args: { + IDENT [26] { + name: @it2:0:0 + } + CONSTANT [27] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + COMPREHENSION [31] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [32] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [33] { value: false } + } + loop_condition: { + CALL [34] { + function: @not_strictly_false + args: { + CALL [35] { + function: !_ + args: { + IDENT [36] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [37] { + function: _||_ + args: { + IDENT [38] { + name: @ac:0:0 + } + CALL [39] { + function: _&&_ + args: { + CALL [40] { + function: _>_ + args: { + IDENT [41] { + name: @it:0:0 + } + CONSTANT [42] { value: 0 } + } + } + CALL [43] { + function: _>=_ + args: { + IDENT [44] { + name: @it2:0:0 + } + CONSTANT [45] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [47] { + function: size + args: { + LIST [48] { + elements: { + COMPREHENSION [49] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [50] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [51] { value: false } + } + loop_condition: { + CALL [52] { + function: @not_strictly_false + args: { + CALL [53] { + function: !_ + args: { + IDENT [54] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [55] { + function: _||_ + args: { + IDENT [56] { + name: @ac:0:0 + } + CALL [57] { + function: _&&_ + args: { + CALL [58] { + function: _>_ + args: { + IDENT [59] { + name: @it:0:0 + } + CONSTANT [60] { value: 1 } + } + } + CALL [61] { + function: _>=_ + args: { + IDENT [62] { + name: @it2:0:0 + } + CONSTANT [63] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [64] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [65] { + function: size + args: { + LIST [66] { + elements: { + COMPREHENSION [67] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [68] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [69] { value: false } + } + loop_condition: { + CALL [70] { + function: @not_strictly_false + args: { + CALL [71] { + function: !_ + args: { + IDENT [72] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [73] { + function: _||_ + args: { + IDENT [74] { + name: @ac:0:0 + } + CALL [75] { + function: _&&_ + args: { + CALL [76] { + function: _>_ + args: { + IDENT [77] { + name: @it:0:0 + } + CONSTANT [78] { value: 1 } + } + } + CALL [79] { + function: _>=_ + args: { + IDENT [80] { + name: @it2:0:0 + } + CONSTANT [81] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [82] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CONSTANT [83] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + CALL [8] { + function: _&&_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [10] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [11] { value: false } + } + loop_condition: { + CALL [12] { + function: @not_strictly_false + args: { + CALL [13] { + function: !_ + args: { + IDENT [14] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [15] { + function: _||_ + args: { + IDENT [16] { + name: @ac:0:0 + } + CALL [17] { + function: _&&_ + args: { + CALL [18] { + function: _>_ + args: { + IDENT [19] { + name: @it:0:0 + } + CONSTANT [20] { value: 0 } + } + } + CALL [21] { + function: _>_ + args: { + IDENT [22] { + name: @it2:0:0 + } + CONSTANT [23] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [26] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [27] { value: false } + } + loop_condition: { + CALL [28] { + function: @not_strictly_false + args: { + CALL [29] { + function: !_ + args: { + IDENT [30] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [31] { + function: _||_ + args: { + IDENT [32] { + name: @ac:0:0 + } + CALL [33] { + function: _&&_ + args: { + CALL [34] { + function: _>_ + args: { + IDENT [35] { + name: @it:0:0 + } + CONSTANT [36] { value: 0 } + } + } + CALL [37] { + function: _>_ + args: { + IDENT [38] { + name: @it2:0:0 + } + CONSTANT [39] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + CALL [41] { + function: _&&_ + args: { + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [43] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [44] { value: false } + } + loop_condition: { + CALL [45] { + function: @not_strictly_false + args: { + CALL [46] { + function: !_ + args: { + IDENT [47] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [48] { + function: _||_ + args: { + IDENT [49] { + name: @ac:0:0 + } + CALL [50] { + function: _&&_ + args: { + CALL [51] { + function: _>_ + args: { + IDENT [52] { + name: @it:0:0 + } + CONSTANT [53] { value: 1 } + } + } + CALL [54] { + function: _>_ + args: { + IDENT [55] { + name: @it2:0:0 + } + CONSTANT [56] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [57] { + name: @ac:0:0 + } + } + } + COMPREHENSION [58] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [59] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [60] { value: false } + } + loop_condition: { + CALL [61] { + function: @not_strictly_false + args: { + CALL [62] { + function: !_ + args: { + IDENT [63] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [64] { + function: _||_ + args: { + IDENT [65] { + name: @ac:0:0 + } + CALL [66] { + function: _&&_ + args: { + CALL [67] { + function: _>_ + args: { + IDENT [68] { + name: @it:0:0 + } + CONSTANT [69] { value: 1 } + } + } + CALL [70] { + function: _>_ + args: { + IDENT [71] { + name: @it2:0:0 + } + CONSTANT [72] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [73] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + LIST [11] { + elements: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_range: { + IDENT [17] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:0:0 + } + LIST [29] { + elements: { + CALL [30] { + function: _+_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + IDENT [35] { + name: @index2 + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @it:0:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @ac:0:0 + } + LIST [33] { + elements: { + IDENT [34] { + name: @it:0:0 + } + } + } + } + } + IDENT [35] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [37] { + name: @ac:1:0 + } + } + } + IDENT [38] { + name: @index0 + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + } + CALL [7] { + function: _+_ + args: { + COMPREHENSION [8] { + iter_var: @it:0:0 + iter_range: { + IDENT [9] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [10] { + elements: { + } + } + } + loop_condition: { + CONSTANT [11] { value: true } + } + loop_step: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @ac:0:0 + } + LIST [14] { + elements: { + CALL [15] { + function: _*_ + args: { + IDENT [16] { + name: @it:0:0 + } + CONSTANT [17] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @ac:0:0 + } + } + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_range: { + IDENT [21] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:0:0 + } + LIST [26] { + elements: { + CALL [27] { + function: _*_ + args: { + IDENT [28] { + name: @it:0:0 + } + CONSTANT [29] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [31] { + elements: { + } + } + } + loop_condition: { + CONSTANT [32] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [34] { + name: @ac:1:0 + } + LIST [35] { + elements: { + CALL [36] { + function: _*_ + args: { + IDENT [37] { + name: @it:1:0 + } + CONSTANT [38] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [39] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + LIST [11] { + elements: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [17] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:0:0 + } + LIST [29] { + elements: { + CALL [30] { + function: _+_ + args: { + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it:0:0 + } + IDENT [33] { + name: @it2:0:0 + } + } + } + CONSTANT [34] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [35] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:1:0 + } + } + } + IDENT [37] { + name: @index2 + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _&&_ + args: { + CALL [29] { + function: _==_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:1:0 + } + } + } + CALL [32] { + function: _<_ + args: { + IDENT [33] { + name: @it:1:0 + } + IDENT [34] { + name: @it2:1:0 + } + } + } + } + } + CALL [35] { + function: _+_ + args: { + IDENT [36] { + name: @ac:0:0 + } + LIST [37] { + elements: { + IDENT [38] { + name: @it:0:0 + } + } + } + } + } + IDENT [39] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:1:0 + } + } + } + IDENT [42] { + name: @index0 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + COMPREHENSION [8] { + iter_var: @it:1:0 + iter_range: { + IDENT [9] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [10] { + elements: { + } + } + } + loop_condition: { + CONSTANT [11] { value: true } + } + loop_step: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @ac:1:0 + } + LIST [14] { + elements: { + COMPREHENSION [15] { + iter_var: @it:0:0 + iter_range: { + IDENT [16] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [17] { + elements: { + } + } + } + loop_condition: { + CONSTANT [18] { value: true } + } + loop_step: { + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @ac:0:0 + } + LIST [21] { + elements: { + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @it:0:0 + } + CONSTANT [24] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [25] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [26] { + name: @ac:1:0 + } + } + } + COMPREHENSION [27] { + iter_var: @it:1:0 + iter_range: { + IDENT [28] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @ac:1:0 + } + LIST [33] { + elements: { + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + IDENT [35] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [36] { + elements: { + } + } + } + loop_condition: { + CONSTANT [37] { value: true } + } + loop_step: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @ac:0:0 + } + LIST [40] { + elements: { + CALL [41] { + function: _+_ + args: { + IDENT [42] { + name: @it:0:0 + } + CONSTANT [43] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [44] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [45] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + COMPREHENSION [8] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [9] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [10] { + + } + } + loop_condition: { + CONSTANT [11] { value: true } + } + loop_step: { + CALL [12] { + function: cel.@mapInsert + args: { + IDENT [13] { + name: @ac:1:0 + } + IDENT [14] { + name: @it:1:0 + } + COMPREHENSION [15] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [16] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [17] { + + } + } + loop_condition: { + CONSTANT [18] { value: true } + } + loop_step: { + CALL [19] { + function: cel.@mapInsert + args: { + IDENT [20] { + name: @ac:0:0 + } + IDENT [21] { + name: @it:0:0 + } + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @it:0:0 + } + IDENT [25] { + name: @it2:0:0 + } + } + } + CONSTANT [26] { value: 1 } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:1:0 + } + } + } + COMPREHENSION [29] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [30] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [31] { + + } + } + loop_condition: { + CONSTANT [32] { value: true } + } + loop_step: { + CALL [33] { + function: cel.@mapInsert + args: { + IDENT [34] { + name: @ac:1:0 + } + IDENT [35] { + name: @it:1:0 + } + COMPREHENSION [36] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [37] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [38] { + + } + } + loop_condition: { + CONSTANT [39] { value: true } + } + loop_step: { + CALL [40] { + function: cel.@mapInsert + args: { + IDENT [41] { + name: @ac:0:0 + } + IDENT [42] { + name: @it:0:0 + } + CALL [43] { + function: _+_ + args: { + CALL [44] { + function: _+_ + args: { + IDENT [45] { + name: @it:0:0 + } + IDENT [46] { + name: @it2:0:0 + } + } + } + CONSTANT [47] { value: 1 } + } + } + } + } + } + result: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [49] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: @in + args: { + CONSTANT [4] { value: 1 } + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + CONSTANT [8] { value: 3 } + } + } + } + } + LIST [9] { + elements: { + CONSTANT [10] { value: 1 } + CONSTANT [11] { value: 2 } + CONSTANT [12] { value: 3 } + } + } + CALL [13] { + function: _&&_ + args: { + IDENT [14] { + name: @index0 + } + CALL [15] { + function: @in + args: { + CONSTANT [16] { value: 2 } + IDENT [17] { + name: @index1 + } + } + } + } + } + CALL [18] { + function: @in + args: { + CONSTANT [19] { value: 3 } + LIST [20] { + elements: { + CONSTANT [21] { value: 3 } + IDENT [22] { + name: @index1 + } + } + } + } + } + } + } + CALL [23] { + function: _&&_ + args: { + IDENT [24] { + name: @index2 + } + CALL [25] { + function: _&&_ + args: { + IDENT [26] { + name: @index3 + } + IDENT [27] { + name: @index0 + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + LIST [13] { + elements: { + LIST [14] { + elements: { + CONSTANT [15] { value: 3 } + CONSTANT [16] { value: 4 } + } + } + } + } + COMPREHENSION [17] { + iter_var: @it:0:0 + iter_range: { + IDENT [18] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [19] { + elements: { + } + } + } + loop_condition: { + CONSTANT [20] { value: true } + } + loop_step: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @ac:0:0 + } + IDENT [23] { + name: @index2 + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + LIST [25] { + elements: { + IDENT [26] { + name: @index3 + } + } + } + } + } + CALL [27] { + function: _==_ + args: { + COMPREHENSION [28] { + iter_var: @it:1:0 + iter_range: { + IDENT [29] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [30] { + elements: { + } + } + } + loop_condition: { + CONSTANT [31] { value: true } + } + loop_step: { + CALL [32] { + function: _+_ + args: { + IDENT [33] { + name: @ac:1:0 + } + IDENT [34] { + name: @index4 + } + } + } + } + result: { + IDENT [35] { + name: @ac:1:0 + } + } + } + LIST [36] { + elements: { + IDENT [37] { + name: @index0 + } + IDENT [38] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + LIST [13] { + elements: { + LIST [14] { + elements: { + CONSTANT [15] { value: 3 } + CONSTANT [16] { value: 4 } + } + } + } + } + COMPREHENSION [17] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [18] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [19] { + elements: { + } + } + } + loop_condition: { + CONSTANT [20] { value: true } + } + loop_step: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @ac:0:0 + } + IDENT [23] { + name: @index2 + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + LIST [25] { + elements: { + IDENT [26] { + name: @index3 + } + } + } + } + } + CALL [27] { + function: _==_ + args: { + COMPREHENSION [28] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [29] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [30] { + elements: { + } + } + } + loop_condition: { + CONSTANT [31] { value: true } + } + loop_step: { + CALL [32] { + function: _+_ + args: { + IDENT [33] { + name: @ac:1:0 + } + IDENT [34] { + name: @index4 + } + } + } + } + result: { + IDENT [35] { + name: @ac:1:0 + } + } + } + LIST [36] { + elements: { + IDENT [37] { + name: @index0 + } + IDENT [38] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + CONSTANT [6] { value: 1 } + } + } + CONSTANT [7] { value: 3 } + } + } + CALL [8] { + function: _?_:_ + args: { + IDENT [9] { + name: @index0 + } + CALL [10] { + function: _-_ + args: { + IDENT [11] { + name: x + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + LIST [14] { + elements: { + IDENT [15] { + name: @index1 + } + } + } + } + } + CALL [16] { + function: _||_ + args: { + COMPREHENSION [17] { + iter_var: @it:0:0 + iter_range: { + IDENT [18] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + CALL [26] { + function: _-_ + args: { + IDENT [27] { + name: @it:0:0 + } + CONSTANT [28] { value: 1 } + } + } + CONSTANT [29] { value: 3 } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:0:0 + } + } + } + IDENT [31] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: "foo" } + CONSTANT [5] { value: "bar" } + } + } + } + } + COMPREHENSION [6] { + iter_var: @it:1:0 + iter_range: { + COMPREHENSION [7] { + iter_var: @it:0:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [9] { + elements: { + } + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @ac:0:0 + } + LIST [13] { + elements: { + LIST [14] { + elements: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @it:0:0 + } + IDENT [17] { + name: @it:0:0 + } + } + } + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it:0:0 + } + IDENT [20] { + name: @it:0:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:1:0 + } + LIST [26] { + elements: { + LIST [27] { + elements: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @it:1:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it:1:0 + } + IDENT [33] { + name: @it:1:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _-_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + IDENT [6] { + name: y + } + } + } + CONSTANT [7] { value: 1 } + } + } + CALL [8] { + function: _>_ + args: { + IDENT [9] { + name: @index0 + } + CONSTANT [10] { value: 3 } + } + } + LIST [11] { + elements: { + CALL [12] { + function: _?_:_ + args: { + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 5 } + } + } + } + } + } + } + CALL [16] { + function: _||_ + args: { + COMPREHENSION [17] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [18] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + CALL [26] { + function: _-_ + args: { + CALL [27] { + function: _-_ + args: { + IDENT [28] { + name: @it:0:0 + } + IDENT [29] { + name: @it2:0:0 + } + } + } + CONSTANT [30] { value: 1 } + } + } + CONSTANT [31] { value: 3 } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:0:0 + } + } + } + IDENT [33] { + name: @index1 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: "foo" } + CONSTANT [5] { value: "bar" } + } + } + } + } + COMPREHENSION [6] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + COMPREHENSION [7] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [9] { + + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: cel.@mapInsert + args: { + IDENT [12] { + name: @ac:0:0 + } + IDENT [13] { + name: @it:0:0 + } + LIST [14] { + elements: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @it:0:0 + } + IDENT [17] { + name: @it:0:0 + } + } + } + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it2:0:0 + } + IDENT [20] { + name: @it2:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [22] { + + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: cel.@mapInsert + args: { + IDENT [25] { + name: @ac:1:0 + } + IDENT [26] { + name: @it:1:0 + } + LIST [27] { + elements: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @it:1:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it2:1:0 + } + IDENT [33] { + name: @it2:1:0 + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: @index0 + }.payload + }.single_int64 + } + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + IDENT [10] { + name: @index0 + }.payload~presence_test + } + IDENT [11] { + name: @index1 + } + CONSTANT [12] { value: 0 } + } + } + } + } + CALL [13] { + function: _==_ + args: { + IDENT [14] { + name: @index2 + } + CONSTANT [15] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + SELECT [8] { + SELECT [9] { + IDENT [10] { + name: msg + }.oneof_type + }.payload~presence_test + } + CALL [11] { + function: _?_:_ + args: { + IDENT [12] { + name: @index2 + } + IDENT [13] { + name: @index1 + } + CALL [14] { + function: _*_ + args: { + IDENT [15] { + name: @index1 + } + CONSTANT [16] { value: 0 } + } + } + } + } + } + } + CALL [17] { + function: _==_ + args: { + IDENT [18] { + name: @index3 + } + CONSTANT [19] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + IDENT [10] { + name: @index0 + }.single_int64~presence_test + } + IDENT [11] { + name: @index1 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index1 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + IDENT [16] { + name: @index2 + } + CONSTANT [17] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.map_string_string + } + SELECT [8] { + SELECT [9] { + IDENT [10] { + name: msg + }.oneof_type + }.payload~presence_test + } + CALL [11] { + function: _&&_ + args: { + SELECT [12] { + IDENT [13] { + name: msg + }.oneof_type~presence_test + } + IDENT [14] { + name: @index2 + } + } + } + CALL [15] { + function: _&&_ + args: { + IDENT [16] { + name: @index3 + } + SELECT [17] { + IDENT [18] { + name: @index0 + }.single_int64~presence_test + } + } + } + CALL [19] { + function: _&&_ + args: { + SELECT [20] { + IDENT [21] { + name: @index0 + }.map_string_string~presence_test + } + SELECT [22] { + IDENT [23] { + name: @index1 + }.key~presence_test + } + } + } + CALL [24] { + function: _==_ + args: { + SELECT [25] { + IDENT [26] { + name: @index1 + }.key + } + CONSTANT [27] { value: "A" } + } + } + } + } + CALL [28] { + function: _?_:_ + args: { + IDENT [29] { + name: @index4 + } + CALL [30] { + function: _?_:_ + args: { + IDENT [31] { + name: @index5 + } + IDENT [32] { + name: @index6 + } + CONSTANT [33] { value: false } + } + } + CONSTANT [34] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CALL [4] { + function: optional.none + args: { + } + } + IDENT [5] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [6] { + elements: { + CONSTANT [7] { value: 5 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 10 } + CALL [10] { + function: optional.none + args: { + } + } + IDENT [11] { + name: @index0 + } + IDENT [12] { + name: @index0 + } + } + optional_indices: [0] + } + } + } + CALL [13] { + function: _==_ + args: { + IDENT [14] { + name: @index2 + } + LIST [15] { + elements: { + CONSTANT [16] { value: 10 } + IDENT [17] { + name: @index1 + } + IDENT [18] { + name: @index1 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "hello" } + } + optional_entry: true + value: { + CALL [6] { + function: optional.of + args: { + CONSTANT [7] { value: "hello" } + } + } + } + } + } + CALL [8] { + function: _[_] + args: { + IDENT [9] { + name: @index0 + } + CONSTANT [10] { value: "hello" } + } + } + } + } + CALL [11] { + function: _==_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + CONSTANT [15] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + MAP [7] { + MAP_ENTRY [8] { + key: { + CONSTANT [9] { value: "key" } + } + optional_entry: true + value: { + CALL [10] { + function: optional.of + args: { + CONSTANT [11] { value: "test" } + } + } + } + } + } + CALL [12] { + function: or + target: { + CALL [13] { + function: _[?_] + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: "bogus" } + } + } + } + args: { + CALL [16] { + function: _[?_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: "bogus" } + } + } + } + } + CALL [19] { + function: orValue + target: { + IDENT [20] { + name: @index2 + } + } + args: { + CALL [21] { + function: _[_] + args: { + IDENT [22] { + name: @index0 + } + CONSTANT [23] { value: "key" } + } + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + IDENT [25] { + name: @index3 + } + CONSTANT [26] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + CALL [10] { + function: _+_ + args: { + SELECT [11] { + IDENT [12] { + name: @index0 + }.single_int32 + } + SELECT [13] { + IDENT [14] { + name: @index0 + }.single_int64 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + IDENT [16] { + name: @index1 + } + CONSTANT [17] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [5] { value: "h" } + CONSTANT [6] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: "l" } + } + } + CONSTANT [12] { value: "o" } + } + } + } + } + CALL [13] { + function: matches + target: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index1 + } + CONSTANT [16] { value: " world" } + } + } + } + args: { + IDENT [17] { + name: @index1 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [5] { value: "h" } + CONSTANT [6] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: "l" } + } + } + CONSTANT [12] { value: "o" } + } + } + } + } + CALL [13] { + function: matches + target: { + CONSTANT [14] { value: "hello world" } + } + args: { + IDENT [15] { + name: @index1 + } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [5] { value: "h" } + CONSTANT [6] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: "l" } + } + } + CONSTANT [12] { value: "o" } + } + } + } + } + CALL [13] { + function: matches + target: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index1 + } + CONSTANT [16] { value: " world" } + } + } + } + args: { + CONSTANT [17] { value: "hello" } + } + } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [5] { value: "h" } + CONSTANT [6] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: "l" } + } + } + CONSTANT [12] { value: "o" } + } + } + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CONSTANT [15] { value: "w" } + CONSTANT [16] { value: "o" } + } + } + CONSTANT [17] { value: "r" } + } + } + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @index2 + } + CONSTANT [21] { value: "l" } + } + } + CONSTANT [22] { value: "d" } + } + } + } + } + CALL [23] { + function: matches + target: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @index1 + } + CONSTANT [26] { value: " world" } + } + } + } + args: { + IDENT [27] { + name: @index3 + } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + SELECT [6] { + IDENT [7] { + name: @index0 + }.single_int64 + } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: non_pure_custom_func + args: { + IDENT [12] { + name: @index1 + } + } + } + CALL [13] { + function: non_pure_custom_func + args: { + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int32 + } + } + } + } + } + CALL [16] { + function: non_pure_custom_func + args: { + IDENT [17] { + name: @index1 + } + } + } + } + } + CALL [18] { + function: non_pure_custom_func + args: { + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + }.payload + } + CALL [6] { + function: pure_custom_func + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.single_int64 + } + } + } + CALL [9] { + function: pure_custom_func + args: { + SELECT [10] { + IDENT [11] { + name: @index0 + }.single_int32 + } + } + } + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index1 + } + IDENT [15] { + name: @index2 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + CALL [17] { + function: pure_custom_func + args: { + SELECT [18] { + IDENT [19] { + name: msg + }.single_int64 + } + } + } + } + } + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @index3 + } + IDENT [22] { + name: @index4 + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_3.baseline b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_3.baseline new file mode 100644 index 000000000..89b1069ad --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_3.baseline @@ -0,0 +1,5442 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + IDENT [11] { + name: @index0 + } + } + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CONSTANT [10] { value: 2 } + IDENT [11] { + name: @index0 + } + } + } + IDENT [12] { + name: @index0 + } + } + } + CONSTANT [13] { value: 1 } + } + } + } + } + CALL [14] { + function: _==_ + args: { + IDENT [15] { + name: @index1 + } + CONSTANT [16] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + IDENT [15] { + name: @index1 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + } + } + CALL [17] { + function: _==_ + args: { + IDENT [18] { + name: @index2 + } + CONSTANT [19] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CONSTANT [18] { value: 5 } + IDENT [19] { + name: @index0 + } + } + } + IDENT [20] { + name: @index0 + } + } + } + IDENT [21] { + name: @index1 + } + } + } + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @index3 + } + IDENT [26] { + name: @index1 + } + } + } + IDENT [27] { + name: @index2 + } + } + } + IDENT [28] { + name: @index2 + } + } + } + } + } + CALL [29] { + function: _==_ + args: { + IDENT [30] { + name: @index4 + } + CONSTANT [31] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: timestamp + args: { + CALL [4] { + function: int + args: { + CALL [5] { + function: timestamp + args: { + CONSTANT [6] { value: 1000000000 } + } + } + } + } + } + } + CALL [7] { + function: timestamp + args: { + CALL [8] { + function: int + args: { + CALL [9] { + function: timestamp + args: { + CONSTANT [10] { value: 50 } + } + } + } + } + } + } + CALL [11] { + function: timestamp + args: { + CALL [12] { + function: int + args: { + CALL [13] { + function: timestamp + args: { + CONSTANT [14] { value: 200 } + } + } + } + } + } + } + CALL [15] { + function: timestamp + args: { + CALL [16] { + function: int + args: { + CALL [17] { + function: timestamp + args: { + CONSTANT [18] { value: 75 } + } + } + } + } + } + } + CALL [19] { + function: getFullYear + target: { + IDENT [20] { + name: @index0 + } + } + args: { + } + } + CALL [21] { + function: getFullYear + target: { + IDENT [22] { + name: @index2 + } + } + args: { + } + } + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @index4 + } + CALL [26] { + function: getFullYear + target: { + IDENT [27] { + name: @index3 + } + } + args: { + } + } + } + } + CALL [28] { + function: getFullYear + target: { + IDENT [29] { + name: @index1 + } + } + args: { + } + } + } + } + CALL [30] { + function: _+_ + args: { + CALL [31] { + function: _+_ + args: { + CALL [32] { + function: _+_ + args: { + IDENT [33] { + name: @index6 + } + IDENT [34] { + name: @index4 + } + } + } + CALL [35] { + function: getSeconds + target: { + IDENT [36] { + name: @index1 + } + } + args: { + } + } + } + } + IDENT [37] { + name: @index5 + } + } + } + CALL [38] { + function: _+_ + args: { + CALL [39] { + function: _+_ + args: { + CALL [40] { + function: _+_ + args: { + IDENT [41] { + name: @index7 + } + IDENT [42] { + name: @index5 + } + } + } + CALL [43] { + function: getMinutes + target: { + IDENT [44] { + name: @index3 + } + } + args: { + } + } + } + } + IDENT [45] { + name: @index4 + } + } + } + } + } + CALL [46] { + function: _==_ + args: { + IDENT [47] { + name: @index8 + } + CONSTANT [48] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + } + } + CONSTANT [15] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "e" } + } + value: { + MAP [6] { + MAP_ENTRY [7] { + key: { + CONSTANT [8] { value: "b" } + } + value: { + CONSTANT [9] { value: 1 } + } + } + } + } + } + } + MAP [10] { + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: "b" } + } + value: { + CONSTANT [13] { value: 1 } + } + } + } + } + } + MAP [14] { + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "a" } + } + value: { + IDENT [17] { + name: @index1 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "c" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "d" } + } + value: { + IDENT [23] { + name: @index0 + } + } + } + MAP_ENTRY [24] { + key: { + CONSTANT [25] { value: "e" } + } + value: { + IDENT [26] { + name: @index0 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + SELECT [13] { + IDENT [14] { + name: @index1 + }.single_int32 + } + } + } + IDENT [15] { + name: @index0 + } + } + } + SELECT [16] { + SELECT [17] { + SELECT [18] { + IDENT [19] { + name: @index1 + }.oneof_type + }.payload + }.single_int64 + } + CALL [20] { + function: _+_ + args: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @index2 + } + SELECT [23] { + IDENT [24] { + name: msg + }.single_int64 + } + } + } + IDENT [25] { + name: @index3 + } + } + } + } + } + CALL [26] { + function: _==_ + args: { + IDENT [27] { + name: @index4 + } + CONSTANT [28] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.oneof_type + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: @index0 + }.payload + }.oneof_type + } + SELECT [10] { + SELECT [11] { + SELECT [12] { + IDENT [13] { + name: @index1 + }.payload + }.oneof_type + }.payload + } + SELECT [14] { + SELECT [15] { + SELECT [16] { + IDENT [17] { + name: @index1 + }.child + }.child + }.payload + } + } + } + CALL [18] { + function: _||_ + args: { + CALL [19] { + function: _||_ + args: { + CONSTANT [20] { value: true } + SELECT [21] { + IDENT [22] { + name: @index2 + }.single_bool + } + } + } + SELECT [23] { + IDENT [24] { + name: @index3 + }.single_bool + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CALL [7] { + function: _[_] + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 1 } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + IDENT [15] { + name: @index1 + } + } + } + CONSTANT [16] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _[_] + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _[_] + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 1 } + } + } + } + } + CALL [15] { + function: _[_] + args: { + IDENT [16] { + name: @index0 + } + CONSTANT [17] { value: 2 } + } + } + } + } + } + } + CALL [18] { + function: _==_ + args: { + IDENT [19] { + name: @index1 + } + CONSTANT [20] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.oneof_type + } + SELECT [7] { + SELECT [8] { + SELECT [9] { + IDENT [10] { + name: @index0 + }.payload + }.oneof_type + }.payload + } + } + } + SELECT [11] { + SELECT [12] { + SELECT [13] { + IDENT [14] { + name: @index1 + }.oneof_type + }.payload + }.single_int64 + } + } +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CONSTANT [12] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + CALL [5] { + function: _+_ + args: { + IDENT [6] { + name: @index0 + } + CALL [7] { + function: _*_ + args: { + CALL [8] { + function: _+_ + args: { + IDENT [9] { + name: @index0 + } + CONSTANT [10] { value: 1 } + } + } + CONSTANT [11] { value: 2 } + } + } + } + } + } + } + CALL [12] { + function: _?_:_ + args: { + CONSTANT [13] { value: false } + CONSTANT [14] { value: false } + CALL [15] { + function: _==_ + args: { + IDENT [16] { + name: @index1 + } + CONSTANT [17] { value: 11 } + } + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + CALL [7] { + function: _?_:_ + args: { + CALL [8] { + function: _>_ + args: { + IDENT [9] { + name: @index0 + } + CONSTANT [10] { value: 0 } + } + } + CALL [11] { + function: _?_:_ + args: { + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @index1 + } + CONSTANT [14] { value: 0 } + } + } + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index0 + } + IDENT [17] { + name: @index1 + } + } + } + CONSTANT [18] { value: 0 } + } + } + CONSTANT [19] { value: 0 } + } + } + } + } + CALL [20] { + function: _==_ + args: { + IDENT [21] { + name: @index2 + } + CONSTANT [22] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:0 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + IDENT [31] { + name: @index0 + } + } + } + } + } + CALL [32] { + function: size + args: { + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + } + } + } + } + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + IDENT [38] { + name: @index2 + } + IDENT [39] { + name: @index2 + } + } + } + IDENT [40] { + name: @index3 + } + } + } + IDENT [41] { + name: @index3 + } + } + } + } + } + CALL [42] { + function: _==_ + args: { + IDENT [43] { + name: @index4 + } + CONSTANT [44] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:1 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: "a" } + } + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:1 + } + CALL [25] { + function: _==_ + args: { + IDENT [26] { + name: @it:0:1 + } + CONSTANT [27] { value: "a" } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:1 + } + } + } + LIST [29] { + elements: { + IDENT [30] { + name: @index0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + } + } + CALL [33] { + function: _+_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + IDENT [36] { + name: @index2 + } + IDENT [37] { + name: @index2 + } + } + } + IDENT [38] { + name: @index3 + } + } + } + IDENT [39] { + name: @index3 + } + } + } + } + } + CALL [40] { + function: _==_ + args: { + IDENT [41] { + name: @index4 + } + LIST [42] { + elements: { + CONSTANT [43] { value: true } + CONSTANT [44] { value: true } + CONSTANT [45] { value: true } + CONSTANT [46] { value: true } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @index0 + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _&&_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + LIST [22] { + elements: { + CONSTANT [23] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [24] { value: false } + } + loop_condition: { + CALL [25] { + function: @not_strictly_false + args: { + CALL [26] { + function: !_ + args: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [28] { + function: _||_ + args: { + IDENT [29] { + name: @ac:0:0 + } + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [37] { value: false } + } + loop_condition: { + CALL [38] { + function: @not_strictly_false + args: { + CALL [39] { + function: !_ + args: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [41] { + function: _||_ + args: { + IDENT [42] { + name: @ac:0:0 + } + CALL [43] { + function: _>_ + args: { + IDENT [44] { + name: @it:0:0 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: size + args: { + LIST [12] { + elements: { + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [14] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [15] { value: false } + } + loop_condition: { + CALL [16] { + function: @not_strictly_false + args: { + CALL [17] { + function: !_ + args: { + IDENT [18] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [19] { + function: _||_ + args: { + IDENT [20] { + name: @ac:0:0 + } + CALL [21] { + function: _&&_ + args: { + CALL [22] { + function: _>_ + args: { + IDENT [23] { + name: @it:0:0 + } + CONSTANT [24] { value: 0 } + } + } + CALL [25] { + function: _>=_ + args: { + IDENT [26] { + name: @it2:0:0 + } + CONSTANT [27] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + COMPREHENSION [31] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [32] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [33] { value: false } + } + loop_condition: { + CALL [34] { + function: @not_strictly_false + args: { + CALL [35] { + function: !_ + args: { + IDENT [36] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [37] { + function: _||_ + args: { + IDENT [38] { + name: @ac:0:0 + } + CALL [39] { + function: _&&_ + args: { + CALL [40] { + function: _>_ + args: { + IDENT [41] { + name: @it:0:0 + } + CONSTANT [42] { value: 0 } + } + } + CALL [43] { + function: _>=_ + args: { + IDENT [44] { + name: @it2:0:0 + } + CONSTANT [45] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [47] { + function: size + args: { + LIST [48] { + elements: { + COMPREHENSION [49] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [50] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [51] { value: false } + } + loop_condition: { + CALL [52] { + function: @not_strictly_false + args: { + CALL [53] { + function: !_ + args: { + IDENT [54] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [55] { + function: _||_ + args: { + IDENT [56] { + name: @ac:0:0 + } + CALL [57] { + function: _&&_ + args: { + CALL [58] { + function: _>_ + args: { + IDENT [59] { + name: @it:0:0 + } + CONSTANT [60] { value: 1 } + } + } + CALL [61] { + function: _>=_ + args: { + IDENT [62] { + name: @it2:0:0 + } + CONSTANT [63] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [64] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CALL [65] { + function: size + args: { + LIST [66] { + elements: { + COMPREHENSION [67] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [68] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [69] { value: false } + } + loop_condition: { + CALL [70] { + function: @not_strictly_false + args: { + CALL [71] { + function: !_ + args: { + IDENT [72] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [73] { + function: _||_ + args: { + IDENT [74] { + name: @ac:0:0 + } + CALL [75] { + function: _&&_ + args: { + CALL [76] { + function: _>_ + args: { + IDENT [77] { + name: @it:0:0 + } + CONSTANT [78] { value: 1 } + } + } + CALL [79] { + function: _>=_ + args: { + IDENT [80] { + name: @it2:0:0 + } + CONSTANT [81] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [82] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + } + CONSTANT [83] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + LIST [5] { + elements: { + CONSTANT [6] { value: 2 } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + CALL [8] { + function: _&&_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [10] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [11] { value: false } + } + loop_condition: { + CALL [12] { + function: @not_strictly_false + args: { + CALL [13] { + function: !_ + args: { + IDENT [14] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [15] { + function: _||_ + args: { + IDENT [16] { + name: @ac:0:0 + } + CALL [17] { + function: _&&_ + args: { + CALL [18] { + function: _>_ + args: { + IDENT [19] { + name: @it:0:0 + } + CONSTANT [20] { value: 0 } + } + } + CALL [21] { + function: _>_ + args: { + IDENT [22] { + name: @it2:0:0 + } + CONSTANT [23] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [26] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [27] { value: false } + } + loop_condition: { + CALL [28] { + function: @not_strictly_false + args: { + CALL [29] { + function: !_ + args: { + IDENT [30] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [31] { + function: _||_ + args: { + IDENT [32] { + name: @ac:0:0 + } + CALL [33] { + function: _&&_ + args: { + CALL [34] { + function: _>_ + args: { + IDENT [35] { + name: @it:0:0 + } + CONSTANT [36] { value: 0 } + } + } + CALL [37] { + function: _>_ + args: { + IDENT [38] { + name: @it2:0:0 + } + CONSTANT [39] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + CALL [41] { + function: _&&_ + args: { + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [43] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [44] { value: false } + } + loop_condition: { + CALL [45] { + function: @not_strictly_false + args: { + CALL [46] { + function: !_ + args: { + IDENT [47] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [48] { + function: _||_ + args: { + IDENT [49] { + name: @ac:0:0 + } + CALL [50] { + function: _&&_ + args: { + CALL [51] { + function: _>_ + args: { + IDENT [52] { + name: @it:0:0 + } + CONSTANT [53] { value: 1 } + } + } + CALL [54] { + function: _>_ + args: { + IDENT [55] { + name: @it2:0:0 + } + CONSTANT [56] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [57] { + name: @ac:0:0 + } + } + } + COMPREHENSION [58] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [59] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [60] { value: false } + } + loop_condition: { + CALL [61] { + function: @not_strictly_false + args: { + CALL [62] { + function: !_ + args: { + IDENT [63] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [64] { + function: _||_ + args: { + IDENT [65] { + name: @ac:0:0 + } + CALL [66] { + function: _&&_ + args: { + CALL [67] { + function: _>_ + args: { + IDENT [68] { + name: @it:0:0 + } + CONSTANT [69] { value: 1 } + } + } + CALL [70] { + function: _>_ + args: { + IDENT [71] { + name: @it2:0:0 + } + CONSTANT [72] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [73] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + LIST [11] { + elements: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_range: { + IDENT [17] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:0:0 + } + LIST [29] { + elements: { + CALL [30] { + function: _+_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + IDENT [35] { + name: @index2 + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @it:0:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @ac:0:0 + } + LIST [33] { + elements: { + IDENT [34] { + name: @it:0:0 + } + } + } + } + } + IDENT [35] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [37] { + name: @ac:1:0 + } + } + } + IDENT [38] { + name: @index0 + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + } + CALL [7] { + function: _+_ + args: { + COMPREHENSION [8] { + iter_var: @it:0:0 + iter_range: { + IDENT [9] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [10] { + elements: { + } + } + } + loop_condition: { + CONSTANT [11] { value: true } + } + loop_step: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @ac:0:0 + } + LIST [14] { + elements: { + CALL [15] { + function: _*_ + args: { + IDENT [16] { + name: @it:0:0 + } + CONSTANT [17] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @ac:0:0 + } + } + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_range: { + IDENT [21] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:0:0 + } + LIST [26] { + elements: { + CALL [27] { + function: _*_ + args: { + IDENT [28] { + name: @it:0:0 + } + CONSTANT [29] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [31] { + elements: { + } + } + } + loop_condition: { + CONSTANT [32] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [34] { + name: @ac:1:0 + } + LIST [35] { + elements: { + CALL [36] { + function: _*_ + args: { + IDENT [37] { + name: @it:1:0 + } + CONSTANT [38] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [39] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + LIST [11] { + elements: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [17] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:0:0 + } + LIST [29] { + elements: { + CALL [30] { + function: _+_ + args: { + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it:0:0 + } + IDENT [33] { + name: @it2:0:0 + } + } + } + CONSTANT [34] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [35] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:1:0 + } + } + } + IDENT [37] { + name: @index2 + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _&&_ + args: { + CALL [29] { + function: _==_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:1:0 + } + } + } + CALL [32] { + function: _<_ + args: { + IDENT [33] { + name: @it:1:0 + } + IDENT [34] { + name: @it2:1:0 + } + } + } + } + } + CALL [35] { + function: _+_ + args: { + IDENT [36] { + name: @ac:0:0 + } + LIST [37] { + elements: { + IDENT [38] { + name: @it:0:0 + } + } + } + } + } + IDENT [39] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:1:0 + } + } + } + IDENT [42] { + name: @index0 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + COMPREHENSION [8] { + iter_var: @it:1:0 + iter_range: { + IDENT [9] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [10] { + elements: { + } + } + } + loop_condition: { + CONSTANT [11] { value: true } + } + loop_step: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @ac:1:0 + } + LIST [14] { + elements: { + COMPREHENSION [15] { + iter_var: @it:0:0 + iter_range: { + IDENT [16] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [17] { + elements: { + } + } + } + loop_condition: { + CONSTANT [18] { value: true } + } + loop_step: { + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @ac:0:0 + } + LIST [21] { + elements: { + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @it:0:0 + } + CONSTANT [24] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [25] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [26] { + name: @ac:1:0 + } + } + } + COMPREHENSION [27] { + iter_var: @it:1:0 + iter_range: { + IDENT [28] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @ac:1:0 + } + LIST [33] { + elements: { + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + IDENT [35] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [36] { + elements: { + } + } + } + loop_condition: { + CONSTANT [37] { value: true } + } + loop_step: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @ac:0:0 + } + LIST [40] { + elements: { + CALL [41] { + function: _+_ + args: { + IDENT [42] { + name: @it:0:0 + } + CONSTANT [43] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [44] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [45] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + } + CALL [7] { + function: _==_ + args: { + COMPREHENSION [8] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [9] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [10] { + + } + } + loop_condition: { + CONSTANT [11] { value: true } + } + loop_step: { + CALL [12] { + function: cel.@mapInsert + args: { + IDENT [13] { + name: @ac:1:0 + } + IDENT [14] { + name: @it:1:0 + } + COMPREHENSION [15] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [16] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [17] { + + } + } + loop_condition: { + CONSTANT [18] { value: true } + } + loop_step: { + CALL [19] { + function: cel.@mapInsert + args: { + IDENT [20] { + name: @ac:0:0 + } + IDENT [21] { + name: @it:0:0 + } + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @it:0:0 + } + IDENT [25] { + name: @it2:0:0 + } + } + } + CONSTANT [26] { value: 1 } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:1:0 + } + } + } + COMPREHENSION [29] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [30] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [31] { + + } + } + loop_condition: { + CONSTANT [32] { value: true } + } + loop_step: { + CALL [33] { + function: cel.@mapInsert + args: { + IDENT [34] { + name: @ac:1:0 + } + IDENT [35] { + name: @it:1:0 + } + COMPREHENSION [36] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [37] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [38] { + + } + } + loop_condition: { + CONSTANT [39] { value: true } + } + loop_step: { + CALL [40] { + function: cel.@mapInsert + args: { + IDENT [41] { + name: @ac:0:0 + } + IDENT [42] { + name: @it:0:0 + } + CALL [43] { + function: _+_ + args: { + CALL [44] { + function: _+_ + args: { + IDENT [45] { + name: @it:0:0 + } + IDENT [46] { + name: @it2:0:0 + } + } + } + CONSTANT [47] { value: 1 } + } + } + } + } + } + result: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [49] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: @in + args: { + CONSTANT [4] { value: 1 } + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + CONSTANT [8] { value: 3 } + } + } + } + } + LIST [9] { + elements: { + CONSTANT [10] { value: 1 } + CONSTANT [11] { value: 2 } + CONSTANT [12] { value: 3 } + } + } + CALL [13] { + function: _&&_ + args: { + CALL [14] { + function: @in + args: { + CONSTANT [15] { value: 3 } + LIST [16] { + elements: { + CONSTANT [17] { value: 3 } + IDENT [18] { + name: @index1 + } + } + } + } + } + IDENT [19] { + name: @index0 + } + } + } + } + } + CALL [20] { + function: _&&_ + args: { + CALL [21] { + function: _&&_ + args: { + IDENT [22] { + name: @index0 + } + CALL [23] { + function: @in + args: { + CONSTANT [24] { value: 2 } + IDENT [25] { + name: @index1 + } + } + } + } + } + IDENT [26] { + name: @index2 + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + LIST [13] { + elements: { + LIST [14] { + elements: { + CONSTANT [15] { value: 3 } + CONSTANT [16] { value: 4 } + } + } + } + } + COMPREHENSION [17] { + iter_var: @it:0:0 + iter_range: { + IDENT [18] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [19] { + elements: { + } + } + } + loop_condition: { + CONSTANT [20] { value: true } + } + loop_step: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @ac:0:0 + } + IDENT [23] { + name: @index2 + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + CALL [25] { + function: _==_ + args: { + COMPREHENSION [26] { + iter_var: @it:1:0 + iter_range: { + IDENT [27] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [28] { + elements: { + } + } + } + loop_condition: { + CONSTANT [29] { value: true } + } + loop_step: { + CALL [30] { + function: _+_ + args: { + IDENT [31] { + name: @ac:1:0 + } + LIST [32] { + elements: { + IDENT [33] { + name: @index3 + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + LIST [35] { + elements: { + IDENT [36] { + name: @index0 + } + IDENT [37] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + LIST [13] { + elements: { + LIST [14] { + elements: { + CONSTANT [15] { value: 3 } + CONSTANT [16] { value: 4 } + } + } + } + } + COMPREHENSION [17] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [18] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [19] { + elements: { + } + } + } + loop_condition: { + CONSTANT [20] { value: true } + } + loop_step: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @ac:0:0 + } + IDENT [23] { + name: @index2 + } + } + } + } + result: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + CALL [25] { + function: _==_ + args: { + COMPREHENSION [26] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [27] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [28] { + elements: { + } + } + } + loop_condition: { + CONSTANT [29] { value: true } + } + loop_step: { + CALL [30] { + function: _+_ + args: { + IDENT [31] { + name: @ac:1:0 + } + LIST [32] { + elements: { + IDENT [33] { + name: @index3 + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + LIST [35] { + elements: { + IDENT [36] { + name: @index0 + } + IDENT [37] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + CONSTANT [6] { value: 1 } + } + } + CONSTANT [7] { value: 3 } + } + } + LIST [8] { + elements: { + CALL [9] { + function: _?_:_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: _-_ + args: { + IDENT [12] { + name: x + } + CONSTANT [13] { value: 1 } + } + } + CONSTANT [14] { value: 5 } + } + } + } + } + } + } + CALL [15] { + function: _||_ + args: { + COMPREHENSION [16] { + iter_var: @it:0:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [18] { value: false } + } + loop_condition: { + CALL [19] { + function: @not_strictly_false + args: { + CALL [20] { + function: !_ + args: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [22] { + function: _||_ + args: { + IDENT [23] { + name: @ac:0:0 + } + CALL [24] { + function: _>_ + args: { + CALL [25] { + function: _-_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 1 } + } + } + CONSTANT [28] { value: 3 } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:0:0 + } + } + } + IDENT [30] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: "foo" } + CONSTANT [5] { value: "bar" } + } + } + } + } + COMPREHENSION [6] { + iter_var: @it:1:0 + iter_range: { + COMPREHENSION [7] { + iter_var: @it:0:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [9] { + elements: { + } + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @ac:0:0 + } + LIST [13] { + elements: { + LIST [14] { + elements: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @it:0:0 + } + IDENT [17] { + name: @it:0:0 + } + } + } + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it:0:0 + } + IDENT [20] { + name: @it:0:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:1:0 + } + LIST [26] { + elements: { + LIST [27] { + elements: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @it:1:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it:1:0 + } + IDENT [33] { + name: @it:1:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + CALL [5] { + function: _-_ + args: { + IDENT [6] { + name: x + } + IDENT [7] { + name: y + } + } + } + CONSTANT [8] { value: 1 } + } + } + CONSTANT [9] { value: 3 } + } + } + CALL [10] { + function: _?_:_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _-_ + args: { + CALL [13] { + function: _-_ + args: { + IDENT [14] { + name: x + } + IDENT [15] { + name: y + } + } + } + CONSTANT [16] { value: 1 } + } + } + CONSTANT [17] { value: 5 } + } + } + LIST [18] { + elements: { + IDENT [19] { + name: @index1 + } + } + } + } + } + CALL [20] { + function: _||_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [22] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:0:0 + } + CALL [29] { + function: _>_ + args: { + CALL [30] { + function: _-_ + args: { + CALL [31] { + function: _-_ + args: { + IDENT [32] { + name: @it:0:0 + } + IDENT [33] { + name: @it2:0:0 + } + } + } + CONSTANT [34] { value: 1 } + } + } + CONSTANT [35] { value: 3 } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + IDENT [37] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: "foo" } + CONSTANT [5] { value: "bar" } + } + } + } + } + COMPREHENSION [6] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + COMPREHENSION [7] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [9] { + + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: cel.@mapInsert + args: { + IDENT [12] { + name: @ac:0:0 + } + IDENT [13] { + name: @it:0:0 + } + LIST [14] { + elements: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @it:0:0 + } + IDENT [17] { + name: @it:0:0 + } + } + } + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it2:0:0 + } + IDENT [20] { + name: @it2:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [22] { + + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: cel.@mapInsert + args: { + IDENT [25] { + name: @ac:1:0 + } + IDENT [26] { + name: @it:1:0 + } + LIST [27] { + elements: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @it:1:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it2:1:0 + } + IDENT [33] { + name: @it2:1:0 + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + CALL [5] { + function: _?_:_ + args: { + SELECT [6] { + IDENT [7] { + name: @index0 + }.payload~presence_test + } + SELECT [8] { + SELECT [9] { + IDENT [10] { + name: @index0 + }.payload + }.single_int64 + } + CONSTANT [11] { value: 0 } + } + } + } + } + CALL [12] { + function: _==_ + args: { + IDENT [13] { + name: @index1 + } + CONSTANT [14] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + CALL [7] { + function: _?_:_ + args: { + SELECT [8] { + SELECT [9] { + IDENT [10] { + name: msg + }.oneof_type + }.payload~presence_test + } + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + IDENT [16] { + name: @index1 + } + CONSTANT [17] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + SELECT [7] { + SELECT [8] { + SELECT [9] { + IDENT [10] { + name: msg + }.oneof_type + }.payload + }.single_int64~presence_test + } + } + } + CALL [11] { + function: _==_ + args: { + CALL [12] { + function: _?_:_ + args: { + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index0 + } + CALL [15] { + function: _*_ + args: { + IDENT [16] { + name: @index0 + } + CONSTANT [17] { value: 0 } + } + } + } + } + CONSTANT [18] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_string_string + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + CALL [10] { + function: _&&_ + args: { + SELECT [11] { + IDENT [12] { + name: msg + }.oneof_type~presence_test + } + SELECT [13] { + SELECT [14] { + IDENT [15] { + name: msg + }.oneof_type + }.payload~presence_test + } + } + } + CALL [16] { + function: _?_:_ + args: { + CALL [17] { + function: _&&_ + args: { + SELECT [18] { + IDENT [19] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [20] { + IDENT [21] { + name: @index0 + }.key~presence_test + } + } + } + CALL [22] { + function: _==_ + args: { + SELECT [23] { + IDENT [24] { + name: @index0 + }.key + } + CONSTANT [25] { value: "A" } + } + } + CONSTANT [26] { value: false } + } + } + } + } + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _&&_ + args: { + IDENT [29] { + name: @index2 + } + SELECT [30] { + IDENT [31] { + name: @index1 + }.single_int64~presence_test + } + } + } + IDENT [32] { + name: @index3 + } + CONSTANT [33] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CALL [4] { + function: optional.none + args: { + } + } + IDENT [5] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [6] { + elements: { + CONSTANT [7] { value: 5 } + } + } + } + } + CALL [8] { + function: _==_ + args: { + LIST [9] { + elements: { + CONSTANT [10] { value: 10 } + CALL [11] { + function: optional.none + args: { + } + } + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + optional_indices: [0] + } + LIST [14] { + elements: { + CONSTANT [15] { value: 10 } + IDENT [16] { + name: @index1 + } + IDENT [17] { + name: @index1 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "hello" } + } + optional_entry: true + value: { + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "hello" } + } + } + } + } + } + CONSTANT [9] { value: "hello" } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + CALL [7] { + function: _[?_] + args: { + MAP [8] { + MAP_ENTRY [9] { + key: { + CONSTANT [10] { value: "key" } + } + optional_entry: true + value: { + CALL [11] { + function: optional.of + args: { + CONSTANT [12] { value: "test" } + } + } + } + } + } + CONSTANT [13] { value: "bogus" } + } + } + CALL [14] { + function: orValue + target: { + CALL [15] { + function: or + target: { + IDENT [16] { + name: @index1 + } + } + args: { + CALL [17] { + function: _[?_] + args: { + IDENT [18] { + name: @index0 + } + CONSTANT [19] { value: "bogus" } + } + } + } + } + } + args: { + CALL [20] { + function: _[_] + args: { + IDENT [21] { + name: @index0 + } + CONSTANT [22] { value: "key" } + } + } + } + } + } + } + CALL [23] { + function: _==_ + args: { + IDENT [24] { + name: @index2 + } + CONSTANT [25] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int64 + } + } + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CONSTANT [6] { value: "h" } + CONSTANT [7] { value: "e" } + } + } + CONSTANT [8] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "o" } + } + } + } + } + CALL [13] { + function: matches + target: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index1 + } + CONSTANT [16] { value: " world" } + } + } + } + args: { + IDENT [17] { + name: @index1 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CONSTANT [6] { value: "h" } + CONSTANT [7] { value: "e" } + } + } + CONSTANT [8] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + } + } + CALL [10] { + function: matches + target: { + CONSTANT [11] { value: "hello world" } + } + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: "o" } + } + } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CONSTANT [6] { value: "h" } + CONSTANT [7] { value: "e" } + } + } + CONSTANT [8] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + } + } + CALL [10] { + function: matches + target: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: "o" } + } + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + CONSTANT [16] { value: "hello" } + } + } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CONSTANT [6] { value: "h" } + CONSTANT [7] { value: "e" } + } + } + CONSTANT [8] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CONSTANT [13] { value: "w" } + CONSTANT [14] { value: "o" } + } + } + CONSTANT [15] { value: "r" } + } + } + CONSTANT [16] { value: "l" } + } + } + } + } + CALL [17] { + function: matches + target: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @index0 + } + CONSTANT [21] { value: "o" } + } + } + CONSTANT [22] { value: " world" } + } + } + } + args: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @index1 + } + CONSTANT [25] { value: "d" } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: non_pure_custom_func + args: { + IDENT [11] { + name: @index0 + } + } + } + CALL [12] { + function: non_pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + CALL [17] { + function: non_pure_custom_func + args: { + IDENT [18] { + name: @index0 + } + } + } + } + } + CALL [19] { + function: non_pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + CALL [7] { + function: pure_custom_func + args: { + IDENT [8] { + name: @index0 + } + } + } + SELECT [9] { + SELECT [10] { + SELECT [11] { + IDENT [12] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index1 + } + CALL [16] { + function: pure_custom_func + args: { + IDENT [17] { + name: @index2 + } + } + } + } + } + IDENT [18] { + name: @index1 + } + } + } + } + } + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @index3 + } + CALL [21] { + function: pure_custom_func + args: { + SELECT [22] { + IDENT [23] { + name: msg + }.single_int64 + } + } + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_4.baseline b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_4.baseline new file mode 100644 index 000000000..fe139eea1 --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_4.baseline @@ -0,0 +1,4973 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + IDENT [11] { + name: @index0 + } + } + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CONSTANT [11] { value: 2 } + IDENT [12] { + name: @index0 + } + } + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + IDENT [15] { + name: @index0 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + IDENT [17] { + name: @index1 + } + } + } + CONSTANT [18] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CONSTANT [19] { value: 5 } + IDENT [20] { + name: @index0 + } + } + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + IDENT [23] { + name: @index1 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + CALL [25] { + function: _+_ + args: { + CALL [26] { + function: _+_ + args: { + IDENT [27] { + name: @index3 + } + IDENT [28] { + name: @index2 + } + } + } + IDENT [29] { + name: @index2 + } + } + } + CONSTANT [30] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: getFullYear + target: { + CALL [4] { + function: timestamp + args: { + CALL [5] { + function: int + args: { + CALL [6] { + function: timestamp + args: { + CONSTANT [7] { value: 1000000000 } + } + } + } + } + } + } + } + args: { + } + } + CALL [8] { + function: getFullYear + target: { + CALL [9] { + function: timestamp + args: { + CALL [10] { + function: int + args: { + CALL [11] { + function: timestamp + args: { + CONSTANT [12] { value: 200 } + } + } + } + } + } + } + } + args: { + } + } + CALL [13] { + function: timestamp + args: { + CALL [14] { + function: int + args: { + CALL [15] { + function: timestamp + args: { + CONSTANT [16] { value: 50 } + } + } + } + } + } + } + CALL [17] { + function: timestamp + args: { + CALL [18] { + function: int + args: { + CALL [19] { + function: timestamp + args: { + CONSTANT [20] { value: 75 } + } + } + } + } + } + } + CALL [21] { + function: _+_ + args: { + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @index0 + } + CALL [25] { + function: getFullYear + target: { + IDENT [26] { + name: @index3 + } + } + args: { + } + } + } + } + CALL [27] { + function: getFullYear + target: { + IDENT [28] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [29] { + name: @index0 + } + } + } + CALL [30] { + function: _+_ + args: { + CALL [31] { + function: _+_ + args: { + CALL [32] { + function: _+_ + args: { + IDENT [33] { + name: @index4 + } + CALL [34] { + function: getSeconds + target: { + IDENT [35] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [36] { + name: @index1 + } + } + } + IDENT [37] { + name: @index1 + } + } + } + } + } + CALL [38] { + function: _==_ + args: { + CALL [39] { + function: _+_ + args: { + CALL [40] { + function: _+_ + args: { + IDENT [41] { + name: @index5 + } + CALL [42] { + function: getMinutes + target: { + IDENT [43] { + name: @index3 + } + } + args: { + } + } + } + } + IDENT [44] { + name: @index0 + } + } + } + CONSTANT [45] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + } + } + CONSTANT [15] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "e" } + } + value: { + MAP [6] { + MAP_ENTRY [7] { + key: { + CONSTANT [8] { value: "b" } + } + value: { + CONSTANT [9] { value: 1 } + } + } + } + } + } + } + MAP [10] { + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: "b" } + } + value: { + CONSTANT [13] { value: 1 } + } + } + } + } + } + MAP [14] { + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "a" } + } + value: { + IDENT [17] { + name: @index1 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "c" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "d" } + } + value: { + IDENT [23] { + name: @index0 + } + } + } + MAP_ENTRY [24] { + key: { + CONSTANT [25] { value: "e" } + } + value: { + IDENT [26] { + name: @index0 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + SELECT [14] { + IDENT [15] { + name: @index1 + }.single_int32 + } + } + } + IDENT [16] { + name: @index0 + } + } + } + SELECT [17] { + IDENT [18] { + name: msg + }.single_int64 + } + } + } + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @index2 + } + SELECT [21] { + SELECT [22] { + SELECT [23] { + IDENT [24] { + name: @index1 + }.oneof_type + }.payload + }.single_int64 + } + } + } + } + } + CALL [25] { + function: _==_ + args: { + IDENT [26] { + name: @index3 + } + CONSTANT [27] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + } + SELECT [8] { + IDENT [9] { + name: @index0 + }.oneof_type + } + SELECT [10] { + SELECT [11] { + SELECT [12] { + SELECT [13] { + IDENT [14] { + name: @index1 + }.payload + }.oneof_type + }.payload + }.single_bool + } + SELECT [15] { + SELECT [16] { + SELECT [17] { + SELECT [18] { + IDENT [19] { + name: @index1 + }.child + }.child + }.payload + }.single_bool + } + } + } + CALL [20] { + function: _||_ + args: { + CALL [21] { + function: _||_ + args: { + CONSTANT [22] { value: true } + IDENT [23] { + name: @index2 + } + } + } + IDENT [24] { + name: @index3 + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CONSTANT [8] { value: 1 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + IDENT [14] { + name: @index0 + } + } + } + CONSTANT [15] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: 0 } + } + } + CALL [13] { + function: _[_] + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + CALL [16] { + function: _[_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 2 } + } + } + } + } + CONSTANT [19] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + } + SELECT [8] { + SELECT [9] { + SELECT [10] { + SELECT [11] { + IDENT [12] { + name: @index0 + }.oneof_type + }.payload + }.oneof_type + }.payload + } + } + } + SELECT [13] { + IDENT [14] { + name: @index1 + }.single_int64 + } + } +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CONSTANT [12] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + CALL [8] { + function: _*_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 1 } + } + } + CONSTANT [12] { value: 2 } + } + } + } + } + CONSTANT [13] { value: 11 } + } + } + } + } + CALL [14] { + function: _?_:_ + args: { + CONSTANT [15] { value: false } + CONSTANT [16] { value: false } + IDENT [17] { + name: @index1 + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _?_:_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index0 + } + IDENT [18] { + name: @index1 + } + } + } + CONSTANT [19] { value: 0 } + } + } + CONSTANT [20] { value: 0 } + } + } + CONSTANT [21] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:0 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + IDENT [31] { + name: @index0 + } + } + } + } + } + CALL [32] { + function: size + args: { + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + } + } + } + } + } + } + CALL [35] { + function: _==_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index2 + } + IDENT [40] { + name: @index2 + } + } + } + IDENT [41] { + name: @index3 + } + } + } + IDENT [42] { + name: @index3 + } + } + } + CONSTANT [43] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:1 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: "a" } + } + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:1 + } + CALL [25] { + function: _==_ + args: { + IDENT [26] { + name: @it:0:1 + } + CONSTANT [27] { value: "a" } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:1 + } + } + } + LIST [29] { + elements: { + IDENT [30] { + name: @index0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + } + } + } + } + CALL [33] { + function: _==_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + IDENT [37] { + name: @index2 + } + IDENT [38] { + name: @index2 + } + } + } + IDENT [39] { + name: @index3 + } + } + } + IDENT [40] { + name: @index3 + } + } + } + LIST [41] { + elements: { + CONSTANT [42] { value: true } + CONSTANT [43] { value: true } + CONSTANT [44] { value: true } + CONSTANT [45] { value: true } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @index0 + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _&&_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + LIST [22] { + elements: { + CONSTANT [23] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [24] { value: false } + } + loop_condition: { + CALL [25] { + function: @not_strictly_false + args: { + CALL [26] { + function: !_ + args: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [28] { + function: _||_ + args: { + IDENT [29] { + name: @ac:0:0 + } + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [37] { value: false } + } + loop_condition: { + CALL [38] { + function: @not_strictly_false + args: { + CALL [39] { + function: !_ + args: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [41] { + function: _||_ + args: { + IDENT [42] { + name: @ac:0:0 + } + CALL [43] { + function: _>_ + args: { + IDENT [44] { + name: @it:0:0 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>=_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [21] { + elements: { + CONSTANT [22] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:0:0 + } + CALL [29] { + function: _&&_ + args: { + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + CALL [33] { + function: _>=_ + args: { + IDENT [34] { + name: @it2:0:0 + } + CONSTANT [35] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + CALL [37] { + function: size + args: { + LIST [38] { + elements: { + IDENT [39] { + name: @index0 + } + } + } + } + } + CALL [40] { + function: size + args: { + LIST [41] { + elements: { + IDENT [42] { + name: @index1 + } + } + } + } + } + } + } + CALL [43] { + function: _==_ + args: { + CALL [44] { + function: _+_ + args: { + CALL [45] { + function: _+_ + args: { + CALL [46] { + function: _+_ + args: { + IDENT [47] { + name: @index2 + } + IDENT [48] { + name: @index2 + } + } + } + IDENT [49] { + name: @index3 + } + } + } + IDENT [50] { + name: @index3 + } + } + } + CONSTANT [51] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + CALL [20] { + function: _&&_ + args: { + CALL [21] { + function: _&&_ + args: { + IDENT [22] { + name: @index0 + } + IDENT [23] { + name: @index0 + } + } + } + CALL [24] { + function: _&&_ + args: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [26] { + elements: { + CONSTANT [27] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [28] { value: false } + } + loop_condition: { + CALL [29] { + function: @not_strictly_false + args: { + CALL [30] { + function: !_ + args: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [32] { + function: _||_ + args: { + IDENT [33] { + name: @ac:0:0 + } + CALL [34] { + function: _&&_ + args: { + CALL [35] { + function: _>_ + args: { + IDENT [36] { + name: @it:0:0 + } + CONSTANT [37] { value: 1 } + } + } + CALL [38] { + function: _>_ + args: { + IDENT [39] { + name: @it2:0:0 + } + CONSTANT [40] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:0:0 + } + } + } + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [43] { + elements: { + CONSTANT [44] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [45] { value: false } + } + loop_condition: { + CALL [46] { + function: @not_strictly_false + args: { + CALL [47] { + function: !_ + args: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [49] { + function: _||_ + args: { + IDENT [50] { + name: @ac:0:0 + } + CALL [51] { + function: _&&_ + args: { + CALL [52] { + function: _>_ + args: { + IDENT [53] { + name: @it:0:0 + } + CONSTANT [54] { value: 1 } + } + } + CALL [55] { + function: _>_ + args: { + IDENT [56] { + name: @it2:0:0 + } + CONSTANT [57] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [58] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_range: { + IDENT [12] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @ac:0:0 + } + LIST [17] { + elements: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it:0:0 + } + CONSTANT [20] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + } + CALL [22] { + function: _==_ + args: { + COMPREHENSION [23] { + iter_var: @it:1:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:1:0 + } + LIST [29] { + elements: { + IDENT [30] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:1:0 + } + } + } + LIST [32] { + elements: { + IDENT [33] { + name: @index1 + } + IDENT [34] { + name: @index1 + } + IDENT [35] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @it:0:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @ac:0:0 + } + LIST [33] { + elements: { + IDENT [34] { + name: @it:0:0 + } + } + } + } + } + IDENT [35] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [37] { + name: @ac:1:0 + } + } + } + IDENT [38] { + name: @index0 + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + } + } + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @index0 + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:1:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _*_ + args: { + IDENT [27] { + name: @it:1:0 + } + CONSTANT [28] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + LIST [11] { + elements: { + IDENT [12] { + name: @index1 + } + IDENT [13] { + name: @index1 + } + IDENT [14] { + name: @index1 + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [17] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:0:0 + } + LIST [29] { + elements: { + CALL [30] { + function: _+_ + args: { + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it:0:0 + } + IDENT [33] { + name: @it2:0:0 + } + } + } + CONSTANT [34] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [35] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:1:0 + } + } + } + IDENT [37] { + name: @index2 + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _&&_ + args: { + CALL [29] { + function: _==_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:1:0 + } + } + } + CALL [32] { + function: _<_ + args: { + IDENT [33] { + name: @it:1:0 + } + IDENT [34] { + name: @it2:1:0 + } + } + } + } + } + CALL [35] { + function: _+_ + args: { + IDENT [36] { + name: @ac:0:0 + } + LIST [37] { + elements: { + IDENT [38] { + name: @it:0:0 + } + } + } + } + } + IDENT [39] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:1:0 + } + } + } + IDENT [42] { + name: @index0 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + COMPREHENSION [17] { + iter_var: @it:1:0 + iter_range: { + LIST [18] { + elements: { + CONSTANT [19] { value: 1 } + CONSTANT [20] { value: 2 } + CONSTANT [21] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:1:0 + } + LIST [26] { + elements: { + IDENT [27] { + name: @index0 + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:1:0 + } + } + } + } + } + CALL [29] { + function: _==_ + args: { + IDENT [30] { + name: @index1 + } + IDENT [31] { + name: @index1 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [8] { + + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: cel.@mapInsert + args: { + IDENT [11] { + name: @ac:0:0 + } + IDENT [12] { + name: @it:0:0 + } + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @it:0:0 + } + IDENT [16] { + name: @it2:0:0 + } + } + } + CONSTANT [17] { value: 1 } + } + } + } + } + } + result: { + IDENT [18] { + name: @ac:0:0 + } + } + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + LIST [20] { + elements: { + CONSTANT [21] { value: 1 } + CONSTANT [22] { value: 2 } + CONSTANT [23] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [24] { + + } + } + loop_condition: { + CONSTANT [25] { value: true } + } + loop_step: { + CALL [26] { + function: cel.@mapInsert + args: { + IDENT [27] { + name: @ac:1:0 + } + IDENT [28] { + name: @it:1:0 + } + IDENT [29] { + name: @index0 + } + } + } + } + result: { + IDENT [30] { + name: @ac:1:0 + } + } + } + } + } + CALL [31] { + function: _==_ + args: { + IDENT [32] { + name: @index1 + } + IDENT [33] { + name: @index1 + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: @in + args: { + CONSTANT [4] { value: 1 } + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + CONSTANT [8] { value: 3 } + } + } + } + } + LIST [9] { + elements: { + CONSTANT [10] { value: 1 } + CONSTANT [11] { value: 2 } + CONSTANT [12] { value: 3 } + } + } + } + } + CALL [13] { + function: _&&_ + args: { + CALL [14] { + function: _&&_ + args: { + IDENT [15] { + name: @index0 + } + CALL [16] { + function: @in + args: { + CONSTANT [17] { value: 2 } + IDENT [18] { + name: @index1 + } + } + } + } + } + CALL [19] { + function: _&&_ + args: { + CALL [20] { + function: @in + args: { + CONSTANT [21] { value: 3 } + LIST [22] { + elements: { + CONSTANT [23] { value: 3 } + IDENT [24] { + name: @index1 + } + } + } + } + } + IDENT [25] { + name: @index0 + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_range: { + IDENT [14] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @ac:0:0 + } + LIST [19] { + elements: { + LIST [20] { + elements: { + CONSTANT [21] { value: 3 } + CONSTANT [22] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [23] { + name: @ac:0:0 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + COMPREHENSION [25] { + iter_var: @it:1:0 + iter_range: { + IDENT [26] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:1:0 + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + LIST [34] { + elements: { + IDENT [35] { + name: @index0 + } + IDENT [36] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [14] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @ac:0:0 + } + LIST [19] { + elements: { + LIST [20] { + elements: { + CONSTANT [21] { value: 3 } + CONSTANT [22] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [23] { + name: @ac:0:0 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + COMPREHENSION [25] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [26] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:1:0 + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + LIST [34] { + elements: { + IDENT [35] { + name: @index0 + } + IDENT [36] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + CONSTANT [6] { value: 1 } + } + } + CONSTANT [7] { value: 3 } + } + } + } + } + CALL [8] { + function: _||_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_range: { + LIST [10] { + elements: { + CALL [11] { + function: _?_:_ + args: { + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _-_ + args: { + IDENT [14] { + name: x + } + CONSTANT [15] { value: 1 } + } + } + CONSTANT [16] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [17] { value: false } + } + loop_condition: { + CALL [18] { + function: @not_strictly_false + args: { + CALL [19] { + function: !_ + args: { + IDENT [20] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [21] { + function: _||_ + args: { + IDENT [22] { + name: @ac:0:0 + } + CALL [23] { + function: _>_ + args: { + CALL [24] { + function: _-_ + args: { + IDENT [25] { + name: @it:0:0 + } + CONSTANT [26] { value: 1 } + } + } + CONSTANT [27] { value: 3 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + IDENT [29] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: "foo" } + CONSTANT [5] { value: "bar" } + } + } + } + } + COMPREHENSION [6] { + iter_var: @it:1:0 + iter_range: { + COMPREHENSION [7] { + iter_var: @it:0:0 + iter_range: { + IDENT [8] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [9] { + elements: { + } + } + } + loop_condition: { + CONSTANT [10] { value: true } + } + loop_step: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @ac:0:0 + } + LIST [13] { + elements: { + LIST [14] { + elements: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @it:0:0 + } + IDENT [17] { + name: @it:0:0 + } + } + } + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it:0:0 + } + IDENT [20] { + name: @it:0:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:1:0 + } + LIST [26] { + elements: { + LIST [27] { + elements: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @it:1:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it:1:0 + } + IDENT [33] { + name: @it:1:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + CALL [5] { + function: _-_ + args: { + IDENT [6] { + name: x + } + IDENT [7] { + name: y + } + } + } + CONSTANT [8] { value: 1 } + } + } + CONSTANT [9] { value: 3 } + } + } + LIST [10] { + elements: { + CALL [11] { + function: _?_:_ + args: { + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _-_ + args: { + CALL [14] { + function: _-_ + args: { + IDENT [15] { + name: x + } + IDENT [16] { + name: y + } + } + } + CONSTANT [17] { value: 1 } + } + } + CONSTANT [18] { value: 5 } + } + } + } + } + } + } + CALL [19] { + function: _||_ + args: { + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [21] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [22] { value: false } + } + loop_condition: { + CALL [23] { + function: @not_strictly_false + args: { + CALL [24] { + function: !_ + args: { + IDENT [25] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [26] { + function: _||_ + args: { + IDENT [27] { + name: @ac:0:0 + } + CALL [28] { + function: _>_ + args: { + CALL [29] { + function: _-_ + args: { + CALL [30] { + function: _-_ + args: { + IDENT [31] { + name: @it:0:0 + } + IDENT [32] { + name: @it2:0:0 + } + } + } + CONSTANT [33] { value: 1 } + } + } + CONSTANT [34] { value: 3 } + } + } + } + } + } + result: { + IDENT [35] { + name: @ac:0:0 + } + } + } + IDENT [36] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: "foo" } + CONSTANT [6] { value: "bar" } + } + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [7] { + + } + } + loop_condition: { + CONSTANT [8] { value: true } + } + loop_step: { + CALL [9] { + function: cel.@mapInsert + args: { + IDENT [10] { + name: @ac:0:0 + } + IDENT [11] { + name: @it:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @it:0:0 + } + IDENT [15] { + name: @it:0:0 + } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @it2:0:0 + } + IDENT [18] { + name: @it2:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + COMPREHENSION [20] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [21] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [22] { + + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: cel.@mapInsert + args: { + IDENT [25] { + name: @ac:1:0 + } + IDENT [26] { + name: @it:1:0 + } + LIST [27] { + elements: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @it:1:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it2:1:0 + } + IDENT [33] { + name: @it2:1:0 + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.payload~presence_test + } + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload + }.single_int64 + } + CONSTANT [12] { value: 0 } + } + } + CONSTANT [13] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: msg + }.oneof_type + }.payload~presence_test + } + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + CALL [7] { + function: _?_:_ + args: { + SELECT [8] { + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: msg + }.oneof_type + }.payload + }.single_int64~presence_test + } + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 0 } + } + } + } + } + } + } + CALL [16] { + function: _==_ + args: { + IDENT [17] { + name: @index1 + } + CONSTANT [18] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_string_string + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + CALL [10] { + function: _&&_ + args: { + CALL [11] { + function: _&&_ + args: { + SELECT [12] { + IDENT [13] { + name: msg + }.oneof_type~presence_test + } + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload~presence_test + } + } + } + SELECT [17] { + IDENT [18] { + name: @index1 + }.single_int64~presence_test + } + } + } + } + } + CALL [19] { + function: _?_:_ + args: { + IDENT [20] { + name: @index2 + } + CALL [21] { + function: _?_:_ + args: { + CALL [22] { + function: _&&_ + args: { + SELECT [23] { + IDENT [24] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [25] { + IDENT [26] { + name: @index0 + }.key~presence_test + } + } + } + CALL [27] { + function: _==_ + args: { + SELECT [28] { + IDENT [29] { + name: @index0 + }.key + } + CONSTANT [30] { value: "A" } + } + } + CONSTANT [31] { value: false } + } + } + CONSTANT [32] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CALL [4] { + function: optional.none + args: { + } + } + IDENT [5] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [6] { + elements: { + CONSTANT [7] { value: 5 } + } + } + } + } + CALL [8] { + function: _==_ + args: { + LIST [9] { + elements: { + CONSTANT [10] { value: 10 } + CALL [11] { + function: optional.none + args: { + } + } + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + optional_indices: [0] + } + LIST [14] { + elements: { + CONSTANT [15] { value: 10 } + IDENT [16] { + name: @index1 + } + IDENT [17] { + name: @index1 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "hello" } + } + optional_entry: true + value: { + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "hello" } + } + } + } + } + } + CONSTANT [9] { value: "hello" } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + CALL [7] { + function: or + target: { + CALL [8] { + function: _[?_] + args: { + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "key" } + } + optional_entry: true + value: { + CALL [12] { + function: optional.of + args: { + CONSTANT [13] { value: "test" } + } + } + } + } + } + CONSTANT [14] { value: "bogus" } + } + } + } + args: { + CALL [15] { + function: _[?_] + args: { + IDENT [16] { + name: @index0 + } + CONSTANT [17] { value: "bogus" } + } + } + } + } + } + } + CALL [18] { + function: _==_ + args: { + CALL [19] { + function: orValue + target: { + IDENT [20] { + name: @index1 + } + } + args: { + CALL [21] { + function: _[_] + args: { + IDENT [22] { + name: @index0 + } + CONSTANT [23] { value: "key" } + } + } + } + } + CONSTANT [24] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int64 + } + } + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + IDENT [16] { + name: @index0 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CONSTANT [13] { value: "hello world" } + } + args: { + IDENT [14] { + name: @index0 + } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + CONSTANT [16] { value: "hello" } + } + } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CALL [15] { + function: _+_ + args: { + CONSTANT [16] { value: "w" } + CONSTANT [17] { value: "o" } + } + } + CONSTANT [18] { value: "r" } + } + } + CONSTANT [19] { value: "l" } + } + } + CONSTANT [20] { value: "d" } + } + } + } + } + CALL [21] { + function: matches + target: { + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @index0 + } + CONSTANT [24] { value: " world" } + } + } + } + args: { + IDENT [25] { + name: @index1 + } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: non_pure_custom_func + args: { + IDENT [11] { + name: @index0 + } + } + } + CALL [12] { + function: non_pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + CALL [17] { + function: non_pure_custom_func + args: { + IDENT [18] { + name: @index0 + } + } + } + } + } + CALL [19] { + function: non_pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: pure_custom_func + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [8] { + function: pure_custom_func + args: { + SELECT [9] { + SELECT [10] { + SELECT [11] { + IDENT [12] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @index0 + } + IDENT [17] { + name: @index1 + } + } + } + IDENT [18] { + name: @index0 + } + } + } + CALL [19] { + function: pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_5.baseline b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_5.baseline new file mode 100644 index 000000000..c7ab9e404 --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_5.baseline @@ -0,0 +1,4919 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + IDENT [11] { + name: @index0 + } + } + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CONSTANT [11] { value: 2 } + IDENT [12] { + name: @index0 + } + } + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + IDENT [15] { + name: @index0 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + IDENT [17] { + name: @index1 + } + } + } + CONSTANT [18] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + CONSTANT [20] { value: 5 } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index0 + } + } + } + IDENT [23] { + name: @index1 + } + } + } + IDENT [24] { + name: @index1 + } + } + } + IDENT [25] { + name: @index2 + } + } + } + } + } + CALL [26] { + function: _==_ + args: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @index3 + } + IDENT [29] { + name: @index2 + } + } + } + CONSTANT [30] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: getFullYear + target: { + CALL [4] { + function: timestamp + args: { + CALL [5] { + function: int + args: { + CALL [6] { + function: timestamp + args: { + CONSTANT [7] { value: 1000000000 } + } + } + } + } + } + } + } + args: { + } + } + CALL [8] { + function: getFullYear + target: { + CALL [9] { + function: timestamp + args: { + CALL [10] { + function: int + args: { + CALL [11] { + function: timestamp + args: { + CONSTANT [12] { value: 200 } + } + } + } + } + } + } + } + args: { + } + } + CALL [13] { + function: timestamp + args: { + CALL [14] { + function: int + args: { + CALL [15] { + function: timestamp + args: { + CONSTANT [16] { value: 50 } + } + } + } + } + } + } + CALL [17] { + function: timestamp + args: { + CALL [18] { + function: int + args: { + CALL [19] { + function: timestamp + args: { + CONSTANT [20] { value: 75 } + } + } + } + } + } + } + CALL [21] { + function: _+_ + args: { + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @index0 + } + CALL [26] { + function: getFullYear + target: { + IDENT [27] { + name: @index3 + } + } + args: { + } + } + } + } + CALL [28] { + function: getFullYear + target: { + IDENT [29] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [30] { + name: @index0 + } + } + } + CALL [31] { + function: getSeconds + target: { + IDENT [32] { + name: @index2 + } + } + args: { + } + } + } + } + } + } + CALL [33] { + function: _==_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + IDENT [38] { + name: @index4 + } + IDENT [39] { + name: @index1 + } + } + } + IDENT [40] { + name: @index1 + } + } + } + CALL [41] { + function: getMinutes + target: { + IDENT [42] { + name: @index3 + } + } + args: { + } + } + } + } + IDENT [43] { + name: @index0 + } + } + } + CONSTANT [44] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + } + } + CONSTANT [15] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "e" } + } + value: { + MAP [6] { + MAP_ENTRY [7] { + key: { + CONSTANT [8] { value: "b" } + } + value: { + CONSTANT [9] { value: 1 } + } + } + } + } + } + } + MAP [10] { + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: "b" } + } + value: { + CONSTANT [13] { value: 1 } + } + } + } + } + } + MAP [14] { + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "a" } + } + value: { + IDENT [17] { + name: @index1 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "c" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "d" } + } + value: { + IDENT [23] { + name: @index0 + } + } + } + MAP_ENTRY [24] { + key: { + CONSTANT [25] { value: "e" } + } + value: { + IDENT [26] { + name: @index0 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + SELECT [15] { + IDENT [16] { + name: @index1 + }.single_int32 + } + } + } + IDENT [17] { + name: @index0 + } + } + } + SELECT [18] { + IDENT [19] { + name: msg + }.single_int64 + } + } + } + SELECT [20] { + SELECT [21] { + SELECT [22] { + IDENT [23] { + name: @index1 + }.oneof_type + }.payload + }.single_int64 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + IDENT [25] { + name: @index2 + } + CONSTANT [26] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + CALL [9] { + function: _||_ + args: { + CONSTANT [10] { value: true } + SELECT [11] { + SELECT [12] { + SELECT [13] { + SELECT [14] { + IDENT [15] { + name: @index0 + }.payload + }.oneof_type + }.payload + }.single_bool + } + } + } + } + } + CALL [16] { + function: _||_ + args: { + IDENT [17] { + name: @index1 + } + SELECT [18] { + SELECT [19] { + SELECT [20] { + SELECT [21] { + IDENT [22] { + name: @index0 + }.child + }.child + }.payload + }.single_bool + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CONSTANT [8] { value: 1 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + IDENT [14] { + name: @index0 + } + } + } + CONSTANT [15] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: 0 } + } + } + CALL [13] { + function: _[_] + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + CALL [16] { + function: _[_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 2 } + } + } + } + } + CONSTANT [19] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + } + } + SELECT [9] { + SELECT [10] { + SELECT [11] { + SELECT [12] { + IDENT [13] { + name: @index0 + }.payload + }.oneof_type + }.payload + }.single_int64 + } + } +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CONSTANT [12] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _?_:_ + args: { + CONSTANT [6] { value: false } + CONSTANT [7] { value: false } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: _*_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 2 } + } + } + } + } + CONSTANT [16] { value: 11 } + } + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _?_:_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index0 + } + IDENT [18] { + name: @index1 + } + } + } + CONSTANT [19] { value: 0 } + } + } + CONSTANT [20] { value: 0 } + } + } + CONSTANT [21] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:0 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + IDENT [31] { + name: @index0 + } + } + } + } + } + CALL [32] { + function: size + args: { + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + } + } + } + } + } + } + CALL [35] { + function: _==_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index2 + } + IDENT [40] { + name: @index2 + } + } + } + IDENT [41] { + name: @index3 + } + } + } + IDENT [42] { + name: @index3 + } + } + } + CONSTANT [43] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:1 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: "a" } + } + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:1 + } + CALL [25] { + function: _==_ + args: { + IDENT [26] { + name: @it:0:1 + } + CONSTANT [27] { value: "a" } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:1 + } + } + } + LIST [29] { + elements: { + IDENT [30] { + name: @index0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + } + } + } + } + CALL [33] { + function: _==_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + IDENT [37] { + name: @index2 + } + IDENT [38] { + name: @index2 + } + } + } + IDENT [39] { + name: @index3 + } + } + } + IDENT [40] { + name: @index3 + } + } + } + LIST [41] { + elements: { + CONSTANT [42] { value: true } + CONSTANT [43] { value: true } + CONSTANT [44] { value: true } + CONSTANT [45] { value: true } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @index0 + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _&&_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + LIST [22] { + elements: { + CONSTANT [23] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [24] { value: false } + } + loop_condition: { + CALL [25] { + function: @not_strictly_false + args: { + CALL [26] { + function: !_ + args: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [28] { + function: _||_ + args: { + IDENT [29] { + name: @ac:0:0 + } + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [37] { value: false } + } + loop_condition: { + CALL [38] { + function: @not_strictly_false + args: { + CALL [39] { + function: !_ + args: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [41] { + function: _||_ + args: { + IDENT [42] { + name: @ac:0:0 + } + CALL [43] { + function: _>_ + args: { + IDENT [44] { + name: @it:0:0 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>=_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [21] { + elements: { + CONSTANT [22] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:0:0 + } + CALL [29] { + function: _&&_ + args: { + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + CALL [33] { + function: _>=_ + args: { + IDENT [34] { + name: @it2:0:0 + } + CONSTANT [35] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + CALL [37] { + function: size + args: { + LIST [38] { + elements: { + IDENT [39] { + name: @index0 + } + } + } + } + } + CALL [40] { + function: size + args: { + LIST [41] { + elements: { + IDENT [42] { + name: @index1 + } + } + } + } + } + } + } + CALL [43] { + function: _==_ + args: { + CALL [44] { + function: _+_ + args: { + CALL [45] { + function: _+_ + args: { + CALL [46] { + function: _+_ + args: { + IDENT [47] { + name: @index2 + } + IDENT [48] { + name: @index2 + } + } + } + IDENT [49] { + name: @index3 + } + } + } + IDENT [50] { + name: @index3 + } + } + } + CONSTANT [51] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + CALL [20] { + function: _&&_ + args: { + CALL [21] { + function: _&&_ + args: { + IDENT [22] { + name: @index0 + } + IDENT [23] { + name: @index0 + } + } + } + CALL [24] { + function: _&&_ + args: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [26] { + elements: { + CONSTANT [27] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [28] { value: false } + } + loop_condition: { + CALL [29] { + function: @not_strictly_false + args: { + CALL [30] { + function: !_ + args: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [32] { + function: _||_ + args: { + IDENT [33] { + name: @ac:0:0 + } + CALL [34] { + function: _&&_ + args: { + CALL [35] { + function: _>_ + args: { + IDENT [36] { + name: @it:0:0 + } + CONSTANT [37] { value: 1 } + } + } + CALL [38] { + function: _>_ + args: { + IDENT [39] { + name: @it2:0:0 + } + CONSTANT [40] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:0:0 + } + } + } + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [43] { + elements: { + CONSTANT [44] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [45] { value: false } + } + loop_condition: { + CALL [46] { + function: @not_strictly_false + args: { + CALL [47] { + function: !_ + args: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [49] { + function: _||_ + args: { + IDENT [50] { + name: @ac:0:0 + } + CALL [51] { + function: _&&_ + args: { + CALL [52] { + function: _>_ + args: { + IDENT [53] { + name: @it:0:0 + } + CONSTANT [54] { value: 1 } + } + } + CALL [55] { + function: _>_ + args: { + IDENT [56] { + name: @it2:0:0 + } + CONSTANT [57] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [58] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_range: { + IDENT [12] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @ac:0:0 + } + LIST [17] { + elements: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it:0:0 + } + CONSTANT [20] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + } + CALL [22] { + function: _==_ + args: { + COMPREHENSION [23] { + iter_var: @it:1:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:1:0 + } + LIST [29] { + elements: { + IDENT [30] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:1:0 + } + } + } + LIST [32] { + elements: { + IDENT [33] { + name: @index1 + } + IDENT [34] { + name: @index1 + } + IDENT [35] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @it:0:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @ac:0:0 + } + LIST [33] { + elements: { + IDENT [34] { + name: @it:0:0 + } + } + } + } + } + IDENT [35] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [37] { + name: @ac:1:0 + } + } + } + IDENT [38] { + name: @index0 + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + } + } + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @index0 + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:1:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _*_ + args: { + IDENT [27] { + name: @it:1:0 + } + CONSTANT [28] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [12] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @ac:0:0 + } + LIST [17] { + elements: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @it:0:0 + } + IDENT [21] { + name: @it2:0:0 + } + } + } + CONSTANT [22] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [23] { + name: @ac:0:0 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + COMPREHENSION [25] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [26] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:1:0 + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + LIST [34] { + elements: { + IDENT [35] { + name: @index1 + } + IDENT [36] { + name: @index1 + } + IDENT [37] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _&&_ + args: { + CALL [29] { + function: _==_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:1:0 + } + } + } + CALL [32] { + function: _<_ + args: { + IDENT [33] { + name: @it:1:0 + } + IDENT [34] { + name: @it2:1:0 + } + } + } + } + } + CALL [35] { + function: _+_ + args: { + IDENT [36] { + name: @ac:0:0 + } + LIST [37] { + elements: { + IDENT [38] { + name: @it:0:0 + } + } + } + } + } + IDENT [39] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:1:0 + } + } + } + IDENT [42] { + name: @index0 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + COMPREHENSION [17] { + iter_var: @it:1:0 + iter_range: { + LIST [18] { + elements: { + CONSTANT [19] { value: 1 } + CONSTANT [20] { value: 2 } + CONSTANT [21] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:1:0 + } + LIST [26] { + elements: { + IDENT [27] { + name: @index0 + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:1:0 + } + } + } + } + } + CALL [29] { + function: _==_ + args: { + IDENT [30] { + name: @index1 + } + IDENT [31] { + name: @index1 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [8] { + + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: cel.@mapInsert + args: { + IDENT [11] { + name: @ac:0:0 + } + IDENT [12] { + name: @it:0:0 + } + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @it:0:0 + } + IDENT [16] { + name: @it2:0:0 + } + } + } + CONSTANT [17] { value: 1 } + } + } + } + } + } + result: { + IDENT [18] { + name: @ac:0:0 + } + } + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + LIST [20] { + elements: { + CONSTANT [21] { value: 1 } + CONSTANT [22] { value: 2 } + CONSTANT [23] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [24] { + + } + } + loop_condition: { + CONSTANT [25] { value: true } + } + loop_step: { + CALL [26] { + function: cel.@mapInsert + args: { + IDENT [27] { + name: @ac:1:0 + } + IDENT [28] { + name: @it:1:0 + } + IDENT [29] { + name: @index0 + } + } + } + } + result: { + IDENT [30] { + name: @ac:1:0 + } + } + } + } + } + CALL [31] { + function: _==_ + args: { + IDENT [32] { + name: @index1 + } + IDENT [33] { + name: @index1 + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: @in + args: { + CONSTANT [4] { value: 1 } + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + CONSTANT [8] { value: 3 } + } + } + } + } + LIST [9] { + elements: { + CONSTANT [10] { value: 1 } + CONSTANT [11] { value: 2 } + CONSTANT [12] { value: 3 } + } + } + } + } + CALL [13] { + function: _&&_ + args: { + CALL [14] { + function: _&&_ + args: { + IDENT [15] { + name: @index0 + } + CALL [16] { + function: @in + args: { + CONSTANT [17] { value: 2 } + IDENT [18] { + name: @index1 + } + } + } + } + } + CALL [19] { + function: _&&_ + args: { + CALL [20] { + function: @in + args: { + CONSTANT [21] { value: 3 } + LIST [22] { + elements: { + CONSTANT [23] { value: 3 } + IDENT [24] { + name: @index1 + } + } + } + } + } + IDENT [25] { + name: @index0 + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_range: { + IDENT [14] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @ac:0:0 + } + LIST [19] { + elements: { + LIST [20] { + elements: { + CONSTANT [21] { value: 3 } + CONSTANT [22] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [23] { + name: @ac:0:0 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + COMPREHENSION [25] { + iter_var: @it:1:0 + iter_range: { + IDENT [26] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:1:0 + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + LIST [34] { + elements: { + IDENT [35] { + name: @index0 + } + IDENT [36] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [14] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @ac:0:0 + } + LIST [19] { + elements: { + LIST [20] { + elements: { + CONSTANT [21] { value: 3 } + CONSTANT [22] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [23] { + name: @ac:0:0 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + COMPREHENSION [25] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [26] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:1:0 + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + LIST [34] { + elements: { + IDENT [35] { + name: @index0 + } + IDENT [36] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + CONSTANT [6] { value: 1 } + } + } + CONSTANT [7] { value: 3 } + } + } + } + } + CALL [8] { + function: _||_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_range: { + LIST [10] { + elements: { + CALL [11] { + function: _?_:_ + args: { + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _-_ + args: { + IDENT [14] { + name: x + } + CONSTANT [15] { value: 1 } + } + } + CONSTANT [16] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [17] { value: false } + } + loop_condition: { + CALL [18] { + function: @not_strictly_false + args: { + CALL [19] { + function: !_ + args: { + IDENT [20] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [21] { + function: _||_ + args: { + IDENT [22] { + name: @ac:0:0 + } + CALL [23] { + function: _>_ + args: { + CALL [24] { + function: _-_ + args: { + IDENT [25] { + name: @it:0:0 + } + CONSTANT [26] { value: 1 } + } + } + CONSTANT [27] { value: 3 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + IDENT [29] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: "foo" } + CONSTANT [6] { value: "bar" } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [7] { + elements: { + } + } + } + loop_condition: { + CONSTANT [8] { value: true } + } + loop_step: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @ac:0:0 + } + LIST [11] { + elements: { + LIST [12] { + elements: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @it:0:0 + } + IDENT [15] { + name: @it:0:0 + } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @it:0:0 + } + IDENT [18] { + name: @it:0:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + COMPREHENSION [20] { + iter_var: @it:1:0 + iter_range: { + IDENT [21] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:1:0 + } + LIST [26] { + elements: { + LIST [27] { + elements: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @it:1:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @it:1:0 + } + IDENT [33] { + name: @it:1:0 + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:1:0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + CALL [5] { + function: _-_ + args: { + IDENT [6] { + name: x + } + IDENT [7] { + name: y + } + } + } + CONSTANT [8] { value: 1 } + } + } + CONSTANT [9] { value: 3 } + } + } + } + } + CALL [10] { + function: _||_ + args: { + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [12] { + elements: { + CALL [13] { + function: _?_:_ + args: { + IDENT [14] { + name: @index0 + } + CALL [15] { + function: _-_ + args: { + CALL [16] { + function: _-_ + args: { + IDENT [17] { + name: x + } + IDENT [18] { + name: y + } + } + } + CONSTANT [19] { value: 1 } + } + } + CONSTANT [20] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [21] { value: false } + } + loop_condition: { + CALL [22] { + function: @not_strictly_false + args: { + CALL [23] { + function: !_ + args: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [25] { + function: _||_ + args: { + IDENT [26] { + name: @ac:0:0 + } + CALL [27] { + function: _>_ + args: { + CALL [28] { + function: _-_ + args: { + CALL [29] { + function: _-_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:0:0 + } + } + } + CONSTANT [32] { value: 1 } + } + } + CONSTANT [33] { value: 3 } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:0:0 + } + } + } + IDENT [35] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_var2: y + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + MAP [14] { + + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [17] { + function: cel.@mapInsert + args: { + IDENT [16] { + name: @result + } + IDENT [5] { + name: x + } + LIST [7] { + elements: { + CALL [9] { + function: _+_ + args: { + IDENT [8] { + name: x + } + IDENT [10] { + name: x + } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [11] { + name: y + } + IDENT [13] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + MAP [30] { + + } + } + loop_condition: { + CONSTANT [31] { value: true } + } + loop_step: { + CALL [33] { + function: cel.@mapInsert + args: { + IDENT [32] { + name: @result + } + IDENT [21] { + name: x + } + LIST [23] { + elements: { + CALL [25] { + function: _+_ + args: { + IDENT [24] { + name: x + } + IDENT [26] { + name: x + } + } + } + CALL [28] { + function: _+_ + args: { + IDENT [27] { + name: y + } + IDENT [29] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.payload~presence_test + } + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload + }.single_int64 + } + CONSTANT [12] { value: 0 } + } + } + CONSTANT [13] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: msg + }.oneof_type + }.payload~presence_test + } + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + SELECT [11] { + IDENT [12] { + name: msg + }.oneof_type + }.payload + }.single_int64~presence_test + } + IDENT [13] { + name: @index0 + } + CALL [14] { + function: _*_ + args: { + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 0 } + } + } + } + } + CONSTANT [17] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_string_string + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + } + } + CALL [10] { + function: _?_:_ + args: { + CALL [11] { + function: _&&_ + args: { + CALL [12] { + function: _&&_ + args: { + SELECT [13] { + IDENT [14] { + name: msg + }.oneof_type~presence_test + } + SELECT [15] { + SELECT [16] { + IDENT [17] { + name: msg + }.oneof_type + }.payload~presence_test + } + } + } + SELECT [18] { + IDENT [19] { + name: @index1 + }.single_int64~presence_test + } + } + } + CALL [20] { + function: _?_:_ + args: { + CALL [21] { + function: _&&_ + args: { + SELECT [22] { + IDENT [23] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [24] { + IDENT [25] { + name: @index0 + }.key~presence_test + } + } + } + CALL [26] { + function: _==_ + args: { + SELECT [27] { + IDENT [28] { + name: @index0 + }.key + } + CONSTANT [29] { value: "A" } + } + } + CONSTANT [30] { value: false } + } + } + CONSTANT [31] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CALL [4] { + function: optional.none + args: { + } + } + IDENT [5] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [6] { + elements: { + CONSTANT [7] { value: 5 } + } + } + } + } + CALL [8] { + function: _==_ + args: { + LIST [9] { + elements: { + CONSTANT [10] { value: 10 } + CALL [11] { + function: optional.none + args: { + } + } + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + optional_indices: [0] + } + LIST [14] { + elements: { + CONSTANT [15] { value: 10 } + IDENT [16] { + name: @index1 + } + IDENT [17] { + name: @index1 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "hello" } + } + optional_entry: true + value: { + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "hello" } + } + } + } + } + } + CONSTANT [9] { value: "hello" } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + CALL [7] { + function: orValue + target: { + CALL [8] { + function: or + target: { + CALL [9] { + function: _[?_] + args: { + MAP [10] { + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: "key" } + } + optional_entry: true + value: { + CALL [13] { + function: optional.of + args: { + CONSTANT [14] { value: "test" } + } + } + } + } + } + CONSTANT [15] { value: "bogus" } + } + } + } + args: { + CALL [16] { + function: _[?_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: "bogus" } + } + } + } + } + } + args: { + CALL [19] { + function: _[_] + args: { + IDENT [20] { + name: @index0 + } + CONSTANT [21] { value: "key" } + } + } + } + } + } + } + CALL [22] { + function: _==_ + args: { + IDENT [23] { + name: @index1 + } + CONSTANT [24] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int64 + } + } + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + IDENT [16] { + name: @index0 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [2] { + function: matches + target: { + CONSTANT [1] { value: "hello world" } + } + args: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [3] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [7] { + function: _+_ + args: { + CONSTANT [8] { value: "h" } + CONSTANT [9] { value: "e" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "l" } + } + } + CONSTANT [12] { value: "o" } + } + } + CONSTANT [13] { value: " world" } + } + } + } + } + CALL [14] { + function: matches + target: { + IDENT [15] { + name: @index0 + } + } + args: { + CONSTANT [16] { value: "hello" } + } + } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [7] { + function: _+_ + args: { + CONSTANT [8] { value: "h" } + CONSTANT [9] { value: "e" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "l" } + } + } + CONSTANT [12] { value: "o" } + } + } + CONSTANT [13] { value: " world" } + } + } + } + } + CALL [14] { + function: matches + target: { + IDENT [15] { + name: @index0 + } + } + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + CONSTANT [20] { value: "w" } + CONSTANT [21] { value: "o" } + } + } + CONSTANT [22] { value: "r" } + } + } + CONSTANT [23] { value: "l" } + } + } + CONSTANT [24] { value: "d" } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: non_pure_custom_func + args: { + IDENT [11] { + name: @index0 + } + } + } + CALL [12] { + function: non_pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + CALL [17] { + function: non_pure_custom_func + args: { + IDENT [18] { + name: @index0 + } + } + } + } + } + CALL [19] { + function: non_pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: pure_custom_func + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [8] { + function: _+_ + args: { + IDENT [9] { + name: @index0 + } + CALL [10] { + function: pure_custom_func + args: { + SELECT [11] { + SELECT [12] { + SELECT [13] { + IDENT [14] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + } + } + CALL [15] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index1 + } + IDENT [18] { + name: @index0 + } + } + } + CALL [19] { + function: pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_6.baseline b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_6.baseline new file mode 100644 index 000000000..f13d51e99 --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_6.baseline @@ -0,0 +1,4871 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + IDENT [11] { + name: @index0 + } + } + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CONSTANT [11] { value: 2 } + IDENT [12] { + name: @index0 + } + } + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + IDENT [15] { + name: @index0 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + IDENT [17] { + name: @index1 + } + } + } + CONSTANT [18] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + CALL [20] { + function: _+_ + args: { + CONSTANT [21] { value: 5 } + IDENT [22] { + name: @index0 + } + } + } + IDENT [23] { + name: @index0 + } + } + } + IDENT [24] { + name: @index1 + } + } + } + IDENT [25] { + name: @index1 + } + } + } + IDENT [26] { + name: @index2 + } + } + } + IDENT [27] { + name: @index2 + } + } + } + } + } + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @index3 + } + CONSTANT [30] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: getFullYear + target: { + CALL [4] { + function: timestamp + args: { + CALL [5] { + function: int + args: { + CALL [6] { + function: timestamp + args: { + CONSTANT [7] { value: 1000000000 } + } + } + } + } + } + } + } + args: { + } + } + CALL [8] { + function: getFullYear + target: { + CALL [9] { + function: timestamp + args: { + CALL [10] { + function: int + args: { + CALL [11] { + function: timestamp + args: { + CONSTANT [12] { value: 200 } + } + } + } + } + } + } + } + args: { + } + } + CALL [13] { + function: timestamp + args: { + CALL [14] { + function: int + args: { + CALL [15] { + function: timestamp + args: { + CONSTANT [16] { value: 50 } + } + } + } + } + } + } + CALL [17] { + function: timestamp + args: { + CALL [18] { + function: int + args: { + CALL [19] { + function: timestamp + args: { + CONSTANT [20] { value: 75 } + } + } + } + } + } + } + CALL [21] { + function: _+_ + args: { + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + CALL [25] { + function: _+_ + args: { + IDENT [26] { + name: @index0 + } + CALL [27] { + function: getFullYear + target: { + IDENT [28] { + name: @index3 + } + } + args: { + } + } + } + } + CALL [29] { + function: getFullYear + target: { + IDENT [30] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [31] { + name: @index0 + } + } + } + CALL [32] { + function: getSeconds + target: { + IDENT [33] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [34] { + name: @index1 + } + } + } + } + } + CALL [35] { + function: _==_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index4 + } + IDENT [40] { + name: @index1 + } + } + } + CALL [41] { + function: getMinutes + target: { + IDENT [42] { + name: @index3 + } + } + args: { + } + } + } + } + IDENT [43] { + name: @index0 + } + } + } + CONSTANT [44] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + } + } + CONSTANT [15] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "e" } + } + value: { + MAP [6] { + MAP_ENTRY [7] { + key: { + CONSTANT [8] { value: "b" } + } + value: { + CONSTANT [9] { value: 1 } + } + } + } + } + } + } + MAP [10] { + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: "b" } + } + value: { + CONSTANT [13] { value: 1 } + } + } + } + } + } + MAP [14] { + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "a" } + } + value: { + IDENT [17] { + name: @index1 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "c" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "d" } + } + value: { + IDENT [23] { + name: @index0 + } + } + } + MAP_ENTRY [24] { + key: { + CONSTANT [25] { value: "e" } + } + value: { + IDENT [26] { + name: @index0 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index0 + } + SELECT [16] { + IDENT [17] { + name: @index1 + }.single_int32 + } + } + } + IDENT [18] { + name: @index0 + } + } + } + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + SELECT [21] { + SELECT [22] { + SELECT [23] { + IDENT [24] { + name: @index1 + }.oneof_type + }.payload + }.single_int64 + } + } + } + CONSTANT [25] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + } + } + CALL [9] { + function: _||_ + args: { + CALL [10] { + function: _||_ + args: { + CONSTANT [11] { value: true } + SELECT [12] { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: @index0 + }.payload + }.oneof_type + }.payload + }.single_bool + } + } + } + SELECT [17] { + SELECT [18] { + SELECT [19] { + SELECT [20] { + IDENT [21] { + name: @index0 + }.child + }.child + }.payload + }.single_bool + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CONSTANT [8] { value: 1 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + IDENT [14] { + name: @index0 + } + } + } + CONSTANT [15] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: 0 } + } + } + CALL [13] { + function: _[_] + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + CALL [16] { + function: _[_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 2 } + } + } + } + } + CONSTANT [19] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + } + } + } + SELECT [10] { + SELECT [11] { + SELECT [12] { + IDENT [13] { + name: @index0 + }.oneof_type + }.payload + }.single_int64 + } + } +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CONSTANT [12] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _?_:_ + args: { + CONSTANT [6] { value: false } + CONSTANT [7] { value: false } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: _*_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 2 } + } + } + } + } + CONSTANT [16] { value: 11 } + } + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _?_:_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index0 + } + IDENT [18] { + name: @index1 + } + } + } + CONSTANT [19] { value: 0 } + } + } + CONSTANT [20] { value: 0 } + } + } + CONSTANT [21] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:0 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + IDENT [31] { + name: @index0 + } + } + } + } + } + CALL [32] { + function: size + args: { + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + } + } + } + } + } + } + CALL [35] { + function: _==_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index2 + } + IDENT [40] { + name: @index2 + } + } + } + IDENT [41] { + name: @index3 + } + } + } + IDENT [42] { + name: @index3 + } + } + } + CONSTANT [43] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:1 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: "a" } + } + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:1 + } + CALL [25] { + function: _==_ + args: { + IDENT [26] { + name: @it:0:1 + } + CONSTANT [27] { value: "a" } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:1 + } + } + } + LIST [29] { + elements: { + IDENT [30] { + name: @index0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + } + } + } + } + CALL [33] { + function: _==_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + IDENT [37] { + name: @index2 + } + IDENT [38] { + name: @index2 + } + } + } + IDENT [39] { + name: @index3 + } + } + } + IDENT [40] { + name: @index3 + } + } + } + LIST [41] { + elements: { + CONSTANT [42] { value: true } + CONSTANT [43] { value: true } + CONSTANT [44] { value: true } + CONSTANT [45] { value: true } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @index0 + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _&&_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + LIST [22] { + elements: { + CONSTANT [23] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [24] { value: false } + } + loop_condition: { + CALL [25] { + function: @not_strictly_false + args: { + CALL [26] { + function: !_ + args: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [28] { + function: _||_ + args: { + IDENT [29] { + name: @ac:0:0 + } + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [37] { value: false } + } + loop_condition: { + CALL [38] { + function: @not_strictly_false + args: { + CALL [39] { + function: !_ + args: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [41] { + function: _||_ + args: { + IDENT [42] { + name: @ac:0:0 + } + CALL [43] { + function: _>_ + args: { + IDENT [44] { + name: @it:0:0 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>=_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [21] { + elements: { + CONSTANT [22] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:0:0 + } + CALL [29] { + function: _&&_ + args: { + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + CALL [33] { + function: _>=_ + args: { + IDENT [34] { + name: @it2:0:0 + } + CONSTANT [35] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + CALL [37] { + function: size + args: { + LIST [38] { + elements: { + IDENT [39] { + name: @index0 + } + } + } + } + } + CALL [40] { + function: size + args: { + LIST [41] { + elements: { + IDENT [42] { + name: @index1 + } + } + } + } + } + } + } + CALL [43] { + function: _==_ + args: { + CALL [44] { + function: _+_ + args: { + CALL [45] { + function: _+_ + args: { + CALL [46] { + function: _+_ + args: { + IDENT [47] { + name: @index2 + } + IDENT [48] { + name: @index2 + } + } + } + IDENT [49] { + name: @index3 + } + } + } + IDENT [50] { + name: @index3 + } + } + } + CONSTANT [51] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + CALL [20] { + function: _&&_ + args: { + CALL [21] { + function: _&&_ + args: { + IDENT [22] { + name: @index0 + } + IDENT [23] { + name: @index0 + } + } + } + CALL [24] { + function: _&&_ + args: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [26] { + elements: { + CONSTANT [27] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [28] { value: false } + } + loop_condition: { + CALL [29] { + function: @not_strictly_false + args: { + CALL [30] { + function: !_ + args: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [32] { + function: _||_ + args: { + IDENT [33] { + name: @ac:0:0 + } + CALL [34] { + function: _&&_ + args: { + CALL [35] { + function: _>_ + args: { + IDENT [36] { + name: @it:0:0 + } + CONSTANT [37] { value: 1 } + } + } + CALL [38] { + function: _>_ + args: { + IDENT [39] { + name: @it2:0:0 + } + CONSTANT [40] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:0:0 + } + } + } + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [43] { + elements: { + CONSTANT [44] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [45] { value: false } + } + loop_condition: { + CALL [46] { + function: @not_strictly_false + args: { + CALL [47] { + function: !_ + args: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [49] { + function: _||_ + args: { + IDENT [50] { + name: @ac:0:0 + } + CALL [51] { + function: _&&_ + args: { + CALL [52] { + function: _>_ + args: { + IDENT [53] { + name: @it:0:0 + } + CONSTANT [54] { value: 1 } + } + } + CALL [55] { + function: _>_ + args: { + IDENT [56] { + name: @it2:0:0 + } + CONSTANT [57] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [58] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_range: { + IDENT [12] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @ac:0:0 + } + LIST [17] { + elements: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @it:0:0 + } + CONSTANT [20] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [21] { + name: @ac:0:0 + } + } + } + } + } + CALL [22] { + function: _==_ + args: { + COMPREHENSION [23] { + iter_var: @it:1:0 + iter_range: { + IDENT [24] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:1:0 + } + LIST [29] { + elements: { + IDENT [30] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:1:0 + } + } + } + LIST [32] { + elements: { + IDENT [33] { + name: @index1 + } + IDENT [34] { + name: @index1 + } + IDENT [35] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @it:0:0 + } + IDENT [30] { + name: @it:1:0 + } + } + } + CALL [31] { + function: _+_ + args: { + IDENT [32] { + name: @ac:0:0 + } + LIST [33] { + elements: { + IDENT [34] { + name: @it:0:0 + } + } + } + } + } + IDENT [35] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [37] { + name: @ac:1:0 + } + } + } + IDENT [38] { + name: @index0 + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + } + } + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @index0 + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:1:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _*_ + args: { + IDENT [27] { + name: @it:1:0 + } + CONSTANT [28] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [12] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @ac:0:0 + } + LIST [17] { + elements: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @it:0:0 + } + IDENT [21] { + name: @it2:0:0 + } + } + } + CONSTANT [22] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [23] { + name: @ac:0:0 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + COMPREHENSION [25] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [26] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:1:0 + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + LIST [34] { + elements: { + IDENT [35] { + name: @index1 + } + IDENT [36] { + name: @index1 + } + IDENT [37] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + LIST [6] { + elements: { + CONSTANT [7] { value: 2 } + } + } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + CALL [15] { + function: _==_ + args: { + COMPREHENSION [16] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [17] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1:0 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0:0 + iter_range: { + IDENT [24] { + name: @index2 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _?_:_ + args: { + CALL [28] { + function: _&&_ + args: { + CALL [29] { + function: _==_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:1:0 + } + } + } + CALL [32] { + function: _<_ + args: { + IDENT [33] { + name: @it:1:0 + } + IDENT [34] { + name: @it2:1:0 + } + } + } + } + } + CALL [35] { + function: _+_ + args: { + IDENT [36] { + name: @ac:0:0 + } + LIST [37] { + elements: { + IDENT [38] { + name: @it:0:0 + } + } + } + } + } + IDENT [39] { + name: @ac:0:0 + } + } + } + } + result: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:1:0 + } + } + } + IDENT [42] { + name: @index0 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + COMPREHENSION [17] { + iter_var: @it:1:0 + iter_range: { + LIST [18] { + elements: { + CONSTANT [19] { value: 1 } + CONSTANT [20] { value: 2 } + CONSTANT [21] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [22] { + elements: { + } + } + } + loop_condition: { + CONSTANT [23] { value: true } + } + loop_step: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @ac:1:0 + } + LIST [26] { + elements: { + IDENT [27] { + name: @index0 + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:1:0 + } + } + } + } + } + CALL [29] { + function: _==_ + args: { + IDENT [30] { + name: @index1 + } + IDENT [31] { + name: @index1 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [8] { + + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: cel.@mapInsert + args: { + IDENT [11] { + name: @ac:1:0 + } + IDENT [12] { + name: @it:1:0 + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [14] { + elements: { + CONSTANT [15] { value: 1 } + CONSTANT [16] { value: 2 } + CONSTANT [17] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [18] { + + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: cel.@mapInsert + args: { + IDENT [21] { + name: @ac:0:0 + } + IDENT [22] { + name: @it:0:0 + } + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @it:0:0 + } + IDENT [26] { + name: @it2:0:0 + } + } + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + CALL [30] { + function: _==_ + args: { + IDENT [31] { + name: @index0 + } + IDENT [32] { + name: @index0 + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: @in + args: { + CONSTANT [4] { value: 1 } + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + CONSTANT [8] { value: 3 } + } + } + } + } + LIST [9] { + elements: { + CONSTANT [10] { value: 1 } + CONSTANT [11] { value: 2 } + CONSTANT [12] { value: 3 } + } + } + } + } + CALL [13] { + function: _&&_ + args: { + CALL [14] { + function: _&&_ + args: { + IDENT [15] { + name: @index0 + } + CALL [16] { + function: @in + args: { + CONSTANT [17] { value: 2 } + IDENT [18] { + name: @index1 + } + } + } + } + } + CALL [19] { + function: _&&_ + args: { + CALL [20] { + function: @in + args: { + CONSTANT [21] { value: 3 } + LIST [22] { + elements: { + CONSTANT [23] { value: 3 } + IDENT [24] { + name: @index1 + } + } + } + } + } + IDENT [25] { + name: @index0 + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_range: { + IDENT [14] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @ac:0:0 + } + LIST [19] { + elements: { + LIST [20] { + elements: { + CONSTANT [21] { value: 3 } + CONSTANT [22] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [23] { + name: @ac:0:0 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + COMPREHENSION [25] { + iter_var: @it:1:0 + iter_range: { + IDENT [26] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:1:0 + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + LIST [34] { + elements: { + IDENT [35] { + name: @index0 + } + IDENT [36] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [14] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @ac:0:0 + } + LIST [19] { + elements: { + LIST [20] { + elements: { + CONSTANT [21] { value: 3 } + CONSTANT [22] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [23] { + name: @ac:0:0 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + COMPREHENSION [25] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [26] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:1:0 + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + LIST [34] { + elements: { + IDENT [35] { + name: @index0 + } + IDENT [36] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + CONSTANT [6] { value: 1 } + } + } + CONSTANT [7] { value: 3 } + } + } + } + } + CALL [8] { + function: _||_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_range: { + LIST [10] { + elements: { + CALL [11] { + function: _?_:_ + args: { + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _-_ + args: { + IDENT [14] { + name: x + } + CONSTANT [15] { value: 1 } + } + } + CONSTANT [16] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [17] { value: false } + } + loop_condition: { + CALL [18] { + function: @not_strictly_false + args: { + CALL [19] { + function: !_ + args: { + IDENT [20] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [21] { + function: _||_ + args: { + IDENT [22] { + name: @ac:0:0 + } + CALL [23] { + function: _>_ + args: { + CALL [24] { + function: _-_ + args: { + IDENT [25] { + name: @it:0:0 + } + CONSTANT [26] { value: 1 } + } + } + CONSTANT [27] { value: 3 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + IDENT [29] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [15] { + name: @result + } + LIST [16] { + elements: { + LIST [6] { + elements: { + CALL [8] { + function: _+_ + args: { + IDENT [7] { + name: x + } + IDENT [9] { + name: x + } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [10] { + name: x + } + IDENT [12] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + LIST [22] { + elements: { + CALL [24] { + function: _+_ + args: { + IDENT [23] { + name: x + } + IDENT [25] { + name: x + } + } + } + CALL [27] { + function: _+_ + args: { + IDENT [26] { + name: x + } + IDENT [28] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + CALL [5] { + function: _-_ + args: { + IDENT [6] { + name: x + } + IDENT [7] { + name: y + } + } + } + CONSTANT [8] { value: 1 } + } + } + CONSTANT [9] { value: 3 } + } + } + } + } + CALL [10] { + function: _||_ + args: { + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [12] { + elements: { + CALL [13] { + function: _?_:_ + args: { + IDENT [14] { + name: @index0 + } + CALL [15] { + function: _-_ + args: { + CALL [16] { + function: _-_ + args: { + IDENT [17] { + name: x + } + IDENT [18] { + name: y + } + } + } + CONSTANT [19] { value: 1 } + } + } + CONSTANT [20] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [21] { value: false } + } + loop_condition: { + CALL [22] { + function: @not_strictly_false + args: { + CALL [23] { + function: !_ + args: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [25] { + function: _||_ + args: { + IDENT [26] { + name: @ac:0:0 + } + CALL [27] { + function: _>_ + args: { + CALL [28] { + function: _-_ + args: { + CALL [29] { + function: _-_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:0:0 + } + } + } + CONSTANT [32] { value: 1 } + } + } + CONSTANT [33] { value: 3 } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:0:0 + } + } + } + IDENT [35] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_var2: y + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + MAP [14] { + + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [17] { + function: cel.@mapInsert + args: { + IDENT [16] { + name: @result + } + IDENT [5] { + name: x + } + LIST [7] { + elements: { + CALL [9] { + function: _+_ + args: { + IDENT [8] { + name: x + } + IDENT [10] { + name: x + } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [11] { + name: y + } + IDENT [13] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + MAP [30] { + + } + } + loop_condition: { + CONSTANT [31] { value: true } + } + loop_step: { + CALL [33] { + function: cel.@mapInsert + args: { + IDENT [32] { + name: @result + } + IDENT [21] { + name: x + } + LIST [23] { + elements: { + CALL [25] { + function: _+_ + args: { + IDENT [24] { + name: x + } + IDENT [26] { + name: x + } + } + } + CALL [28] { + function: _+_ + args: { + IDENT [27] { + name: y + } + IDENT [29] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.payload~presence_test + } + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload + }.single_int64 + } + CONSTANT [12] { value: 0 } + } + } + CONSTANT [13] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: msg + }.oneof_type + }.payload~presence_test + } + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + SELECT [11] { + IDENT [12] { + name: msg + }.oneof_type + }.payload + }.single_int64~presence_test + } + IDENT [13] { + name: @index0 + } + CALL [14] { + function: _*_ + args: { + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 0 } + } + } + } + } + CONSTANT [17] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_string_string + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + } + } + CALL [10] { + function: _?_:_ + args: { + CALL [11] { + function: _&&_ + args: { + CALL [12] { + function: _&&_ + args: { + SELECT [13] { + IDENT [14] { + name: msg + }.oneof_type~presence_test + } + SELECT [15] { + SELECT [16] { + IDENT [17] { + name: msg + }.oneof_type + }.payload~presence_test + } + } + } + SELECT [18] { + IDENT [19] { + name: @index1 + }.single_int64~presence_test + } + } + } + CALL [20] { + function: _?_:_ + args: { + CALL [21] { + function: _&&_ + args: { + SELECT [22] { + IDENT [23] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [24] { + IDENT [25] { + name: @index0 + }.key~presence_test + } + } + } + CALL [26] { + function: _==_ + args: { + SELECT [27] { + IDENT [28] { + name: @index0 + }.key + } + CONSTANT [29] { value: "A" } + } + } + CONSTANT [30] { value: false } + } + } + CONSTANT [31] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CALL [4] { + function: optional.none + args: { + } + } + IDENT [5] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [6] { + elements: { + CONSTANT [7] { value: 5 } + } + } + } + } + CALL [8] { + function: _==_ + args: { + LIST [9] { + elements: { + CONSTANT [10] { value: 10 } + CALL [11] { + function: optional.none + args: { + } + } + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + optional_indices: [0] + } + LIST [14] { + elements: { + CONSTANT [15] { value: 10 } + IDENT [16] { + name: @index1 + } + IDENT [17] { + name: @index1 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "hello" } + } + optional_entry: true + value: { + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "hello" } + } + } + } + } + } + CONSTANT [9] { value: "hello" } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: orValue + target: { + CALL [9] { + function: or + target: { + CALL [10] { + function: _[?_] + args: { + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "key" } + } + optional_entry: true + value: { + CALL [14] { + function: optional.of + args: { + CONSTANT [15] { value: "test" } + } + } + } + } + } + CONSTANT [16] { value: "bogus" } + } + } + } + args: { + CALL [17] { + function: _[?_] + args: { + IDENT [18] { + name: @index0 + } + CONSTANT [19] { value: "bogus" } + } + } + } + } + } + args: { + CALL [20] { + function: _[_] + args: { + IDENT [21] { + name: @index0 + } + CONSTANT [22] { value: "key" } + } + } + } + } + CONSTANT [23] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int64 + } + } + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + IDENT [16] { + name: @index0 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [2] { + function: matches + target: { + CONSTANT [1] { value: "hello world" } + } + args: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [3] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CONSTANT [13] { value: "hello" } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CALL [20] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CONSTANT [13] { value: "w" } + CONSTANT [15] { value: "o" } + } + } + CONSTANT [17] { value: "r" } + } + } + CONSTANT [19] { value: "l" } + } + } + CONSTANT [21] { value: "d" } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: non_pure_custom_func + args: { + IDENT [11] { + name: @index0 + } + } + } + CALL [12] { + function: non_pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + CALL [17] { + function: non_pure_custom_func + args: { + IDENT [18] { + name: @index0 + } + } + } + } + } + CALL [19] { + function: non_pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: pure_custom_func + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: pure_custom_func + args: { + SELECT [12] { + SELECT [13] { + SELECT [14] { + IDENT [15] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + IDENT [16] { + name: @index0 + } + } + } + } + } + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @index1 + } + CALL [19] { + function: pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_7.baseline b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_7.baseline new file mode 100644 index 000000000..020447afd --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_7.baseline @@ -0,0 +1,4817 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + IDENT [11] { + name: @index0 + } + } + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CONSTANT [11] { value: 2 } + IDENT [12] { + name: @index0 + } + } + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + IDENT [15] { + name: @index0 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + IDENT [17] { + name: @index1 + } + } + } + CONSTANT [18] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + CALL [20] { + function: _+_ + args: { + CALL [21] { + function: _+_ + args: { + CONSTANT [22] { value: 5 } + IDENT [23] { + name: @index0 + } + } + } + IDENT [24] { + name: @index0 + } + } + } + IDENT [25] { + name: @index1 + } + } + } + IDENT [26] { + name: @index1 + } + } + } + IDENT [27] { + name: @index2 + } + } + } + IDENT [28] { + name: @index2 + } + } + } + CONSTANT [29] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: getFullYear + target: { + CALL [4] { + function: timestamp + args: { + CALL [5] { + function: int + args: { + CALL [6] { + function: timestamp + args: { + CONSTANT [7] { value: 1000000000 } + } + } + } + } + } + } + } + args: { + } + } + CALL [8] { + function: getFullYear + target: { + CALL [9] { + function: timestamp + args: { + CALL [10] { + function: int + args: { + CALL [11] { + function: timestamp + args: { + CONSTANT [12] { value: 200 } + } + } + } + } + } + } + } + args: { + } + } + CALL [13] { + function: timestamp + args: { + CALL [14] { + function: int + args: { + CALL [15] { + function: timestamp + args: { + CONSTANT [16] { value: 50 } + } + } + } + } + } + } + CALL [17] { + function: timestamp + args: { + CALL [18] { + function: int + args: { + CALL [19] { + function: timestamp + args: { + CONSTANT [20] { value: 75 } + } + } + } + } + } + } + CALL [21] { + function: _+_ + args: { + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + CALL [25] { + function: _+_ + args: { + CALL [26] { + function: _+_ + args: { + IDENT [27] { + name: @index0 + } + CALL [28] { + function: getFullYear + target: { + IDENT [29] { + name: @index3 + } + } + args: { + } + } + } + } + CALL [30] { + function: getFullYear + target: { + IDENT [31] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [32] { + name: @index0 + } + } + } + CALL [33] { + function: getSeconds + target: { + IDENT [34] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [35] { + name: @index1 + } + } + } + IDENT [36] { + name: @index1 + } + } + } + } + } + CALL [37] { + function: _==_ + args: { + CALL [38] { + function: _+_ + args: { + CALL [39] { + function: _+_ + args: { + IDENT [40] { + name: @index4 + } + CALL [41] { + function: getMinutes + target: { + IDENT [42] { + name: @index3 + } + } + args: { + } + } + } + } + IDENT [43] { + name: @index0 + } + } + } + CONSTANT [44] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + } + } + CONSTANT [15] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "e" } + } + value: { + MAP [6] { + MAP_ENTRY [7] { + key: { + CONSTANT [8] { value: "b" } + } + value: { + CONSTANT [9] { value: 1 } + } + } + } + } + } + } + MAP [10] { + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: "b" } + } + value: { + CONSTANT [13] { value: 1 } + } + } + } + } + } + MAP [14] { + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "a" } + } + value: { + IDENT [17] { + name: @index1 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "c" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "d" } + } + value: { + IDENT [23] { + name: @index0 + } + } + } + MAP_ENTRY [24] { + key: { + CONSTANT [25] { value: "e" } + } + value: { + IDENT [26] { + name: @index0 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index0 + } + SELECT [16] { + IDENT [17] { + name: @index1 + }.single_int32 + } + } + } + IDENT [18] { + name: @index0 + } + } + } + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + SELECT [21] { + SELECT [22] { + SELECT [23] { + IDENT [24] { + name: @index1 + }.oneof_type + }.payload + }.single_int64 + } + } + } + CONSTANT [25] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + } + } + CALL [9] { + function: _||_ + args: { + CALL [10] { + function: _||_ + args: { + CONSTANT [11] { value: true } + SELECT [12] { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: @index0 + }.payload + }.oneof_type + }.payload + }.single_bool + } + } + } + SELECT [17] { + SELECT [18] { + SELECT [19] { + SELECT [20] { + IDENT [21] { + name: @index0 + }.child + }.child + }.payload + }.single_bool + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CONSTANT [8] { value: 1 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + IDENT [14] { + name: @index0 + } + } + } + CONSTANT [15] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: 0 } + } + } + CALL [13] { + function: _[_] + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + CALL [16] { + function: _[_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 2 } + } + } + } + } + CONSTANT [19] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + SELECT [8] { + SELECT [9] { + IDENT [10] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + } + } + SELECT [11] { + SELECT [12] { + IDENT [13] { + name: @index0 + }.payload + }.single_int64 + } + } +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CONSTANT [12] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _?_:_ + args: { + CONSTANT [6] { value: false } + CONSTANT [7] { value: false } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: _*_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 2 } + } + } + } + } + CONSTANT [16] { value: 11 } + } + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _?_:_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index0 + } + IDENT [18] { + name: @index1 + } + } + } + CONSTANT [19] { value: 0 } + } + } + CONSTANT [20] { value: 0 } + } + } + CONSTANT [21] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:0 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + IDENT [31] { + name: @index0 + } + } + } + } + } + CALL [32] { + function: size + args: { + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + } + } + } + } + } + } + CALL [35] { + function: _==_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index2 + } + IDENT [40] { + name: @index2 + } + } + } + IDENT [41] { + name: @index3 + } + } + } + IDENT [42] { + name: @index3 + } + } + } + CONSTANT [43] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:1 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: "a" } + } + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:1 + } + CALL [25] { + function: _==_ + args: { + IDENT [26] { + name: @it:0:1 + } + CONSTANT [27] { value: "a" } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:1 + } + } + } + LIST [29] { + elements: { + IDENT [30] { + name: @index0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + } + } + } + } + CALL [33] { + function: _==_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + IDENT [37] { + name: @index2 + } + IDENT [38] { + name: @index2 + } + } + } + IDENT [39] { + name: @index3 + } + } + } + IDENT [40] { + name: @index3 + } + } + } + LIST [41] { + elements: { + CONSTANT [42] { value: true } + CONSTANT [43] { value: true } + CONSTANT [44] { value: true } + CONSTANT [45] { value: true } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @index0 + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _&&_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + LIST [22] { + elements: { + CONSTANT [23] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [24] { value: false } + } + loop_condition: { + CALL [25] { + function: @not_strictly_false + args: { + CALL [26] { + function: !_ + args: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [28] { + function: _||_ + args: { + IDENT [29] { + name: @ac:0:0 + } + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [37] { value: false } + } + loop_condition: { + CALL [38] { + function: @not_strictly_false + args: { + CALL [39] { + function: !_ + args: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [41] { + function: _||_ + args: { + IDENT [42] { + name: @ac:0:0 + } + CALL [43] { + function: _>_ + args: { + IDENT [44] { + name: @it:0:0 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>=_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [21] { + elements: { + CONSTANT [22] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:0:0 + } + CALL [29] { + function: _&&_ + args: { + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + CALL [33] { + function: _>=_ + args: { + IDENT [34] { + name: @it2:0:0 + } + CONSTANT [35] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + CALL [37] { + function: size + args: { + LIST [38] { + elements: { + IDENT [39] { + name: @index0 + } + } + } + } + } + CALL [40] { + function: size + args: { + LIST [41] { + elements: { + IDENT [42] { + name: @index1 + } + } + } + } + } + } + } + CALL [43] { + function: _==_ + args: { + CALL [44] { + function: _+_ + args: { + CALL [45] { + function: _+_ + args: { + CALL [46] { + function: _+_ + args: { + IDENT [47] { + name: @index2 + } + IDENT [48] { + name: @index2 + } + } + } + IDENT [49] { + name: @index3 + } + } + } + IDENT [50] { + name: @index3 + } + } + } + CONSTANT [51] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + CALL [20] { + function: _&&_ + args: { + CALL [21] { + function: _&&_ + args: { + IDENT [22] { + name: @index0 + } + IDENT [23] { + name: @index0 + } + } + } + CALL [24] { + function: _&&_ + args: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [26] { + elements: { + CONSTANT [27] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [28] { value: false } + } + loop_condition: { + CALL [29] { + function: @not_strictly_false + args: { + CALL [30] { + function: !_ + args: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [32] { + function: _||_ + args: { + IDENT [33] { + name: @ac:0:0 + } + CALL [34] { + function: _&&_ + args: { + CALL [35] { + function: _>_ + args: { + IDENT [36] { + name: @it:0:0 + } + CONSTANT [37] { value: 1 } + } + } + CALL [38] { + function: _>_ + args: { + IDENT [39] { + name: @it2:0:0 + } + CONSTANT [40] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:0:0 + } + } + } + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [43] { + elements: { + CONSTANT [44] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [45] { value: false } + } + loop_condition: { + CALL [46] { + function: @not_strictly_false + args: { + CALL [47] { + function: !_ + args: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [49] { + function: _||_ + args: { + IDENT [50] { + name: @ac:0:0 + } + CALL [51] { + function: _&&_ + args: { + CALL [52] { + function: _>_ + args: { + IDENT [53] { + name: @it:0:0 + } + CONSTANT [54] { value: 1 } + } + } + CALL [55] { + function: _>_ + args: { + IDENT [56] { + name: @it2:0:0 + } + CONSTANT [57] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [58] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + } + } + CALL [11] { + function: _==_ + args: { + COMPREHENSION [12] { + iter_var: @it:1:0 + iter_range: { + IDENT [13] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [14] { + elements: { + } + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @ac:1:0 + } + LIST [18] { + elements: { + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:0:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _+_ + args: { + IDENT [27] { + name: @it:0:0 + } + CONSTANT [28] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:1:0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + IDENT [33] { + name: @index1 + } + IDENT [34] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [31] { + function: _==_ + args: { + COMPREHENSION [30] { + iter_var: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @result + accu_init: { + LIST [24] { + elements: { + } + } + } + loop_condition: { + CONSTANT [25] { value: true } + } + loop_step: { + CALL [28] { + function: _+_ + args: { + IDENT [26] { + name: @result + } + LIST [27] { + elements: { + COMPREHENSION [23] { + iter_var: x + iter_range: { + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + } + } + } + accu_var: @result + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [21] { + function: _?_:_ + args: { + CALL [13] { + function: _==_ + args: { + IDENT [12] { + name: x + } + IDENT [14] { + name: y + } + } + } + CALL [19] { + function: _+_ + args: { + IDENT [17] { + name: @result + } + LIST [18] { + elements: { + IDENT [11] { + name: x + } + } + } + } + } + IDENT [20] { + name: @result + } + } + } + } + result: { + IDENT [22] { + name: @result + } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @result + } + } + } + LIST [32] { + elements: { + LIST [33] { + elements: { + CONSTANT [34] { value: 1 } + } + } + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + } + } + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @index0 + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:1:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _*_ + args: { + IDENT [27] { + name: @it:1:0 + } + CONSTANT [28] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [12] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @ac:0:0 + } + LIST [17] { + elements: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @it:0:0 + } + IDENT [21] { + name: @it2:0:0 + } + } + } + CONSTANT [22] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [23] { + name: @ac:0:0 + } + } + } + } + } + CALL [24] { + function: _==_ + args: { + COMPREHENSION [25] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [26] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [27] { + elements: { + } + } + } + loop_condition: { + CONSTANT [28] { value: true } + } + loop_step: { + CALL [29] { + function: _+_ + args: { + IDENT [30] { + name: @ac:1:0 + } + LIST [31] { + elements: { + IDENT [32] { + name: @index2 + } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:1:0 + } + } + } + LIST [34] { + elements: { + IDENT [35] { + name: @index1 + } + IDENT [36] { + name: @index1 + } + IDENT [37] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [36] { + function: _==_ + args: { + COMPREHENSION [35] { + iter_var: i + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + COMPREHENSION [28] { + iter_var: x + iter_range: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + CONSTANT [10] { value: 3 } + } + } + } + accu_var: @result + accu_init: { + LIST [20] { + elements: { + } + } + } + loop_condition: { + CONSTANT [21] { value: true } + } + loop_step: { + CALL [26] { + function: _?_:_ + args: { + CALL [16] { + function: _&&_ + args: { + CALL [14] { + function: _==_ + args: { + IDENT [13] { + name: x + } + IDENT [15] { + name: y + } + } + } + CALL [18] { + function: _<_ + args: { + IDENT [17] { + name: i + } + IDENT [19] { + name: y + } + } + } + } + } + CALL [24] { + function: _+_ + args: { + IDENT [22] { + name: @result + } + LIST [23] { + elements: { + IDENT [12] { + name: x + } + } + } + } + } + IDENT [25] { + name: @result + } + } + } + } + result: { + IDENT [27] { + name: @result + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } + } + LIST [37] { + elements: { + LIST [38] { + elements: { + CONSTANT [39] { value: 1 } + } + } + LIST [40] { + elements: { + CONSTANT [41] { value: 2 } + } + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:1:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:1:0 + } + LIST [12] { + elements: { + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_range: { + LIST [14] { + elements: { + CONSTANT [15] { value: 1 } + CONSTANT [16] { value: 2 } + CONSTANT [17] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:0:0 + } + LIST [22] { + elements: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @it:0:0 + } + CONSTANT [25] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:1:0 + } + } + } + } + } + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @index0 + } + IDENT [30] { + name: @index0 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [8] { + + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: cel.@mapInsert + args: { + IDENT [11] { + name: @ac:1:0 + } + IDENT [12] { + name: @it:1:0 + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [14] { + elements: { + CONSTANT [15] { value: 1 } + CONSTANT [16] { value: 2 } + CONSTANT [17] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [18] { + + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: cel.@mapInsert + args: { + IDENT [21] { + name: @ac:0:0 + } + IDENT [22] { + name: @it:0:0 + } + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @it:0:0 + } + IDENT [26] { + name: @it2:0:0 + } + } + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + CALL [30] { + function: _==_ + args: { + IDENT [31] { + name: @index0 + } + IDENT [32] { + name: @index0 + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: @in + args: { + CONSTANT [4] { value: 1 } + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + CONSTANT [8] { value: 3 } + } + } + } + } + LIST [9] { + elements: { + CONSTANT [10] { value: 1 } + CONSTANT [11] { value: 2 } + CONSTANT [12] { value: 3 } + } + } + } + } + CALL [13] { + function: _&&_ + args: { + CALL [14] { + function: _&&_ + args: { + IDENT [15] { + name: @index0 + } + CALL [16] { + function: @in + args: { + CONSTANT [17] { value: 2 } + IDENT [18] { + name: @index1 + } + } + } + } + } + CALL [19] { + function: _&&_ + args: { + CALL [20] { + function: @in + args: { + CONSTANT [21] { value: 3 } + LIST [22] { + elements: { + CONSTANT [23] { value: 3 } + IDENT [24] { + name: @index1 + } + } + } + } + } + IDENT [25] { + name: @index0 + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + } + } + CALL [13] { + function: _==_ + args: { + COMPREHENSION [14] { + iter_var: @it:1:0 + iter_range: { + IDENT [15] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [16] { + elements: { + } + } + } + loop_condition: { + CONSTANT [17] { value: true } + } + loop_step: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @ac:1:0 + } + LIST [20] { + elements: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + IDENT [22] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [23] { + elements: { + } + } + } + loop_condition: { + CONSTANT [24] { value: true } + } + loop_step: { + CALL [25] { + function: _+_ + args: { + IDENT [26] { + name: @ac:0:0 + } + LIST [27] { + elements: { + LIST [28] { + elements: { + CONSTANT [29] { value: 3 } + CONSTANT [30] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1:0 + } + } + } + LIST [33] { + elements: { + IDENT [34] { + name: @index0 + } + IDENT [35] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + } + } + CALL [13] { + function: _==_ + args: { + COMPREHENSION [14] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [15] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [16] { + elements: { + } + } + } + loop_condition: { + CONSTANT [17] { value: true } + } + loop_step: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @ac:1:0 + } + LIST [20] { + elements: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [22] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [23] { + elements: { + } + } + } + loop_condition: { + CONSTANT [24] { value: true } + } + loop_step: { + CALL [25] { + function: _+_ + args: { + IDENT [26] { + name: @ac:0:0 + } + LIST [27] { + elements: { + LIST [28] { + elements: { + CONSTANT [29] { value: 3 } + CONSTANT [30] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1:0 + } + } + } + LIST [33] { + elements: { + IDENT [34] { + name: @index0 + } + IDENT [35] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + CONSTANT [6] { value: 1 } + } + } + CONSTANT [7] { value: 3 } + } + } + } + } + CALL [8] { + function: _||_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_range: { + LIST [10] { + elements: { + CALL [11] { + function: _?_:_ + args: { + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _-_ + args: { + IDENT [14] { + name: x + } + CONSTANT [15] { value: 1 } + } + } + CONSTANT [16] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [17] { value: false } + } + loop_condition: { + CALL [18] { + function: @not_strictly_false + args: { + CALL [19] { + function: !_ + args: { + IDENT [20] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [21] { + function: _||_ + args: { + IDENT [22] { + name: @ac:0:0 + } + CALL [23] { + function: _>_ + args: { + CALL [24] { + function: _-_ + args: { + IDENT [25] { + name: @it:0:0 + } + CONSTANT [26] { value: 1 } + } + } + CONSTANT [27] { value: 3 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + IDENT [29] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [15] { + name: @result + } + LIST [16] { + elements: { + LIST [6] { + elements: { + CALL [8] { + function: _+_ + args: { + IDENT [7] { + name: x + } + IDENT [9] { + name: x + } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [10] { + name: x + } + IDENT [12] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + LIST [22] { + elements: { + CALL [24] { + function: _+_ + args: { + IDENT [23] { + name: x + } + IDENT [25] { + name: x + } + } + } + CALL [27] { + function: _+_ + args: { + IDENT [26] { + name: x + } + IDENT [28] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + CALL [5] { + function: _-_ + args: { + IDENT [6] { + name: x + } + IDENT [7] { + name: y + } + } + } + CONSTANT [8] { value: 1 } + } + } + CONSTANT [9] { value: 3 } + } + } + } + } + CALL [10] { + function: _||_ + args: { + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [12] { + elements: { + CALL [13] { + function: _?_:_ + args: { + IDENT [14] { + name: @index0 + } + CALL [15] { + function: _-_ + args: { + CALL [16] { + function: _-_ + args: { + IDENT [17] { + name: x + } + IDENT [18] { + name: y + } + } + } + CONSTANT [19] { value: 1 } + } + } + CONSTANT [20] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [21] { value: false } + } + loop_condition: { + CALL [22] { + function: @not_strictly_false + args: { + CALL [23] { + function: !_ + args: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [25] { + function: _||_ + args: { + IDENT [26] { + name: @ac:0:0 + } + CALL [27] { + function: _>_ + args: { + CALL [28] { + function: _-_ + args: { + CALL [29] { + function: _-_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:0:0 + } + } + } + CONSTANT [32] { value: 1 } + } + } + CONSTANT [33] { value: 3 } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:0:0 + } + } + } + IDENT [35] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_var2: y + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + MAP [14] { + + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [17] { + function: cel.@mapInsert + args: { + IDENT [16] { + name: @result + } + IDENT [5] { + name: x + } + LIST [7] { + elements: { + CALL [9] { + function: _+_ + args: { + IDENT [8] { + name: x + } + IDENT [10] { + name: x + } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [11] { + name: y + } + IDENT [13] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + MAP [30] { + + } + } + loop_condition: { + CONSTANT [31] { value: true } + } + loop_step: { + CALL [33] { + function: cel.@mapInsert + args: { + IDENT [32] { + name: @result + } + IDENT [21] { + name: x + } + LIST [23] { + elements: { + CALL [25] { + function: _+_ + args: { + IDENT [24] { + name: x + } + IDENT [26] { + name: x + } + } + } + CALL [28] { + function: _+_ + args: { + IDENT [27] { + name: y + } + IDENT [29] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.payload~presence_test + } + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload + }.single_int64 + } + CONSTANT [12] { value: 0 } + } + } + CONSTANT [13] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: msg + }.oneof_type + }.payload~presence_test + } + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + SELECT [11] { + IDENT [12] { + name: msg + }.oneof_type + }.payload + }.single_int64~presence_test + } + IDENT [13] { + name: @index0 + } + CALL [14] { + function: _*_ + args: { + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 0 } + } + } + } + } + CONSTANT [17] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_string_string + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + } + } + CALL [10] { + function: _?_:_ + args: { + CALL [11] { + function: _&&_ + args: { + CALL [12] { + function: _&&_ + args: { + SELECT [13] { + IDENT [14] { + name: msg + }.oneof_type~presence_test + } + SELECT [15] { + SELECT [16] { + IDENT [17] { + name: msg + }.oneof_type + }.payload~presence_test + } + } + } + SELECT [18] { + IDENT [19] { + name: @index1 + }.single_int64~presence_test + } + } + } + CALL [20] { + function: _?_:_ + args: { + CALL [21] { + function: _&&_ + args: { + SELECT [22] { + IDENT [23] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [24] { + IDENT [25] { + name: @index0 + }.key~presence_test + } + } + } + CALL [26] { + function: _==_ + args: { + SELECT [27] { + IDENT [28] { + name: @index0 + }.key + } + CONSTANT [29] { value: "A" } + } + } + CONSTANT [30] { value: false } + } + } + CONSTANT [31] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CALL [4] { + function: optional.none + args: { + } + } + IDENT [5] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [6] { + elements: { + CONSTANT [7] { value: 5 } + } + } + } + } + CALL [8] { + function: _==_ + args: { + LIST [9] { + elements: { + CONSTANT [10] { value: 10 } + CALL [11] { + function: optional.none + args: { + } + } + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + optional_indices: [0] + } + LIST [14] { + elements: { + CONSTANT [15] { value: 10 } + IDENT [16] { + name: @index1 + } + IDENT [17] { + name: @index1 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "hello" } + } + optional_entry: true + value: { + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "hello" } + } + } + } + } + } + CONSTANT [9] { value: "hello" } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: orValue + target: { + CALL [9] { + function: or + target: { + CALL [10] { + function: _[?_] + args: { + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "key" } + } + optional_entry: true + value: { + CALL [14] { + function: optional.of + args: { + CONSTANT [15] { value: "test" } + } + } + } + } + } + CONSTANT [16] { value: "bogus" } + } + } + } + args: { + CALL [17] { + function: _[?_] + args: { + IDENT [18] { + name: @index0 + } + CONSTANT [19] { value: "bogus" } + } + } + } + } + } + args: { + CALL [20] { + function: _[_] + args: { + IDENT [21] { + name: @index0 + } + CONSTANT [22] { value: "key" } + } + } + } + } + CONSTANT [23] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int64 + } + } + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + IDENT [16] { + name: @index0 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [2] { + function: matches + target: { + CONSTANT [1] { value: "hello world" } + } + args: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [3] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CONSTANT [13] { value: "hello" } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CALL [20] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CONSTANT [13] { value: "w" } + CONSTANT [15] { value: "o" } + } + } + CONSTANT [17] { value: "r" } + } + } + CONSTANT [19] { value: "l" } + } + } + CONSTANT [21] { value: "d" } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: non_pure_custom_func + args: { + IDENT [11] { + name: @index0 + } + } + } + CALL [12] { + function: non_pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + CALL [17] { + function: non_pure_custom_func + args: { + IDENT [18] { + name: @index0 + } + } + } + } + } + CALL [19] { + function: non_pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: pure_custom_func + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + IDENT [17] { + name: @index0 + } + } + } + CALL [18] { + function: pure_custom_func + args: { + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_8.baseline b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_8.baseline new file mode 100644 index 000000000..bd1fa8d45 --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_8.baseline @@ -0,0 +1,4814 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + IDENT [11] { + name: @index0 + } + } + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CONSTANT [11] { value: 2 } + IDENT [12] { + name: @index0 + } + } + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + IDENT [15] { + name: @index0 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + IDENT [17] { + name: @index1 + } + } + } + CONSTANT [18] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + CALL [20] { + function: _+_ + args: { + CALL [21] { + function: _+_ + args: { + CONSTANT [22] { value: 5 } + IDENT [23] { + name: @index0 + } + } + } + IDENT [24] { + name: @index0 + } + } + } + IDENT [25] { + name: @index1 + } + } + } + IDENT [26] { + name: @index1 + } + } + } + IDENT [27] { + name: @index2 + } + } + } + IDENT [28] { + name: @index2 + } + } + } + CONSTANT [29] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: getFullYear + target: { + CALL [4] { + function: timestamp + args: { + CALL [5] { + function: int + args: { + CALL [6] { + function: timestamp + args: { + CONSTANT [7] { value: 1000000000 } + } + } + } + } + } + } + } + args: { + } + } + CALL [8] { + function: getFullYear + target: { + CALL [9] { + function: timestamp + args: { + CALL [10] { + function: int + args: { + CALL [11] { + function: timestamp + args: { + CONSTANT [12] { value: 200 } + } + } + } + } + } + } + } + args: { + } + } + CALL [13] { + function: timestamp + args: { + CALL [14] { + function: int + args: { + CALL [15] { + function: timestamp + args: { + CONSTANT [16] { value: 50 } + } + } + } + } + } + } + CALL [17] { + function: timestamp + args: { + CALL [18] { + function: int + args: { + CALL [19] { + function: timestamp + args: { + CONSTANT [20] { value: 75 } + } + } + } + } + } + } + CALL [21] { + function: _+_ + args: { + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + CALL [25] { + function: _+_ + args: { + CALL [26] { + function: _+_ + args: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @index0 + } + CALL [29] { + function: getFullYear + target: { + IDENT [30] { + name: @index3 + } + } + args: { + } + } + } + } + CALL [31] { + function: getFullYear + target: { + IDENT [32] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [33] { + name: @index0 + } + } + } + CALL [34] { + function: getSeconds + target: { + IDENT [35] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [36] { + name: @index1 + } + } + } + IDENT [37] { + name: @index1 + } + } + } + CALL [38] { + function: getMinutes + target: { + IDENT [39] { + name: @index3 + } + } + args: { + } + } + } + } + } + } + CALL [40] { + function: _==_ + args: { + CALL [41] { + function: _+_ + args: { + IDENT [42] { + name: @index4 + } + IDENT [43] { + name: @index0 + } + } + } + CONSTANT [44] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + } + } + CONSTANT [15] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "e" } + } + value: { + MAP [6] { + MAP_ENTRY [7] { + key: { + CONSTANT [8] { value: "b" } + } + value: { + CONSTANT [9] { value: 1 } + } + } + } + } + } + } + MAP [10] { + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: "b" } + } + value: { + CONSTANT [13] { value: 1 } + } + } + } + } + } + MAP [14] { + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "a" } + } + value: { + IDENT [17] { + name: @index1 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "c" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "d" } + } + value: { + IDENT [23] { + name: @index0 + } + } + } + MAP_ENTRY [24] { + key: { + CONSTANT [25] { value: "e" } + } + value: { + IDENT [26] { + name: @index0 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index0 + } + SELECT [16] { + IDENT [17] { + name: @index1 + }.single_int32 + } + } + } + IDENT [18] { + name: @index0 + } + } + } + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + SELECT [21] { + SELECT [22] { + SELECT [23] { + IDENT [24] { + name: @index1 + }.oneof_type + }.payload + }.single_int64 + } + } + } + CONSTANT [25] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + } + } + CALL [9] { + function: _||_ + args: { + CALL [10] { + function: _||_ + args: { + CONSTANT [11] { value: true } + SELECT [12] { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: @index0 + }.payload + }.oneof_type + }.payload + }.single_bool + } + } + } + SELECT [17] { + SELECT [18] { + SELECT [19] { + SELECT [20] { + IDENT [21] { + name: @index0 + }.child + }.child + }.payload + }.single_bool + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CONSTANT [8] { value: 1 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + IDENT [14] { + name: @index0 + } + } + } + CONSTANT [15] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: 0 } + } + } + CALL [13] { + function: _[_] + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + CALL [16] { + function: _[_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 2 } + } + } + } + } + CONSTANT [19] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + SELECT [8] { + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + } + } + } + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int64 + } + } +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CONSTANT [12] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _?_:_ + args: { + CONSTANT [6] { value: false } + CONSTANT [7] { value: false } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: _*_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 2 } + } + } + } + } + CONSTANT [16] { value: 11 } + } + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _?_:_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index0 + } + IDENT [18] { + name: @index1 + } + } + } + CONSTANT [19] { value: 0 } + } + } + CONSTANT [20] { value: 0 } + } + } + CONSTANT [21] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:0 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + IDENT [31] { + name: @index0 + } + } + } + } + } + CALL [32] { + function: size + args: { + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + } + } + } + } + } + } + CALL [35] { + function: _==_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index2 + } + IDENT [40] { + name: @index2 + } + } + } + IDENT [41] { + name: @index3 + } + } + } + IDENT [42] { + name: @index3 + } + } + } + CONSTANT [43] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:1 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: "a" } + } + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:1 + } + CALL [25] { + function: _==_ + args: { + IDENT [26] { + name: @it:0:1 + } + CONSTANT [27] { value: "a" } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:1 + } + } + } + LIST [29] { + elements: { + IDENT [30] { + name: @index0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + } + } + } + } + CALL [33] { + function: _==_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + IDENT [37] { + name: @index2 + } + IDENT [38] { + name: @index2 + } + } + } + IDENT [39] { + name: @index3 + } + } + } + IDENT [40] { + name: @index3 + } + } + } + LIST [41] { + elements: { + CONSTANT [42] { value: true } + CONSTANT [43] { value: true } + CONSTANT [44] { value: true } + CONSTANT [45] { value: true } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @index0 + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _&&_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + LIST [22] { + elements: { + CONSTANT [23] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [24] { value: false } + } + loop_condition: { + CALL [25] { + function: @not_strictly_false + args: { + CALL [26] { + function: !_ + args: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [28] { + function: _||_ + args: { + IDENT [29] { + name: @ac:0:0 + } + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [37] { value: false } + } + loop_condition: { + CALL [38] { + function: @not_strictly_false + args: { + CALL [39] { + function: !_ + args: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [41] { + function: _||_ + args: { + IDENT [42] { + name: @ac:0:0 + } + CALL [43] { + function: _>_ + args: { + IDENT [44] { + name: @it:0:0 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>=_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [21] { + elements: { + CONSTANT [22] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:0:0 + } + CALL [29] { + function: _&&_ + args: { + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + CALL [33] { + function: _>=_ + args: { + IDENT [34] { + name: @it2:0:0 + } + CONSTANT [35] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + CALL [37] { + function: size + args: { + LIST [38] { + elements: { + IDENT [39] { + name: @index0 + } + } + } + } + } + CALL [40] { + function: size + args: { + LIST [41] { + elements: { + IDENT [42] { + name: @index1 + } + } + } + } + } + } + } + CALL [43] { + function: _==_ + args: { + CALL [44] { + function: _+_ + args: { + CALL [45] { + function: _+_ + args: { + CALL [46] { + function: _+_ + args: { + IDENT [47] { + name: @index2 + } + IDENT [48] { + name: @index2 + } + } + } + IDENT [49] { + name: @index3 + } + } + } + IDENT [50] { + name: @index3 + } + } + } + CONSTANT [51] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + CALL [20] { + function: _&&_ + args: { + CALL [21] { + function: _&&_ + args: { + IDENT [22] { + name: @index0 + } + IDENT [23] { + name: @index0 + } + } + } + CALL [24] { + function: _&&_ + args: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [26] { + elements: { + CONSTANT [27] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [28] { value: false } + } + loop_condition: { + CALL [29] { + function: @not_strictly_false + args: { + CALL [30] { + function: !_ + args: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [32] { + function: _||_ + args: { + IDENT [33] { + name: @ac:0:0 + } + CALL [34] { + function: _&&_ + args: { + CALL [35] { + function: _>_ + args: { + IDENT [36] { + name: @it:0:0 + } + CONSTANT [37] { value: 1 } + } + } + CALL [38] { + function: _>_ + args: { + IDENT [39] { + name: @it2:0:0 + } + CONSTANT [40] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:0:0 + } + } + } + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [43] { + elements: { + CONSTANT [44] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [45] { value: false } + } + loop_condition: { + CALL [46] { + function: @not_strictly_false + args: { + CALL [47] { + function: !_ + args: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [49] { + function: _||_ + args: { + IDENT [50] { + name: @ac:0:0 + } + CALL [51] { + function: _&&_ + args: { + CALL [52] { + function: _>_ + args: { + IDENT [53] { + name: @it:0:0 + } + CONSTANT [54] { value: 1 } + } + } + CALL [55] { + function: _>_ + args: { + IDENT [56] { + name: @it2:0:0 + } + CONSTANT [57] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [58] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + } + } + CALL [11] { + function: _==_ + args: { + COMPREHENSION [12] { + iter_var: @it:1:0 + iter_range: { + IDENT [13] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [14] { + elements: { + } + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @ac:1:0 + } + LIST [18] { + elements: { + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:0:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _+_ + args: { + IDENT [27] { + name: @it:0:0 + } + CONSTANT [28] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:1:0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + IDENT [33] { + name: @index1 + } + IDENT [34] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [31] { + function: _==_ + args: { + COMPREHENSION [30] { + iter_var: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @result + accu_init: { + LIST [24] { + elements: { + } + } + } + loop_condition: { + CONSTANT [25] { value: true } + } + loop_step: { + CALL [28] { + function: _+_ + args: { + IDENT [26] { + name: @result + } + LIST [27] { + elements: { + COMPREHENSION [23] { + iter_var: x + iter_range: { + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + } + } + } + accu_var: @result + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [21] { + function: _?_:_ + args: { + CALL [13] { + function: _==_ + args: { + IDENT [12] { + name: x + } + IDENT [14] { + name: y + } + } + } + CALL [19] { + function: _+_ + args: { + IDENT [17] { + name: @result + } + LIST [18] { + elements: { + IDENT [11] { + name: x + } + } + } + } + } + IDENT [20] { + name: @result + } + } + } + } + result: { + IDENT [22] { + name: @result + } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @result + } + } + } + LIST [32] { + elements: { + LIST [33] { + elements: { + CONSTANT [34] { value: 1 } + } + } + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + } + } + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @index0 + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:1:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _*_ + args: { + IDENT [27] { + name: @it:1:0 + } + CONSTANT [28] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + } + } + CALL [11] { + function: _==_ + args: { + COMPREHENSION [12] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [13] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [14] { + elements: { + } + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @ac:1:0 + } + LIST [18] { + elements: { + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:0:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _+_ + args: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @it:0:0 + } + IDENT [29] { + name: @it2:0:0 + } + } + } + CONSTANT [30] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1:0 + } + } + } + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + IDENT [35] { + name: @index1 + } + IDENT [36] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [36] { + function: _==_ + args: { + COMPREHENSION [35] { + iter_var: i + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + COMPREHENSION [28] { + iter_var: x + iter_range: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + CONSTANT [10] { value: 3 } + } + } + } + accu_var: @result + accu_init: { + LIST [20] { + elements: { + } + } + } + loop_condition: { + CONSTANT [21] { value: true } + } + loop_step: { + CALL [26] { + function: _?_:_ + args: { + CALL [16] { + function: _&&_ + args: { + CALL [14] { + function: _==_ + args: { + IDENT [13] { + name: x + } + IDENT [15] { + name: y + } + } + } + CALL [18] { + function: _<_ + args: { + IDENT [17] { + name: i + } + IDENT [19] { + name: y + } + } + } + } + } + CALL [24] { + function: _+_ + args: { + IDENT [22] { + name: @result + } + LIST [23] { + elements: { + IDENT [12] { + name: x + } + } + } + } + } + IDENT [25] { + name: @result + } + } + } + } + result: { + IDENT [27] { + name: @result + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } + } + LIST [37] { + elements: { + LIST [38] { + elements: { + CONSTANT [39] { value: 1 } + } + } + LIST [40] { + elements: { + CONSTANT [41] { value: 2 } + } + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:1:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:1:0 + } + LIST [12] { + elements: { + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_range: { + LIST [14] { + elements: { + CONSTANT [15] { value: 1 } + CONSTANT [16] { value: 2 } + CONSTANT [17] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:0:0 + } + LIST [22] { + elements: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @it:0:0 + } + CONSTANT [25] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:1:0 + } + } + } + } + } + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @index0 + } + IDENT [30] { + name: @index0 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [8] { + + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: cel.@mapInsert + args: { + IDENT [11] { + name: @ac:1:0 + } + IDENT [12] { + name: @it:1:0 + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [14] { + elements: { + CONSTANT [15] { value: 1 } + CONSTANT [16] { value: 2 } + CONSTANT [17] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [18] { + + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: cel.@mapInsert + args: { + IDENT [21] { + name: @ac:0:0 + } + IDENT [22] { + name: @it:0:0 + } + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @it:0:0 + } + IDENT [26] { + name: @it2:0:0 + } + } + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + CALL [30] { + function: _==_ + args: { + IDENT [31] { + name: @index0 + } + IDENT [32] { + name: @index0 + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: @in + args: { + CONSTANT [4] { value: 1 } + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + CONSTANT [8] { value: 3 } + } + } + } + } + LIST [9] { + elements: { + CONSTANT [10] { value: 1 } + CONSTANT [11] { value: 2 } + CONSTANT [12] { value: 3 } + } + } + } + } + CALL [13] { + function: _&&_ + args: { + CALL [14] { + function: _&&_ + args: { + IDENT [15] { + name: @index0 + } + CALL [16] { + function: @in + args: { + CONSTANT [17] { value: 2 } + IDENT [18] { + name: @index1 + } + } + } + } + } + CALL [19] { + function: _&&_ + args: { + CALL [20] { + function: @in + args: { + CONSTANT [21] { value: 3 } + LIST [22] { + elements: { + CONSTANT [23] { value: 3 } + IDENT [24] { + name: @index1 + } + } + } + } + } + IDENT [25] { + name: @index0 + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + } + } + CALL [13] { + function: _==_ + args: { + COMPREHENSION [14] { + iter_var: @it:1:0 + iter_range: { + IDENT [15] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [16] { + elements: { + } + } + } + loop_condition: { + CONSTANT [17] { value: true } + } + loop_step: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @ac:1:0 + } + LIST [20] { + elements: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + IDENT [22] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [23] { + elements: { + } + } + } + loop_condition: { + CONSTANT [24] { value: true } + } + loop_step: { + CALL [25] { + function: _+_ + args: { + IDENT [26] { + name: @ac:0:0 + } + LIST [27] { + elements: { + LIST [28] { + elements: { + CONSTANT [29] { value: 3 } + CONSTANT [30] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1:0 + } + } + } + LIST [33] { + elements: { + IDENT [34] { + name: @index0 + } + IDENT [35] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + } + } + CALL [13] { + function: _==_ + args: { + COMPREHENSION [14] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [15] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [16] { + elements: { + } + } + } + loop_condition: { + CONSTANT [17] { value: true } + } + loop_step: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @ac:1:0 + } + LIST [20] { + elements: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [22] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [23] { + elements: { + } + } + } + loop_condition: { + CONSTANT [24] { value: true } + } + loop_step: { + CALL [25] { + function: _+_ + args: { + IDENT [26] { + name: @ac:0:0 + } + LIST [27] { + elements: { + LIST [28] { + elements: { + CONSTANT [29] { value: 3 } + CONSTANT [30] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1:0 + } + } + } + LIST [33] { + elements: { + IDENT [34] { + name: @index0 + } + IDENT [35] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + CONSTANT [6] { value: 1 } + } + } + CONSTANT [7] { value: 3 } + } + } + } + } + CALL [8] { + function: _||_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_range: { + LIST [10] { + elements: { + CALL [11] { + function: _?_:_ + args: { + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _-_ + args: { + IDENT [14] { + name: x + } + CONSTANT [15] { value: 1 } + } + } + CONSTANT [16] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [17] { value: false } + } + loop_condition: { + CALL [18] { + function: @not_strictly_false + args: { + CALL [19] { + function: !_ + args: { + IDENT [20] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [21] { + function: _||_ + args: { + IDENT [22] { + name: @ac:0:0 + } + CALL [23] { + function: _>_ + args: { + CALL [24] { + function: _-_ + args: { + IDENT [25] { + name: @it:0:0 + } + CONSTANT [26] { value: 1 } + } + } + CONSTANT [27] { value: 3 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + IDENT [29] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [15] { + name: @result + } + LIST [16] { + elements: { + LIST [6] { + elements: { + CALL [8] { + function: _+_ + args: { + IDENT [7] { + name: x + } + IDENT [9] { + name: x + } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [10] { + name: x + } + IDENT [12] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + LIST [22] { + elements: { + CALL [24] { + function: _+_ + args: { + IDENT [23] { + name: x + } + IDENT [25] { + name: x + } + } + } + CALL [27] { + function: _+_ + args: { + IDENT [26] { + name: x + } + IDENT [28] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + CALL [5] { + function: _-_ + args: { + IDENT [6] { + name: x + } + IDENT [7] { + name: y + } + } + } + CONSTANT [8] { value: 1 } + } + } + CONSTANT [9] { value: 3 } + } + } + } + } + CALL [10] { + function: _||_ + args: { + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [12] { + elements: { + CALL [13] { + function: _?_:_ + args: { + IDENT [14] { + name: @index0 + } + CALL [15] { + function: _-_ + args: { + CALL [16] { + function: _-_ + args: { + IDENT [17] { + name: x + } + IDENT [18] { + name: y + } + } + } + CONSTANT [19] { value: 1 } + } + } + CONSTANT [20] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [21] { value: false } + } + loop_condition: { + CALL [22] { + function: @not_strictly_false + args: { + CALL [23] { + function: !_ + args: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [25] { + function: _||_ + args: { + IDENT [26] { + name: @ac:0:0 + } + CALL [27] { + function: _>_ + args: { + CALL [28] { + function: _-_ + args: { + CALL [29] { + function: _-_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:0:0 + } + } + } + CONSTANT [32] { value: 1 } + } + } + CONSTANT [33] { value: 3 } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:0:0 + } + } + } + IDENT [35] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_var2: y + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + MAP [14] { + + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [17] { + function: cel.@mapInsert + args: { + IDENT [16] { + name: @result + } + IDENT [5] { + name: x + } + LIST [7] { + elements: { + CALL [9] { + function: _+_ + args: { + IDENT [8] { + name: x + } + IDENT [10] { + name: x + } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [11] { + name: y + } + IDENT [13] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + MAP [30] { + + } + } + loop_condition: { + CONSTANT [31] { value: true } + } + loop_step: { + CALL [33] { + function: cel.@mapInsert + args: { + IDENT [32] { + name: @result + } + IDENT [21] { + name: x + } + LIST [23] { + elements: { + CALL [25] { + function: _+_ + args: { + IDENT [24] { + name: x + } + IDENT [26] { + name: x + } + } + } + CALL [28] { + function: _+_ + args: { + IDENT [27] { + name: y + } + IDENT [29] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.payload~presence_test + } + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload + }.single_int64 + } + CONSTANT [12] { value: 0 } + } + } + CONSTANT [13] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: msg + }.oneof_type + }.payload~presence_test + } + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + SELECT [11] { + IDENT [12] { + name: msg + }.oneof_type + }.payload + }.single_int64~presence_test + } + IDENT [13] { + name: @index0 + } + CALL [14] { + function: _*_ + args: { + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 0 } + } + } + } + } + CONSTANT [17] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_string_string + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + } + } + CALL [10] { + function: _?_:_ + args: { + CALL [11] { + function: _&&_ + args: { + CALL [12] { + function: _&&_ + args: { + SELECT [13] { + IDENT [14] { + name: msg + }.oneof_type~presence_test + } + SELECT [15] { + SELECT [16] { + IDENT [17] { + name: msg + }.oneof_type + }.payload~presence_test + } + } + } + SELECT [18] { + IDENT [19] { + name: @index1 + }.single_int64~presence_test + } + } + } + CALL [20] { + function: _?_:_ + args: { + CALL [21] { + function: _&&_ + args: { + SELECT [22] { + IDENT [23] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [24] { + IDENT [25] { + name: @index0 + }.key~presence_test + } + } + } + CALL [26] { + function: _==_ + args: { + SELECT [27] { + IDENT [28] { + name: @index0 + }.key + } + CONSTANT [29] { value: "A" } + } + } + CONSTANT [30] { value: false } + } + } + CONSTANT [31] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CALL [4] { + function: optional.none + args: { + } + } + IDENT [5] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [6] { + elements: { + CONSTANT [7] { value: 5 } + } + } + } + } + CALL [8] { + function: _==_ + args: { + LIST [9] { + elements: { + CONSTANT [10] { value: 10 } + CALL [11] { + function: optional.none + args: { + } + } + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + optional_indices: [0] + } + LIST [14] { + elements: { + CONSTANT [15] { value: 10 } + IDENT [16] { + name: @index1 + } + IDENT [17] { + name: @index1 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "hello" } + } + optional_entry: true + value: { + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "hello" } + } + } + } + } + } + CONSTANT [9] { value: "hello" } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: orValue + target: { + CALL [9] { + function: or + target: { + CALL [10] { + function: _[?_] + args: { + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "key" } + } + optional_entry: true + value: { + CALL [14] { + function: optional.of + args: { + CONSTANT [15] { value: "test" } + } + } + } + } + } + CONSTANT [16] { value: "bogus" } + } + } + } + args: { + CALL [17] { + function: _[?_] + args: { + IDENT [18] { + name: @index0 + } + CONSTANT [19] { value: "bogus" } + } + } + } + } + } + args: { + CALL [20] { + function: _[_] + args: { + IDENT [21] { + name: @index0 + } + CONSTANT [22] { value: "key" } + } + } + } + } + CONSTANT [23] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int64 + } + } + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + IDENT [16] { + name: @index0 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [2] { + function: matches + target: { + CONSTANT [1] { value: "hello world" } + } + args: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [3] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CONSTANT [13] { value: "hello" } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CALL [20] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CONSTANT [13] { value: "w" } + CONSTANT [15] { value: "o" } + } + } + CONSTANT [17] { value: "r" } + } + } + CONSTANT [19] { value: "l" } + } + } + CONSTANT [21] { value: "d" } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: non_pure_custom_func + args: { + IDENT [11] { + name: @index0 + } + } + } + CALL [12] { + function: non_pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + CALL [17] { + function: non_pure_custom_func + args: { + IDENT [18] { + name: @index0 + } + } + } + } + } + CALL [19] { + function: non_pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: pure_custom_func + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + IDENT [17] { + name: @index0 + } + } + } + CALL [18] { + function: pure_custom_func + args: { + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_9.baseline b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_9.baseline new file mode 100644 index 000000000..c2d7334af --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_block_recursion_depth_9.baseline @@ -0,0 +1,4802 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + IDENT [11] { + name: @index0 + } + } + } + CONSTANT [12] { value: 1 } + } + } + CONSTANT [13] { value: 5 } + } + } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + CONSTANT [11] { value: 2 } + IDENT [12] { + name: @index0 + } + } + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 7 } + } + } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + IDENT [15] { + name: @index0 + } + } + } + IDENT [16] { + name: @index1 + } + } + } + IDENT [17] { + name: @index1 + } + } + } + CONSTANT [18] { value: 6 } + } + } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: size + args: { + LIST [4] { + elements: { + CONSTANT [5] { value: 0 } + } + } + } + } + CALL [6] { + function: size + args: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + } + } + } + } + CALL [10] { + function: size + args: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + CONSTANT [14] { value: 3 } + } + } + } + } + } + } + CALL [15] { + function: _==_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [19] { + function: _+_ + args: { + CALL [20] { + function: _+_ + args: { + CALL [21] { + function: _+_ + args: { + CONSTANT [22] { value: 5 } + IDENT [23] { + name: @index0 + } + } + } + IDENT [24] { + name: @index0 + } + } + } + IDENT [25] { + name: @index1 + } + } + } + IDENT [26] { + name: @index1 + } + } + } + IDENT [27] { + name: @index2 + } + } + } + IDENT [28] { + name: @index2 + } + } + } + CONSTANT [29] { value: 17 } + } + } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: getFullYear + target: { + CALL [4] { + function: timestamp + args: { + CALL [5] { + function: int + args: { + CALL [6] { + function: timestamp + args: { + CONSTANT [7] { value: 1000000000 } + } + } + } + } + } + } + } + args: { + } + } + CALL [8] { + function: getFullYear + target: { + CALL [9] { + function: timestamp + args: { + CALL [10] { + function: int + args: { + CALL [11] { + function: timestamp + args: { + CONSTANT [12] { value: 200 } + } + } + } + } + } + } + } + args: { + } + } + CALL [13] { + function: timestamp + args: { + CALL [14] { + function: int + args: { + CALL [15] { + function: timestamp + args: { + CONSTANT [16] { value: 50 } + } + } + } + } + } + } + CALL [17] { + function: timestamp + args: { + CALL [18] { + function: int + args: { + CALL [19] { + function: timestamp + args: { + CONSTANT [20] { value: 75 } + } + } + } + } + } + } + CALL [21] { + function: _+_ + args: { + CALL [22] { + function: _+_ + args: { + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + CALL [25] { + function: _+_ + args: { + CALL [26] { + function: _+_ + args: { + CALL [27] { + function: _+_ + args: { + CALL [28] { + function: _+_ + args: { + IDENT [29] { + name: @index0 + } + CALL [30] { + function: getFullYear + target: { + IDENT [31] { + name: @index3 + } + } + args: { + } + } + } + } + CALL [32] { + function: getFullYear + target: { + IDENT [33] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [34] { + name: @index0 + } + } + } + CALL [35] { + function: getSeconds + target: { + IDENT [36] { + name: @index2 + } + } + args: { + } + } + } + } + IDENT [37] { + name: @index1 + } + } + } + IDENT [38] { + name: @index1 + } + } + } + CALL [39] { + function: getMinutes + target: { + IDENT [40] { + name: @index3 + } + } + args: { + } + } + } + } + IDENT [41] { + name: @index0 + } + } + } + } + } + CALL [42] { + function: _==_ + args: { + IDENT [43] { + name: @index4 + } + CONSTANT [44] { value: 13934 } + } + } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: 2 } + } + } + } + CONSTANT [8] { value: "a" } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: _*_ + args: { + IDENT [13] { + name: @index0 + } + IDENT [14] { + name: @index0 + } + } + } + } + } + CONSTANT [15] { value: 6 } + } + } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "e" } + } + value: { + MAP [6] { + MAP_ENTRY [7] { + key: { + CONSTANT [8] { value: "b" } + } + value: { + CONSTANT [9] { value: 1 } + } + } + } + } + } + } + MAP [10] { + MAP_ENTRY [11] { + key: { + CONSTANT [12] { value: "b" } + } + value: { + CONSTANT [13] { value: 1 } + } + } + } + } + } + MAP [14] { + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: "a" } + } + value: { + IDENT [17] { + name: @index1 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "c" } + } + value: { + IDENT [20] { + name: @index1 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "d" } + } + value: { + IDENT [23] { + name: @index0 + } + } + } + MAP_ENTRY [24] { + key: { + CONSTANT [25] { value: "e" } + } + value: { + IDENT [26] { + name: @index0 + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + LIST [8] { + elements: { + CONSTANT [9] { value: 1 } + CONSTANT [10] { value: 2 } + } + } + } + } + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 2 } + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 5 } + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 7 } + LIST [19] { + elements: { + IDENT [20] { + name: @index1 + } + IDENT [21] { + name: @index0 + } + } + } + IDENT [22] { + name: @index1 + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _+_ + args: { + IDENT [7] { + name: @index0 + } + IDENT [8] { + name: @index0 + } + } + } + CONSTANT [9] { value: 6 } + } + } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @index0 + } + SELECT [16] { + IDENT [17] { + name: @index1 + }.single_int32 + } + } + } + IDENT [18] { + name: @index0 + } + } + } + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + SELECT [21] { + SELECT [22] { + SELECT [23] { + IDENT [24] { + name: @index1 + }.oneof_type + }.payload + }.single_int64 + } + } + } + CONSTANT [25] { value: 31 } + } + } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + } + } + CALL [9] { + function: _||_ + args: { + CALL [10] { + function: _||_ + args: { + CONSTANT [11] { value: true } + SELECT [12] { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: @index0 + }.payload + }.oneof_type + }.payload + }.single_bool + } + } + } + SELECT [17] { + SELECT [18] { + SELECT [19] { + SELECT [20] { + IDENT [21] { + name: @index0 + }.child + }.child + }.payload + }.single_bool + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CONSTANT [8] { value: 1 } + } + } + } + } + CALL [9] { + function: _==_ + args: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + IDENT [14] { + name: @index0 + } + } + } + CONSTANT [15] { value: 15 } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: 0 } + } + } + CALL [13] { + function: _[_] + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 1 } + } + } + } + } + CALL [16] { + function: _[_] + args: { + IDENT [17] { + name: @index0 + } + CONSTANT [18] { value: 2 } + } + } + } + } + CONSTANT [19] { value: 8 } + } + } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +SELECT [10] { + SELECT [9] { + SELECT [8] { + SELECT [7] { + SELECT [6] { + SELECT [5] { + SELECT [4] { + SELECT [3] { + SELECT [2] { + IDENT [1] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.single_int64 +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + CALL [7] { + function: _>_ + args: { + IDENT [8] { + name: @index0 + } + CONSTANT [9] { value: 0 } + } + } + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CONSTANT [12] { value: 3 } + } + } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + } + } + CALL [5] { + function: _?_:_ + args: { + CONSTANT [6] { value: false } + CONSTANT [7] { value: false } + CALL [8] { + function: _==_ + args: { + CALL [9] { + function: _+_ + args: { + IDENT [10] { + name: @index0 + } + CALL [11] { + function: _*_ + args: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @index0 + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 2 } + } + } + } + } + CONSTANT [16] { value: 11 } + } + } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.single_int64 + } + SELECT [5] { + IDENT [6] { + name: msg + }.single_int32 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @index0 + } + CONSTANT [11] { value: 0 } + } + } + CALL [12] { + function: _?_:_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @index1 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @index0 + } + IDENT [18] { + name: @index1 + } + } + } + CONSTANT [19] { value: 0 } + } + } + CONSTANT [20] { value: 0 } + } + } + CONSTANT [21] { value: 8 } + } + } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:0 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:0 + } + CALL [25] { + function: _>_ + args: { + IDENT [26] { + name: @it:0:0 + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + CALL [29] { + function: size + args: { + LIST [30] { + elements: { + IDENT [31] { + name: @index0 + } + } + } + } + } + CALL [32] { + function: size + args: { + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + } + } + } + } + } + } + CALL [35] { + function: _==_ + args: { + CALL [36] { + function: _+_ + args: { + CALL [37] { + function: _+_ + args: { + CALL [38] { + function: _+_ + args: { + IDENT [39] { + name: @index2 + } + IDENT [40] { + name: @index2 + } + } + } + IDENT [41] { + name: @index3 + } + } + } + IDENT [42] { + name: @index3 + } + } + } + CONSTANT [43] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + COMPREHENSION [16] { + iter_var: @it:0:1 + iter_range: { + LIST [17] { + elements: { + CONSTANT [18] { value: "a" } + } + } + } + accu_var: @ac:0:1 + accu_init: { + CONSTANT [19] { value: false } + } + loop_condition: { + CALL [20] { + function: @not_strictly_false + args: { + CALL [21] { + function: !_ + args: { + IDENT [22] { + name: @ac:0:1 + } + } + } + } + } + } + loop_step: { + CALL [23] { + function: _||_ + args: { + IDENT [24] { + name: @ac:0:1 + } + CALL [25] { + function: _==_ + args: { + IDENT [26] { + name: @it:0:1 + } + CONSTANT [27] { value: "a" } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:1 + } + } + } + LIST [29] { + elements: { + IDENT [30] { + name: @index0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + } + } + } + } + CALL [33] { + function: _==_ + args: { + CALL [34] { + function: _+_ + args: { + CALL [35] { + function: _+_ + args: { + CALL [36] { + function: _+_ + args: { + IDENT [37] { + name: @index2 + } + IDENT [38] { + name: @index2 + } + } + } + IDENT [39] { + name: @index3 + } + } + } + IDENT [40] { + name: @index3 + } + } + } + LIST [41] { + elements: { + CONSTANT [42] { value: true } + CONSTANT [43] { value: true } + CONSTANT [44] { value: true } + CONSTANT [45] { value: true } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _>_ + args: { + IDENT [13] { + name: @it:0:0 + } + CONSTANT [14] { value: 0 } + } + } + } + } + } + result: { + IDENT [15] { + name: @ac:0:0 + } + } + } + } + } + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @index0 + } + IDENT [19] { + name: @index0 + } + } + } + CALL [20] { + function: _&&_ + args: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + LIST [22] { + elements: { + CONSTANT [23] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [24] { value: false } + } + loop_condition: { + CALL [25] { + function: @not_strictly_false + args: { + CALL [26] { + function: !_ + args: { + IDENT [27] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [28] { + function: _||_ + args: { + IDENT [29] { + name: @ac:0:0 + } + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0:0 + } + } + } + COMPREHENSION [34] { + iter_var: @it:0:0 + iter_range: { + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [37] { value: false } + } + loop_condition: { + CALL [38] { + function: @not_strictly_false + args: { + CALL [39] { + function: !_ + args: { + IDENT [40] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [41] { + function: _||_ + args: { + IDENT [42] { + name: @ac:0:0 + } + CALL [43] { + function: _>_ + args: { + IDENT [44] { + name: @it:0:0 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>=_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + COMPREHENSION [20] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [21] { + elements: { + CONSTANT [22] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:0:0 + } + CALL [29] { + function: _&&_ + args: { + CALL [30] { + function: _>_ + args: { + IDENT [31] { + name: @it:0:0 + } + CONSTANT [32] { value: 1 } + } + } + CALL [33] { + function: _>=_ + args: { + IDENT [34] { + name: @it2:0:0 + } + CONSTANT [35] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [36] { + name: @ac:0:0 + } + } + } + CALL [37] { + function: size + args: { + LIST [38] { + elements: { + IDENT [39] { + name: @index0 + } + } + } + } + } + CALL [40] { + function: size + args: { + LIST [41] { + elements: { + IDENT [42] { + name: @index1 + } + } + } + } + } + } + } + CALL [43] { + function: _==_ + args: { + CALL [44] { + function: _+_ + args: { + CALL [45] { + function: _+_ + args: { + CALL [46] { + function: _+_ + args: { + IDENT [47] { + name: @index2 + } + IDENT [48] { + name: @index2 + } + } + } + IDENT [49] { + name: @index3 + } + } + } + IDENT [50] { + name: @index3 + } + } + } + CONSTANT [51] { value: 4 } + } + } + } +} +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [6] { value: false } + } + loop_condition: { + CALL [7] { + function: @not_strictly_false + args: { + CALL [8] { + function: !_ + args: { + IDENT [9] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [10] { + function: _||_ + args: { + IDENT [11] { + name: @ac:0:0 + } + CALL [12] { + function: _&&_ + args: { + CALL [13] { + function: _>_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 0 } + } + } + CALL [16] { + function: _>_ + args: { + IDENT [17] { + name: @it2:0:0 + } + CONSTANT [18] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [19] { + name: @ac:0:0 + } + } + } + } + } + CALL [20] { + function: _&&_ + args: { + CALL [21] { + function: _&&_ + args: { + IDENT [22] { + name: @index0 + } + IDENT [23] { + name: @index0 + } + } + } + CALL [24] { + function: _&&_ + args: { + COMPREHENSION [25] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [26] { + elements: { + CONSTANT [27] { value: 1 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [28] { value: false } + } + loop_condition: { + CALL [29] { + function: @not_strictly_false + args: { + CALL [30] { + function: !_ + args: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [32] { + function: _||_ + args: { + IDENT [33] { + name: @ac:0:0 + } + CALL [34] { + function: _&&_ + args: { + CALL [35] { + function: _>_ + args: { + IDENT [36] { + name: @it:0:0 + } + CONSTANT [37] { value: 1 } + } + } + CALL [38] { + function: _>_ + args: { + IDENT [39] { + name: @it2:0:0 + } + CONSTANT [40] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [41] { + name: @ac:0:0 + } + } + } + COMPREHENSION [42] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [43] { + elements: { + CONSTANT [44] { value: 2 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [45] { value: false } + } + loop_condition: { + CALL [46] { + function: @not_strictly_false + args: { + CALL [47] { + function: !_ + args: { + IDENT [48] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [49] { + function: _||_ + args: { + IDENT [50] { + name: @ac:0:0 + } + CALL [51] { + function: _&&_ + args: { + CALL [52] { + function: _>_ + args: { + IDENT [53] { + name: @it:0:0 + } + CONSTANT [54] { value: 1 } + } + } + CALL [55] { + function: _>_ + args: { + IDENT [56] { + name: @it2:0:0 + } + CONSTANT [57] { value: 0 } + } + } + } + } + } + } + } + result: { + IDENT [58] { + name: @ac:0:0 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + CONSTANT [10] { value: 4 } + } + } + } + } + CALL [11] { + function: _==_ + args: { + COMPREHENSION [12] { + iter_var: @it:1:0 + iter_range: { + IDENT [13] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [14] { + elements: { + } + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @ac:1:0 + } + LIST [18] { + elements: { + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:0:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _+_ + args: { + IDENT [27] { + name: @it:0:0 + } + CONSTANT [28] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:1:0 + } + } + } + LIST [31] { + elements: { + IDENT [32] { + name: @index1 + } + IDENT [33] { + name: @index1 + } + IDENT [34] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [31] { + function: _==_ + args: { + COMPREHENSION [30] { + iter_var: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @result + accu_init: { + LIST [24] { + elements: { + } + } + } + loop_condition: { + CONSTANT [25] { value: true } + } + loop_step: { + CALL [28] { + function: _+_ + args: { + IDENT [26] { + name: @result + } + LIST [27] { + elements: { + COMPREHENSION [23] { + iter_var: x + iter_range: { + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + } + } + } + accu_var: @result + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [21] { + function: _?_:_ + args: { + CALL [13] { + function: _==_ + args: { + IDENT [12] { + name: x + } + IDENT [14] { + name: y + } + } + } + CALL [19] { + function: _+_ + args: { + IDENT [17] { + name: @result + } + LIST [18] { + elements: { + IDENT [11] { + name: x + } + } + } + } + } + IDENT [20] { + name: @result + } + } + } + } + result: { + IDENT [22] { + name: @result + } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @result + } + } + } + LIST [32] { + elements: { + LIST [33] { + elements: { + CONSTANT [34] { value: 1 } + } + } + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + } + } +} +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:0:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:0:0 + } + LIST [12] { + elements: { + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @it:0:0 + } + CONSTANT [15] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [16] { + name: @ac:0:0 + } + } + } + } + } + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @index0 + } + COMPREHENSION [19] { + iter_var: @it:1:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:1:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _*_ + args: { + IDENT [27] { + name: @it:1:0 + } + CONSTANT [28] { value: 2 } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 4 } + CONSTANT [10] { value: 6 } + } + } + } + } + CALL [11] { + function: _==_ + args: { + COMPREHENSION [12] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [13] { + name: @index0 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [14] { + elements: { + } + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [16] { + function: _+_ + args: { + IDENT [17] { + name: @ac:1:0 + } + LIST [18] { + elements: { + COMPREHENSION [19] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [20] { + name: @index0 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [21] { + elements: { + } + } + } + loop_condition: { + CONSTANT [22] { value: true } + } + loop_step: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @ac:0:0 + } + LIST [25] { + elements: { + CALL [26] { + function: _+_ + args: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @it:0:0 + } + IDENT [29] { + name: @it2:0:0 + } + } + } + CONSTANT [30] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1:0 + } + } + } + LIST [33] { + elements: { + IDENT [34] { + name: @index1 + } + IDENT [35] { + name: @index1 + } + IDENT [36] { + name: @index1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +CALL [36] { + function: _==_ + args: { + COMPREHENSION [35] { + iter_var: i + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + COMPREHENSION [28] { + iter_var: x + iter_range: { + LIST [7] { + elements: { + CONSTANT [8] { value: 1 } + CONSTANT [9] { value: 2 } + CONSTANT [10] { value: 3 } + } + } + } + accu_var: @result + accu_init: { + LIST [20] { + elements: { + } + } + } + loop_condition: { + CONSTANT [21] { value: true } + } + loop_step: { + CALL [26] { + function: _?_:_ + args: { + CALL [16] { + function: _&&_ + args: { + CALL [14] { + function: _==_ + args: { + IDENT [13] { + name: x + } + IDENT [15] { + name: y + } + } + } + CALL [18] { + function: _<_ + args: { + IDENT [17] { + name: i + } + IDENT [19] { + name: y + } + } + } + } + } + CALL [24] { + function: _+_ + args: { + IDENT [22] { + name: @result + } + LIST [23] { + elements: { + IDENT [12] { + name: x + } + } + } + } + } + IDENT [25] { + name: @result + } + } + } + } + result: { + IDENT [27] { + name: @result + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } + } + LIST [37] { + elements: { + LIST [38] { + elements: { + CONSTANT [39] { value: 1 } + } + } + LIST [40] { + elements: { + CONSTANT [41] { value: 2 } + } + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:1:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [8] { + elements: { + } + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @ac:1:0 + } + LIST [12] { + elements: { + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_range: { + LIST [14] { + elements: { + CONSTANT [15] { value: 1 } + CONSTANT [16] { value: 2 } + CONSTANT [17] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:0:0 + } + LIST [22] { + elements: { + CALL [23] { + function: _+_ + args: { + IDENT [24] { + name: @it:0:0 + } + CONSTANT [25] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [26] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:1:0 + } + } + } + } + } + CALL [28] { + function: _==_ + args: { + IDENT [29] { + name: @index0 + } + IDENT [30] { + name: @index0 + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + COMPREHENSION [3] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + accu_var: @ac:1:0 + accu_init: { + MAP [8] { + + } + } + loop_condition: { + CONSTANT [9] { value: true } + } + loop_step: { + CALL [10] { + function: cel.@mapInsert + args: { + IDENT [11] { + name: @ac:1:0 + } + IDENT [12] { + name: @it:1:0 + } + COMPREHENSION [13] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [14] { + elements: { + CONSTANT [15] { value: 1 } + CONSTANT [16] { value: 2 } + CONSTANT [17] { value: 3 } + } + } + } + accu_var: @ac:0:0 + accu_init: { + MAP [18] { + + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: cel.@mapInsert + args: { + IDENT [21] { + name: @ac:0:0 + } + IDENT [22] { + name: @it:0:0 + } + CALL [23] { + function: _+_ + args: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @it:0:0 + } + IDENT [26] { + name: @it2:0:0 + } + } + } + CONSTANT [27] { value: 1 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:1:0 + } + } + } + } + } + CALL [30] { + function: _==_ + args: { + IDENT [31] { + name: @index0 + } + IDENT [32] { + name: @index0 + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: @in + args: { + CONSTANT [4] { value: 1 } + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + CONSTANT [8] { value: 3 } + } + } + } + } + LIST [9] { + elements: { + CONSTANT [10] { value: 1 } + CONSTANT [11] { value: 2 } + CONSTANT [12] { value: 3 } + } + } + } + } + CALL [13] { + function: _&&_ + args: { + CALL [14] { + function: _&&_ + args: { + IDENT [15] { + name: @index0 + } + CALL [16] { + function: @in + args: { + CONSTANT [17] { value: 2 } + IDENT [18] { + name: @index1 + } + } + } + } + } + CALL [19] { + function: _&&_ + args: { + CALL [20] { + function: @in + args: { + CONSTANT [21] { value: 3 } + LIST [22] { + elements: { + CONSTANT [23] { value: 3 } + IDENT [24] { + name: @index1 + } + } + } + } + } + IDENT [25] { + name: @index0 + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: true } + } + value: { + CONSTANT [6] { value: false } + } + } + } + } + } + CALL [7] { + function: @in + args: { + CONSTANT [8] { value: 2 } + MAP [9] { + MAP_ENTRY [10] { + key: { + CONSTANT [11] { value: "a" } + } + value: { + CONSTANT [12] { value: 1 } + } + } + MAP_ENTRY [13] { + key: { + CONSTANT [14] { value: 2 } + } + value: { + IDENT [15] { + name: @index0 + } + } + } + MAP_ENTRY [16] { + key: { + CONSTANT [17] { value: 3 } + } + value: { + IDENT [18] { + name: @index0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + } + } + CALL [13] { + function: _==_ + args: { + COMPREHENSION [14] { + iter_var: @it:1:0 + iter_range: { + IDENT [15] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [16] { + elements: { + } + } + } + loop_condition: { + CONSTANT [17] { value: true } + } + loop_step: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @ac:1:0 + } + LIST [20] { + elements: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_range: { + IDENT [22] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [23] { + elements: { + } + } + } + loop_condition: { + CONSTANT [24] { value: true } + } + loop_step: { + CALL [25] { + function: _+_ + args: { + IDENT [26] { + name: @ac:0:0 + } + LIST [27] { + elements: { + LIST [28] { + elements: { + CONSTANT [29] { value: 3 } + CONSTANT [30] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1:0 + } + } + } + LIST [33] { + elements: { + IDENT [34] { + name: @index0 + } + IDENT [35] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + LIST [4] { + elements: { + CONSTANT [5] { value: 3 } + CONSTANT [6] { value: 4 } + } + } + LIST [7] { + elements: { + CONSTANT [8] { value: 3 } + CONSTANT [9] { value: 4 } + } + } + } + } + LIST [10] { + elements: { + CONSTANT [11] { value: 1 } + CONSTANT [12] { value: 2 } + } + } + } + } + CALL [13] { + function: _==_ + args: { + COMPREHENSION [14] { + iter_var: @it:1:0 + iter_var2: @it2:1:0 + iter_range: { + IDENT [15] { + name: @index1 + } + } + accu_var: @ac:1:0 + accu_init: { + LIST [16] { + elements: { + } + } + } + loop_condition: { + CONSTANT [17] { value: true } + } + loop_step: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @ac:1:0 + } + LIST [20] { + elements: { + COMPREHENSION [21] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + IDENT [22] { + name: @index1 + } + } + accu_var: @ac:0:0 + accu_init: { + LIST [23] { + elements: { + } + } + } + loop_condition: { + CONSTANT [24] { value: true } + } + loop_step: { + CALL [25] { + function: _+_ + args: { + IDENT [26] { + name: @ac:0:0 + } + LIST [27] { + elements: { + LIST [28] { + elements: { + CONSTANT [29] { value: 3 } + CONSTANT [30] { value: 4 } + } + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1:0 + } + } + } + LIST [33] { + elements: { + IDENT [34] { + name: @index0 + } + IDENT [35] { + name: @index0 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + IDENT [5] { + name: x + } + CONSTANT [6] { value: 1 } + } + } + CONSTANT [7] { value: 3 } + } + } + } + } + CALL [8] { + function: _||_ + args: { + COMPREHENSION [9] { + iter_var: @it:0:0 + iter_range: { + LIST [10] { + elements: { + CALL [11] { + function: _?_:_ + args: { + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _-_ + args: { + IDENT [14] { + name: x + } + CONSTANT [15] { value: 1 } + } + } + CONSTANT [16] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [17] { value: false } + } + loop_condition: { + CALL [18] { + function: @not_strictly_false + args: { + CALL [19] { + function: !_ + args: { + IDENT [20] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [21] { + function: _||_ + args: { + IDENT [22] { + name: @ac:0:0 + } + CALL [23] { + function: _>_ + args: { + CALL [24] { + function: _-_ + args: { + IDENT [25] { + name: @it:0:0 + } + CONSTANT [26] { value: 1 } + } + } + CONSTANT [27] { value: 3 } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:0:0 + } + } + } + IDENT [29] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [15] { + name: @result + } + LIST [16] { + elements: { + LIST [6] { + elements: { + CALL [8] { + function: _+_ + args: { + IDENT [7] { + name: x + } + IDENT [9] { + name: x + } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [10] { + name: x + } + IDENT [12] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + LIST [22] { + elements: { + CALL [24] { + function: _+_ + args: { + IDENT [23] { + name: x + } + IDENT [25] { + name: x + } + } + } + CALL [27] { + function: _+_ + args: { + IDENT [26] { + name: x + } + IDENT [28] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _>_ + args: { + CALL [4] { + function: _-_ + args: { + CALL [5] { + function: _-_ + args: { + IDENT [6] { + name: x + } + IDENT [7] { + name: y + } + } + } + CONSTANT [8] { value: 1 } + } + } + CONSTANT [9] { value: 3 } + } + } + } + } + CALL [10] { + function: _||_ + args: { + COMPREHENSION [11] { + iter_var: @it:0:0 + iter_var2: @it2:0:0 + iter_range: { + LIST [12] { + elements: { + CALL [13] { + function: _?_:_ + args: { + IDENT [14] { + name: @index0 + } + CALL [15] { + function: _-_ + args: { + CALL [16] { + function: _-_ + args: { + IDENT [17] { + name: x + } + IDENT [18] { + name: y + } + } + } + CONSTANT [19] { value: 1 } + } + } + CONSTANT [20] { value: 5 } + } + } + } + } + } + accu_var: @ac:0:0 + accu_init: { + CONSTANT [21] { value: false } + } + loop_condition: { + CALL [22] { + function: @not_strictly_false + args: { + CALL [23] { + function: !_ + args: { + IDENT [24] { + name: @ac:0:0 + } + } + } + } + } + } + loop_step: { + CALL [25] { + function: _||_ + args: { + IDENT [26] { + name: @ac:0:0 + } + CALL [27] { + function: _>_ + args: { + CALL [28] { + function: _-_ + args: { + CALL [29] { + function: _-_ + args: { + IDENT [30] { + name: @it:0:0 + } + IDENT [31] { + name: @it2:0:0 + } + } + } + CONSTANT [32] { value: 1 } + } + } + CONSTANT [33] { value: 3 } + } + } + } + } + } + result: { + IDENT [34] { + name: @ac:0:0 + } + } + } + IDENT [35] { + name: @index0 + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_var2: y + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_var2: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + MAP [14] { + + } + } + loop_condition: { + CONSTANT [15] { value: true } + } + loop_step: { + CALL [17] { + function: cel.@mapInsert + args: { + IDENT [16] { + name: @result + } + IDENT [5] { + name: x + } + LIST [7] { + elements: { + CALL [9] { + function: _+_ + args: { + IDENT [8] { + name: x + } + IDENT [10] { + name: x + } + } + } + CALL [12] { + function: _+_ + args: { + IDENT [11] { + name: y + } + IDENT [13] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + MAP [30] { + + } + } + loop_condition: { + CONSTANT [31] { value: true } + } + loop_step: { + CALL [33] { + function: cel.@mapInsert + args: { + IDENT [32] { + name: @result + } + IDENT [21] { + name: x + } + LIST [23] { + elements: { + CALL [25] { + function: _+_ + args: { + IDENT [24] { + name: x + } + IDENT [26] { + name: x + } + } + } + CALL [28] { + function: _+_ + args: { + IDENT [27] { + name: y + } + IDENT [29] { + name: y + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + } + CALL [7] { + function: _&&_ + args: { + SELECT [8] { + IDENT [9] { + name: @index0 + }.a~presence_test + } + CALL [10] { + function: _[_] + args: { + IDENT [11] { + name: @index0 + } + CONSTANT [12] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + } + CALL [8] { + function: _&&_ + args: { + IDENT [9] { + name: @index0 + } + IDENT [10] { + name: @index0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + } + } + CALL [5] { + function: _==_ + args: { + CALL [6] { + function: _?_:_ + args: { + SELECT [7] { + IDENT [8] { + name: @index0 + }.payload~presence_test + } + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: @index0 + }.payload + }.single_int64 + } + CONSTANT [12] { value: 0 } + } + } + CONSTANT [13] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + IDENT [11] { + name: msg + }.oneof_type + }.payload~presence_test + } + IDENT [12] { + name: @index0 + } + CALL [13] { + function: _*_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: 0 } + } + } + } + } + CONSTANT [16] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + SELECT [10] { + SELECT [11] { + IDENT [12] { + name: msg + }.oneof_type + }.payload + }.single_int64~presence_test + } + IDENT [13] { + name: @index0 + } + CALL [14] { + function: _*_ + args: { + IDENT [15] { + name: @index0 + } + CONSTANT [16] { value: 0 } + } + } + } + } + CONSTANT [17] { value: 10 } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.map_string_string + } + SELECT [7] { + SELECT [8] { + IDENT [9] { + name: msg + }.oneof_type + }.payload + } + } + } + CALL [10] { + function: _?_:_ + args: { + CALL [11] { + function: _&&_ + args: { + CALL [12] { + function: _&&_ + args: { + SELECT [13] { + IDENT [14] { + name: msg + }.oneof_type~presence_test + } + SELECT [15] { + SELECT [16] { + IDENT [17] { + name: msg + }.oneof_type + }.payload~presence_test + } + } + } + SELECT [18] { + IDENT [19] { + name: @index1 + }.single_int64~presence_test + } + } + } + CALL [20] { + function: _?_:_ + args: { + CALL [21] { + function: _&&_ + args: { + SELECT [22] { + IDENT [23] { + name: @index1 + }.map_string_string~presence_test + } + SELECT [24] { + IDENT [25] { + name: @index0 + }.key~presence_test + } + } + } + CALL [26] { + function: _==_ + args: { + SELECT [27] { + IDENT [28] { + name: @index0 + }.key + } + CONSTANT [29] { value: "A" } + } + } + CONSTANT [30] { value: false } + } + } + CONSTANT [31] { value: false } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + LIST [3] { + elements: { + CALL [4] { + function: optional.none + args: { + } + } + IDENT [5] { + name: opt_x + } + } + optional_indices: [0, 1] + } + LIST [6] { + elements: { + CONSTANT [7] { value: 5 } + } + } + } + } + CALL [8] { + function: _==_ + args: { + LIST [9] { + elements: { + CONSTANT [10] { value: 10 } + CALL [11] { + function: optional.none + args: { + } + } + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + optional_indices: [0] + } + LIST [14] { + elements: { + CONSTANT [15] { value: 10 } + IDENT [16] { + name: @index1 + } + IDENT [17] { + name: @index1 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _[_] + args: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "hello" } + } + optional_entry: true + value: { + CALL [7] { + function: optional.of + args: { + CONSTANT [8] { value: "hello" } + } + } + } + } + } + CONSTANT [9] { value: "hello" } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @index0 + } + IDENT [13] { + name: @index0 + } + } + } + CONSTANT [14] { value: "hellohello" } + } + } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "key" } + } + value: { + CONSTANT [6] { value: "test" } + } + } + } + } + } + CALL [7] { + function: _==_ + args: { + CALL [8] { + function: orValue + target: { + CALL [9] { + function: or + target: { + CALL [10] { + function: _[?_] + args: { + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "key" } + } + optional_entry: true + value: { + CALL [14] { + function: optional.of + args: { + CONSTANT [15] { value: "test" } + } + } + } + } + } + CONSTANT [16] { value: "bogus" } + } + } + } + args: { + CALL [17] { + function: _[?_] + args: { + IDENT [18] { + name: @index0 + } + CONSTANT [19] { value: "bogus" } + } + } + } + } + } + args: { + CALL [20] { + function: _[_] + args: { + IDENT [21] { + name: @index0 + } + CONSTANT [22] { value: "key" } + } + } + } + } + CONSTANT [23] { value: "test" } + } + } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + STRUCT [3] { + name: cel.expr.conformance.proto3.TestAllTypes + entries: { + ENTRY [4] { + field_key: single_int64 + optional_entry: true + value: { + CALL [5] { + function: optional.ofNonZeroValue + args: { + CONSTANT [6] { value: 1 } + } + } + } + } + ENTRY [7] { + field_key: single_int32 + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: 4 } + } + } + } + } + } + } + } + } + CALL [10] { + function: _==_ + args: { + CALL [11] { + function: _+_ + args: { + SELECT [12] { + IDENT [13] { + name: @index0 + }.single_int32 + } + SELECT [14] { + IDENT [15] { + name: @index0 + }.single_int64 + } + } + } + CONSTANT [16] { value: 5 } + } + } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + } + CALL [12] { + function: matches + target: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @index0 + } + CONSTANT [15] { value: " world" } + } + } + } + args: { + IDENT [16] { + name: @index0 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [2] { + function: matches + target: { + CONSTANT [1] { value: "hello world" } + } + args: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [3] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CONSTANT [13] { value: "hello" } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CALL [20] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CONSTANT [13] { value: "w" } + CONSTANT [15] { value: "o" } + } + } + CONSTANT [17] { value: "r" } + } + } + CONSTANT [19] { value: "l" } + } + } + CONSTANT [21] { value: "d" } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + CALL [7] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: non_pure_custom_func + args: { + IDENT [11] { + name: @index0 + } + } + } + CALL [12] { + function: non_pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + CALL [17] { + function: non_pure_custom_func + args: { + IDENT [18] { + name: @index0 + } + } + } + } + } + CALL [19] { + function: non_pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: msg + }.single_int64 + } + } + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: cel.@block + args: { + LIST [2] { + elements: { + CALL [3] { + function: pure_custom_func + args: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.single_int64 + } + } + } + } + } + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + IDENT [11] { + name: @index0 + } + CALL [12] { + function: pure_custom_func + args: { + SELECT [13] { + SELECT [14] { + SELECT [15] { + IDENT [16] { + name: msg + }.oneof_type + }.payload + }.single_int32 + } + } + } + } + } + IDENT [17] { + name: @index0 + } + } + } + CALL [18] { + function: pure_custom_func + args: { + SELECT [19] { + IDENT [20] { + name: msg + }.single_int64 + } + } + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_ast_cascaded_binds.baseline b/optimizer/src/test/resources/subexpression_ast_cascaded_binds.baseline new file mode 100644 index 000000000..016dc257d --- /dev/null +++ b/optimizer/src/test/resources/subexpression_ast_cascaded_binds.baseline @@ -0,0 +1,4795 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +CALL [1] { + function: _==_ + args: { + CALL [2] { + function: _+_ + args: { + COMPREHENSION [3] { + iter_var: #unused + iter_range: { + LIST [4] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [5] { + function: size + args: { + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + } + } + } + } + } + loop_condition: { + CONSTANT [9] { value: false } + } + loop_step: { + IDENT [10] { + name: @r0 + } + } + result: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @r0 + } + IDENT [13] { + name: @r0 + } + } + } + } + } + CONSTANT [14] { value: 1 } + } + } + CONSTANT [15] { value: 5 } + } +} +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +CALL [1] { + function: _==_ + args: { + CALL [2] { + function: _+_ + args: { + COMPREHENSION [3] { + iter_var: #unused + iter_range: { + LIST [4] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [5] { + function: size + args: { + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + } + } + } + } + } + loop_condition: { + CONSTANT [9] { value: false } + } + loop_step: { + IDENT [10] { + name: @r0 + } + } + result: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + CONSTANT [13] { value: 2 } + IDENT [14] { + name: @r0 + } + } + } + IDENT [15] { + name: @r0 + } + } + } + } + } + CONSTANT [16] { value: 1 } + } + } + CONSTANT [17] { value: 7 } + } +} +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + CALL [4] { + function: size + args: { + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + } + } + } + } + } + loop_condition: { + CONSTANT [8] { value: false } + } + loop_step: { + IDENT [9] { + name: @r1 + } + } + result: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + COMPREHENSION [12] { + iter_var: #unused + iter_range: { + LIST [13] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [14] { + function: size + args: { + LIST [15] { + elements: { + CONSTANT [16] { value: 0 } + } + } + } + } + } + loop_condition: { + CONSTANT [17] { value: false } + } + loop_step: { + IDENT [18] { + name: @r0 + } + } + result: { + CALL [19] { + function: _+_ + args: { + IDENT [20] { + name: @r0 + } + IDENT [21] { + name: @r0 + } + } + } + } + } + IDENT [22] { + name: @r1 + } + } + } + IDENT [23] { + name: @r1 + } + } + } + } + } + CONSTANT [24] { value: 6 } + } +} +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r2 + accu_init: { + CALL [4] { + function: size + args: { + LIST [5] { + elements: { + CONSTANT [6] { value: 1 } + CONSTANT [7] { value: 2 } + CONSTANT [8] { value: 3 } + } + } + } + } + } + loop_condition: { + CONSTANT [9] { value: false } + } + loop_step: { + IDENT [10] { + name: @r2 + } + } + result: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _+_ + args: { + COMPREHENSION [13] { + iter_var: #unused + iter_range: { + LIST [14] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + CALL [15] { + function: size + args: { + LIST [16] { + elements: { + CONSTANT [17] { value: 1 } + CONSTANT [18] { value: 2 } + } + } + } + } + } + loop_condition: { + CONSTANT [19] { value: false } + } + loop_step: { + IDENT [20] { + name: @r1 + } + } + result: { + CALL [21] { + function: _+_ + args: { + CALL [22] { + function: _+_ + args: { + COMPREHENSION [23] { + iter_var: #unused + iter_range: { + LIST [24] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [25] { + function: size + args: { + LIST [26] { + elements: { + CONSTANT [27] { value: 0 } + } + } + } + } + } + loop_condition: { + CONSTANT [28] { value: false } + } + loop_step: { + IDENT [29] { + name: @r0 + } + } + result: { + CALL [30] { + function: _+_ + args: { + CALL [31] { + function: _+_ + args: { + CONSTANT [32] { value: 5 } + IDENT [33] { + name: @r0 + } + } + } + IDENT [34] { + name: @r0 + } + } + } + } + } + IDENT [35] { + name: @r1 + } + } + } + IDENT [36] { + name: @r1 + } + } + } + } + } + IDENT [37] { + name: @r2 + } + } + } + IDENT [38] { + name: @r2 + } + } + } + } + } + CONSTANT [39] { value: 17 } + } +} +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [4] { + function: getFullYear + target: { + CALL [5] { + function: timestamp + args: { + CALL [6] { + function: int + args: { + CALL [7] { + function: timestamp + args: { + CONSTANT [8] { value: 1000000000 } + } + } + } + } + } + } + } + args: { + } + } + } + loop_condition: { + CONSTANT [9] { value: false } + } + loop_step: { + IDENT [10] { + name: @r0 + } + } + result: { + CALL [11] { + function: _+_ + args: { + COMPREHENSION [12] { + iter_var: #unused + iter_range: { + LIST [13] { + elements: { + } + } + } + accu_var: @r3 + accu_init: { + CALL [14] { + function: timestamp + args: { + CALL [15] { + function: int + args: { + CALL [16] { + function: timestamp + args: { + CONSTANT [17] { value: 75 } + } + } + } + } + } + } + } + loop_condition: { + CONSTANT [18] { value: false } + } + loop_step: { + IDENT [19] { + name: @r3 + } + } + result: { + CALL [20] { + function: _+_ + args: { + COMPREHENSION [21] { + iter_var: #unused + iter_range: { + LIST [22] { + elements: { + } + } + } + accu_var: @r2 + accu_init: { + CALL [23] { + function: getFullYear + target: { + CALL [24] { + function: timestamp + args: { + CALL [25] { + function: int + args: { + CALL [26] { + function: timestamp + args: { + CONSTANT [27] { value: 200 } + } + } + } + } + } + } + } + args: { + } + } + } + loop_condition: { + CONSTANT [28] { value: false } + } + loop_step: { + IDENT [29] { + name: @r2 + } + } + result: { + CALL [30] { + function: _+_ + args: { + CALL [31] { + function: _+_ + args: { + COMPREHENSION [32] { + iter_var: #unused + iter_range: { + LIST [33] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + CALL [34] { + function: timestamp + args: { + CALL [35] { + function: int + args: { + CALL [36] { + function: timestamp + args: { + CONSTANT [37] { value: 50 } + } + } + } + } + } + } + } + loop_condition: { + CONSTANT [38] { value: false } + } + loop_step: { + IDENT [39] { + name: @r1 + } + } + result: { + CALL [40] { + function: _+_ + args: { + CALL [41] { + function: _+_ + args: { + CALL [42] { + function: _+_ + args: { + CALL [43] { + function: _+_ + args: { + IDENT [44] { + name: @r0 + } + CALL [45] { + function: getFullYear + target: { + IDENT [46] { + name: @r3 + } + } + args: { + } + } + } + } + CALL [47] { + function: getFullYear + target: { + IDENT [48] { + name: @r1 + } + } + args: { + } + } + } + } + IDENT [49] { + name: @r0 + } + } + } + CALL [50] { + function: getSeconds + target: { + IDENT [51] { + name: @r1 + } + } + args: { + } + } + } + } + } + } + IDENT [52] { + name: @r2 + } + } + } + IDENT [53] { + name: @r2 + } + } + } + } + } + CALL [54] { + function: getMinutes + target: { + IDENT [55] { + name: @r3 + } + } + args: { + } + } + } + } + } + } + IDENT [56] { + name: @r0 + } + } + } + } + } + CONSTANT [57] { value: 13934 } + } +} +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [4] { + function: _[_] + args: { + MAP [5] { + MAP_ENTRY [6] { + key: { + CONSTANT [7] { value: "a" } + } + value: { + CONSTANT [8] { value: 2 } + } + } + } + CONSTANT [9] { value: "a" } + } + } + } + loop_condition: { + CONSTANT [10] { value: false } + } + loop_step: { + IDENT [11] { + name: @r0 + } + } + result: { + CALL [12] { + function: _+_ + args: { + IDENT [13] { + name: @r0 + } + CALL [14] { + function: _*_ + args: { + IDENT [15] { + name: @r0 + } + IDENT [16] { + name: @r0 + } + } + } + } + } + } + } + CONSTANT [17] { value: 6 } + } +} +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "b" } + } + value: { + CONSTANT [6] { value: 1 } + } + } + } + } + loop_condition: { + CONSTANT [7] { value: false } + } + loop_step: { + IDENT [8] { + name: @r0 + } + } + result: { + COMPREHENSION [9] { + iter_var: #unused + iter_range: { + LIST [10] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "e" } + } + value: { + IDENT [14] { + name: @r0 + } + } + } + } + } + loop_condition: { + CONSTANT [15] { value: false } + } + loop_step: { + IDENT [16] { + name: @r1 + } + } + result: { + MAP [17] { + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: "a" } + } + value: { + IDENT [20] { + name: @r0 + } + } + } + MAP_ENTRY [21] { + key: { + CONSTANT [22] { value: "c" } + } + value: { + IDENT [23] { + name: @r0 + } + } + } + MAP_ENTRY [24] { + key: { + CONSTANT [25] { value: "d" } + } + value: { + IDENT [26] { + name: @r1 + } + } + } + MAP_ENTRY [27] { + key: { + CONSTANT [28] { value: "e" } + } + value: { + IDENT [29] { + name: @r1 + } + } + } + } + } + } + } +} +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + CONSTANT [7] { value: 4 } + } + } + } + loop_condition: { + CONSTANT [8] { value: false } + } + loop_step: { + IDENT [9] { + name: @r0 + } + } + result: { + COMPREHENSION [10] { + iter_var: #unused + iter_range: { + LIST [11] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + LIST [12] { + elements: { + CONSTANT [13] { value: 1 } + CONSTANT [14] { value: 2 } + } + } + } + loop_condition: { + CONSTANT [15] { value: false } + } + loop_step: { + IDENT [16] { + name: @r1 + } + } + result: { + LIST [17] { + elements: { + CONSTANT [18] { value: 1 } + IDENT [19] { + name: @r0 + } + CONSTANT [20] { value: 2 } + IDENT [21] { + name: @r0 + } + CONSTANT [22] { value: 5 } + IDENT [23] { + name: @r0 + } + CONSTANT [24] { value: 7 } + LIST [25] { + elements: { + IDENT [26] { + name: @r1 + } + IDENT [27] { + name: @r0 + } + } + } + IDENT [28] { + name: @r1 + } + } + } + } + } + } +} +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + IDENT [5] { + name: msg + }.single_int64 + } + } + loop_condition: { + CONSTANT [6] { value: false } + } + loop_step: { + IDENT [7] { + name: @r0 + } + } + result: { + CALL [8] { + function: _+_ + args: { + IDENT [9] { + name: @r0 + } + IDENT [10] { + name: @r0 + } + } + } + } + } + CONSTANT [11] { value: 6 } + } +} +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + } + } + loop_condition: { + CONSTANT [7] { value: false } + } + loop_step: { + IDENT [8] { + name: @r0 + } + } + result: { + CALL [9] { + function: _+_ + args: { + CALL [10] { + function: _+_ + args: { + COMPREHENSION [11] { + iter_var: #unused + iter_range: { + LIST [12] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + SELECT [13] { + IDENT [14] { + name: @r0 + }.single_int64 + } + } + loop_condition: { + CONSTANT [15] { value: false } + } + loop_step: { + IDENT [16] { + name: @r1 + } + } + result: { + CALL [17] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + IDENT [19] { + name: @r1 + } + SELECT [20] { + IDENT [21] { + name: @r0 + }.single_int32 + } + } + } + IDENT [22] { + name: @r1 + } + } + } + } + } + SELECT [23] { + IDENT [24] { + name: msg + }.single_int64 + } + } + } + SELECT [25] { + SELECT [26] { + SELECT [27] { + IDENT [28] { + name: @r0 + }.oneof_type + }.payload + }.single_int64 + } + } + } + } + } + CONSTANT [29] { value: 31 } + } +} +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [3] { + SELECT [4] { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + } + } + loop_condition: { + CONSTANT [9] { value: false } + } + loop_step: { + IDENT [10] { + name: @r0 + } + } + result: { + CALL [11] { + function: _||_ + args: { + CALL [12] { + function: _||_ + args: { + CONSTANT [13] { value: true } + SELECT [14] { + SELECT [15] { + SELECT [16] { + SELECT [17] { + IDENT [18] { + name: @r0 + }.payload + }.oneof_type + }.payload + }.single_bool + } + } + } + SELECT [19] { + SELECT [20] { + SELECT [21] { + SELECT [22] { + IDENT [23] { + name: @r0 + }.child + }.child + }.payload + }.single_bool + } + } + } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [4] { + function: _[_] + args: { + SELECT [5] { + SELECT [6] { + SELECT [7] { + IDENT [8] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + CONSTANT [9] { value: 1 } + } + } + } + loop_condition: { + CONSTANT [10] { value: false } + } + loop_step: { + IDENT [11] { + name: @r0 + } + } + result: { + CALL [12] { + function: _+_ + args: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @r0 + } + IDENT [15] { + name: @r0 + } + } + } + IDENT [16] { + name: @r0 + } + } + } + } + } + CONSTANT [17] { value: 15 } + } +} +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + SELECT [5] { + SELECT [6] { + IDENT [7] { + name: msg + }.oneof_type + }.payload + }.map_int32_int64 + } + } + loop_condition: { + CONSTANT [8] { value: false } + } + loop_step: { + IDENT [9] { + name: @r0 + } + } + result: { + CALL [10] { + function: _+_ + args: { + CALL [11] { + function: _+_ + args: { + CALL [12] { + function: _[_] + args: { + IDENT [13] { + name: @r0 + } + CONSTANT [14] { value: 0 } + } + } + CALL [15] { + function: _[_] + args: { + IDENT [16] { + name: @r0 + } + CONSTANT [17] { value: 1 } + } + } + } + } + CALL [18] { + function: _[_] + args: { + IDENT [19] { + name: @r0 + } + CONSTANT [20] { value: 2 } + } + } + } + } + } + } + CONSTANT [21] { value: 8 } + } +} +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +SELECT [10] { + SELECT [9] { + SELECT [8] { + SELECT [7] { + SELECT [6] { + SELECT [5] { + SELECT [4] { + SELECT [3] { + SELECT [2] { + IDENT [1] { + name: msg + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.oneof_type + }.payload + }.single_int64 +} +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + IDENT [5] { + name: msg + }.single_int64 + } + } + loop_condition: { + CONSTANT [6] { value: false } + } + loop_step: { + IDENT [7] { + name: @r0 + } + } + result: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @r0 + } + CONSTANT [11] { value: 0 } + } + } + IDENT [12] { + name: @r0 + } + CONSTANT [13] { value: 0 } + } + } + } + } + CONSTANT [14] { value: 3 } + } +} +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +CALL [1] { + function: _?_:_ + args: { + CONSTANT [2] { value: false } + CONSTANT [3] { value: false } + CALL [4] { + function: _==_ + args: { + COMPREHENSION [5] { + iter_var: #unused + iter_range: { + LIST [6] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [7] { + IDENT [8] { + name: msg + }.single_int64 + } + } + loop_condition: { + CONSTANT [9] { value: false } + } + loop_step: { + IDENT [10] { + name: @r0 + } + } + result: { + CALL [11] { + function: _+_ + args: { + IDENT [12] { + name: @r0 + } + CALL [13] { + function: _*_ + args: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @r0 + } + CONSTANT [16] { value: 1 } + } + } + CONSTANT [17] { value: 2 } + } + } + } + } + } + } + CONSTANT [18] { value: 11 } + } + } + } +} +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + IDENT [5] { + name: msg + }.single_int64 + } + } + loop_condition: { + CONSTANT [6] { value: false } + } + loop_step: { + IDENT [7] { + name: @r0 + } + } + result: { + CALL [8] { + function: _?_:_ + args: { + CALL [9] { + function: _>_ + args: { + IDENT [10] { + name: @r0 + } + CONSTANT [11] { value: 0 } + } + } + COMPREHENSION [12] { + iter_var: #unused + iter_range: { + LIST [13] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + SELECT [14] { + IDENT [15] { + name: msg + }.single_int32 + } + } + loop_condition: { + CONSTANT [16] { value: false } + } + loop_step: { + IDENT [17] { + name: @r1 + } + } + result: { + CALL [18] { + function: _?_:_ + args: { + CALL [19] { + function: _>_ + args: { + IDENT [20] { + name: @r1 + } + CONSTANT [21] { value: 0 } + } + } + CALL [22] { + function: _+_ + args: { + IDENT [23] { + name: @r0 + } + IDENT [24] { + name: @r1 + } + } + } + CONSTANT [25] { value: 0 } + } + } + } + } + CONSTANT [26] { value: 0 } + } + } + } + } + CONSTANT [27] { value: 8 } + } +} +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + LIST [4] { + elements: { + CONSTANT [5] { value: 2 } + } + } + } + loop_condition: { + CONSTANT [6] { value: false } + } + loop_step: { + IDENT [7] { + name: @r1 + } + } + result: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + COMPREHENSION [10] { + iter_var: #unused + iter_range: { + LIST [11] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + LIST [12] { + elements: { + CONSTANT [13] { value: 1 } + } + } + } + loop_condition: { + CONSTANT [14] { value: false } + } + loop_step: { + IDENT [15] { + name: @r0 + } + } + result: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: size + args: { + LIST [18] { + elements: { + COMPREHENSION [19] { + iter_var: @it:0 + iter_range: { + IDENT [20] { + name: @r0 + } + } + accu_var: @ac:0 + accu_init: { + CONSTANT [21] { value: false } + } + loop_condition: { + CALL [22] { + function: @not_strictly_false + args: { + CALL [23] { + function: !_ + args: { + IDENT [24] { + name: @ac:0 + } + } + } + } + } + } + loop_step: { + CALL [25] { + function: _||_ + args: { + IDENT [26] { + name: @ac:0 + } + CALL [27] { + function: _>_ + args: { + IDENT [28] { + name: @it:0 + } + CONSTANT [29] { value: 0 } + } + } + } + } + } + result: { + IDENT [30] { + name: @ac:0 + } + } + } + } + } + } + } + CALL [31] { + function: size + args: { + LIST [32] { + elements: { + COMPREHENSION [33] { + iter_var: @it:1 + iter_range: { + IDENT [34] { + name: @r0 + } + } + accu_var: @ac:1 + accu_init: { + CONSTANT [35] { value: false } + } + loop_condition: { + CALL [36] { + function: @not_strictly_false + args: { + CALL [37] { + function: !_ + args: { + IDENT [38] { + name: @ac:1 + } + } + } + } + } + } + loop_step: { + CALL [39] { + function: _||_ + args: { + IDENT [40] { + name: @ac:1 + } + CALL [41] { + function: _>_ + args: { + IDENT [42] { + name: @it:1 + } + CONSTANT [43] { value: 0 } + } + } + } + } + } + result: { + IDENT [44] { + name: @ac:1 + } + } + } + } + } + } + } + } + } + } + } + CALL [45] { + function: size + args: { + LIST [46] { + elements: { + COMPREHENSION [47] { + iter_var: @it:2 + iter_range: { + IDENT [48] { + name: @r1 + } + } + accu_var: @ac:2 + accu_init: { + CONSTANT [49] { value: false } + } + loop_condition: { + CALL [50] { + function: @not_strictly_false + args: { + CALL [51] { + function: !_ + args: { + IDENT [52] { + name: @ac:2 + } + } + } + } + } + } + loop_step: { + CALL [53] { + function: _||_ + args: { + IDENT [54] { + name: @ac:2 + } + CALL [55] { + function: _>_ + args: { + IDENT [56] { + name: @it:2 + } + CONSTANT [57] { value: 1 } + } + } + } + } + } + result: { + IDENT [58] { + name: @ac:2 + } + } + } + } + } + } + } + } + } + CALL [59] { + function: size + args: { + LIST [60] { + elements: { + COMPREHENSION [61] { + iter_var: @it:3 + iter_range: { + IDENT [62] { + name: @r1 + } + } + accu_var: @ac:3 + accu_init: { + CONSTANT [63] { value: false } + } + loop_condition: { + CALL [64] { + function: @not_strictly_false + args: { + CALL [65] { + function: !_ + args: { + IDENT [66] { + name: @ac:3 + } + } + } + } + } + } + loop_step: { + CALL [67] { + function: _||_ + args: { + IDENT [68] { + name: @ac:3 + } + CALL [69] { + function: _>_ + args: { + IDENT [70] { + name: @it:3 + } + CONSTANT [71] { value: 1 } + } + } + } + } + } + result: { + IDENT [72] { + name: @ac:3 + } + } + } + } + } + } + } + } + } + } + } + CONSTANT [73] { value: 4 } + } +} +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + LIST [4] { + elements: { + CONSTANT [5] { value: "a" } + } + } + } + loop_condition: { + CONSTANT [6] { value: false } + } + loop_step: { + IDENT [7] { + name: @r1 + } + } + result: { + CALL [8] { + function: _+_ + args: { + CALL [9] { + function: _+_ + args: { + COMPREHENSION [10] { + iter_var: #unused + iter_range: { + LIST [11] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + LIST [12] { + elements: { + CONSTANT [13] { value: 1 } + } + } + } + loop_condition: { + CONSTANT [14] { value: false } + } + loop_step: { + IDENT [15] { + name: @r0 + } + } + result: { + CALL [16] { + function: _+_ + args: { + LIST [17] { + elements: { + COMPREHENSION [18] { + iter_var: @it:0 + iter_range: { + IDENT [19] { + name: @r0 + } + } + accu_var: @ac:0 + accu_init: { + CONSTANT [20] { value: false } + } + loop_condition: { + CALL [21] { + function: @not_strictly_false + args: { + CALL [22] { + function: !_ + args: { + IDENT [23] { + name: @ac:0 + } + } + } + } + } + } + loop_step: { + CALL [24] { + function: _||_ + args: { + IDENT [25] { + name: @ac:0 + } + CALL [26] { + function: _>_ + args: { + IDENT [27] { + name: @it:0 + } + CONSTANT [28] { value: 0 } + } + } + } + } + } + result: { + IDENT [29] { + name: @ac:0 + } + } + } + } + } + LIST [30] { + elements: { + COMPREHENSION [31] { + iter_var: @it:1 + iter_range: { + IDENT [32] { + name: @r0 + } + } + accu_var: @ac:1 + accu_init: { + CONSTANT [33] { value: false } + } + loop_condition: { + CALL [34] { + function: @not_strictly_false + args: { + CALL [35] { + function: !_ + args: { + IDENT [36] { + name: @ac:1 + } + } + } + } + } + } + loop_step: { + CALL [37] { + function: _||_ + args: { + IDENT [38] { + name: @ac:1 + } + CALL [39] { + function: _>_ + args: { + IDENT [40] { + name: @it:1 + } + CONSTANT [41] { value: 0 } + } + } + } + } + } + result: { + IDENT [42] { + name: @ac:1 + } + } + } + } + } + } + } + } + } + LIST [43] { + elements: { + COMPREHENSION [44] { + iter_var: @it:2 + iter_range: { + IDENT [45] { + name: @r1 + } + } + accu_var: @ac:2 + accu_init: { + CONSTANT [46] { value: false } + } + loop_condition: { + CALL [47] { + function: @not_strictly_false + args: { + CALL [48] { + function: !_ + args: { + IDENT [49] { + name: @ac:2 + } + } + } + } + } + } + loop_step: { + CALL [50] { + function: _||_ + args: { + IDENT [51] { + name: @ac:2 + } + CALL [52] { + function: _==_ + args: { + IDENT [53] { + name: @it:2 + } + CONSTANT [54] { value: "a" } + } + } + } + } + } + result: { + IDENT [55] { + name: @ac:2 + } + } + } + } + } + } + } + LIST [56] { + elements: { + COMPREHENSION [57] { + iter_var: @it:3 + iter_range: { + IDENT [58] { + name: @r1 + } + } + accu_var: @ac:3 + accu_init: { + CONSTANT [59] { value: false } + } + loop_condition: { + CALL [60] { + function: @not_strictly_false + args: { + CALL [61] { + function: !_ + args: { + IDENT [62] { + name: @ac:3 + } + } + } + } + } + } + loop_step: { + CALL [63] { + function: _||_ + args: { + IDENT [64] { + name: @ac:3 + } + CALL [65] { + function: _==_ + args: { + IDENT [66] { + name: @it:3 + } + CONSTANT [67] { value: "a" } + } + } + } + } + } + result: { + IDENT [68] { + name: @ac:3 + } + } + } + } + } + } + } + } + } + LIST [69] { + elements: { + CONSTANT [70] { value: true } + CONSTANT [71] { value: true } + CONSTANT [72] { value: true } + CONSTANT [73] { value: true } + } + } + } +} +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + } + } + } + loop_condition: { + CONSTANT [5] { value: false } + } + loop_step: { + IDENT [6] { + name: @r0 + } + } + result: { + CALL [7] { + function: _&&_ + args: { + CALL [8] { + function: _&&_ + args: { + COMPREHENSION [9] { + iter_var: @it:0 + iter_range: { + IDENT [10] { + name: @r0 + } + } + accu_var: @ac:0 + accu_init: { + CONSTANT [11] { value: false } + } + loop_condition: { + CALL [12] { + function: @not_strictly_false + args: { + CALL [13] { + function: !_ + args: { + IDENT [14] { + name: @ac:0 + } + } + } + } + } + } + loop_step: { + CALL [15] { + function: _||_ + args: { + IDENT [16] { + name: @ac:0 + } + CALL [17] { + function: _>_ + args: { + IDENT [18] { + name: @it:0 + } + CONSTANT [19] { value: 0 } + } + } + } + } + } + result: { + IDENT [20] { + name: @ac:0 + } + } + } + COMPREHENSION [21] { + iter_var: @it:1 + iter_range: { + IDENT [22] { + name: @r0 + } + } + accu_var: @ac:1 + accu_init: { + CONSTANT [23] { value: false } + } + loop_condition: { + CALL [24] { + function: @not_strictly_false + args: { + CALL [25] { + function: !_ + args: { + IDENT [26] { + name: @ac:1 + } + } + } + } + } + } + loop_step: { + CALL [27] { + function: _||_ + args: { + IDENT [28] { + name: @ac:1 + } + CALL [29] { + function: _>_ + args: { + IDENT [30] { + name: @it:1 + } + CONSTANT [31] { value: 0 } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1 + } + } + } + } + } + CALL [33] { + function: _&&_ + args: { + COMPREHENSION [34] { + iter_var: @it:2 + iter_range: { + IDENT [35] { + name: @r0 + } + } + accu_var: @ac:2 + accu_init: { + CONSTANT [36] { value: false } + } + loop_condition: { + CALL [37] { + function: @not_strictly_false + args: { + CALL [38] { + function: !_ + args: { + IDENT [39] { + name: @ac:2 + } + } + } + } + } + } + loop_step: { + CALL [40] { + function: _||_ + args: { + IDENT [41] { + name: @ac:2 + } + CALL [42] { + function: _>_ + args: { + IDENT [43] { + name: @it:2 + } + CONSTANT [44] { value: 1 } + } + } + } + } + } + result: { + IDENT [45] { + name: @ac:2 + } + } + } + COMPREHENSION [46] { + iter_var: @it:3 + iter_range: { + LIST [47] { + elements: { + CONSTANT [48] { value: 2 } + } + } + } + accu_var: @ac:3 + accu_init: { + CONSTANT [49] { value: false } + } + loop_condition: { + CALL [50] { + function: @not_strictly_false + args: { + CALL [51] { + function: !_ + args: { + IDENT [52] { + name: @ac:3 + } + } + } + } + } + } + loop_step: { + CALL [53] { + function: _||_ + args: { + IDENT [54] { + name: @ac:3 + } + CALL [55] { + function: _>_ + args: { + IDENT [56] { + name: @it:3 + } + CONSTANT [57] { value: 1 } + } + } + } + } + } + result: { + IDENT [58] { + name: @ac:3 + } + } + } + } + } + } + } + } +} +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + LIST [4] { + elements: { + CONSTANT [5] { value: 1 } + CONSTANT [6] { value: 2 } + CONSTANT [7] { value: 3 } + } + } + } + loop_condition: { + CONSTANT [8] { value: false } + } + loop_step: { + IDENT [9] { + name: @r0 + } + } + result: { + COMPREHENSION [10] { + iter_var: @it:1 + iter_range: { + IDENT [11] { + name: @r0 + } + } + accu_var: @ac:1 + accu_init: { + LIST [12] { + elements: { + } + } + } + loop_condition: { + CONSTANT [13] { value: true } + } + loop_step: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @ac:1 + } + LIST [16] { + elements: { + COMPREHENSION [17] { + iter_var: @it:0 + iter_range: { + IDENT [18] { + name: @r0 + } + } + accu_var: @ac:0 + accu_init: { + LIST [19] { + elements: { + } + } + } + loop_condition: { + CONSTANT [20] { value: true } + } + loop_step: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @ac:0 + } + LIST [23] { + elements: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @it:0 + } + CONSTANT [26] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:0 + } + } + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:1 + } + } + } + } + } + COMPREHENSION [29] { + iter_var: #unused + iter_range: { + LIST [30] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + LIST [31] { + elements: { + CONSTANT [32] { value: 2 } + CONSTANT [33] { value: 3 } + CONSTANT [34] { value: 4 } + } + } + } + loop_condition: { + CONSTANT [35] { value: false } + } + loop_step: { + IDENT [36] { + name: @r1 + } + } + result: { + LIST [37] { + elements: { + IDENT [38] { + name: @r1 + } + IDENT [39] { + name: @r1 + } + IDENT [40] { + name: @r1 + } + } + } + } + } + } +} +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +CALL [31] { + function: _==_ + args: { + COMPREHENSION [30] { + iter_var: y + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: 1 } + CONSTANT [3] { value: 2 } + } + } + } + accu_var: @result + accu_init: { + LIST [24] { + elements: { + } + } + } + loop_condition: { + CONSTANT [25] { value: true } + } + loop_step: { + CALL [28] { + function: _+_ + args: { + IDENT [26] { + name: @result + } + LIST [27] { + elements: { + COMPREHENSION [23] { + iter_var: x + iter_range: { + LIST [6] { + elements: { + CONSTANT [7] { value: 1 } + CONSTANT [8] { value: 2 } + CONSTANT [9] { value: 3 } + } + } + } + accu_var: @result + accu_init: { + LIST [15] { + elements: { + } + } + } + loop_condition: { + CONSTANT [16] { value: true } + } + loop_step: { + CALL [21] { + function: _?_:_ + args: { + CALL [13] { + function: _==_ + args: { + IDENT [12] { + name: x + } + IDENT [14] { + name: y + } + } + } + CALL [19] { + function: _+_ + args: { + IDENT [17] { + name: @result + } + LIST [18] { + elements: { + IDENT [11] { + name: x + } + } + } + } + } + IDENT [20] { + name: @result + } + } + } + } + result: { + IDENT [22] { + name: @result + } + } + } + } + } + } + } + } + result: { + IDENT [29] { + name: @result + } + } + } + LIST [32] { + elements: { + LIST [33] { + elements: { + CONSTANT [34] { value: 1 } + } + } + LIST [35] { + elements: { + CONSTANT [36] { value: 2 } + } + } + } + } + } +} +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + loop_condition: { + CONSTANT [7] { value: false } + } + loop_step: { + IDENT [8] { + name: @r0 + } + } + result: { + CALL [9] { + function: _==_ + args: { + COMPREHENSION [10] { + iter_var: @it:1 + iter_range: { + IDENT [11] { + name: @r0 + } + } + accu_var: @ac:1 + accu_init: { + LIST [12] { + elements: { + } + } + } + loop_condition: { + CONSTANT [13] { value: true } + } + loop_step: { + CALL [14] { + function: _+_ + args: { + IDENT [15] { + name: @ac:1 + } + LIST [16] { + elements: { + COMPREHENSION [17] { + iter_var: @it:0 + iter_range: { + IDENT [18] { + name: @r0 + } + } + accu_var: @ac:0 + accu_init: { + LIST [19] { + elements: { + } + } + } + loop_condition: { + CONSTANT [20] { value: true } + } + loop_step: { + CALL [21] { + function: _+_ + args: { + IDENT [22] { + name: @ac:0 + } + LIST [23] { + elements: { + CALL [24] { + function: _+_ + args: { + IDENT [25] { + name: @it:0 + } + CONSTANT [26] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [27] { + name: @ac:0 + } + } + } + } + } + } + } + } + result: { + IDENT [28] { + name: @ac:1 + } + } + } + COMPREHENSION [29] { + iter_var: @it:3 + iter_range: { + IDENT [30] { + name: @r0 + } + } + accu_var: @ac:3 + accu_init: { + LIST [31] { + elements: { + } + } + } + loop_condition: { + CONSTANT [32] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [34] { + name: @ac:3 + } + LIST [35] { + elements: { + COMPREHENSION [36] { + iter_var: @it:2 + iter_range: { + IDENT [37] { + name: @r0 + } + } + accu_var: @ac:2 + accu_init: { + LIST [38] { + elements: { + } + } + } + loop_condition: { + CONSTANT [39] { value: true } + } + loop_step: { + CALL [40] { + function: _+_ + args: { + IDENT [41] { + name: @ac:2 + } + LIST [42] { + elements: { + CALL [43] { + function: _+_ + args: { + IDENT [44] { + name: @it:2 + } + CONSTANT [45] { value: 1 } + } + } + } + } + } + } + } + result: { + IDENT [46] { + name: @ac:2 + } + } + } + } + } + } + } + } + result: { + IDENT [47] { + name: @ac:3 + } + } + } + } + } + } +} +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + LIST [3] { + elements: { + CONSTANT [4] { value: 1 } + CONSTANT [5] { value: 2 } + CONSTANT [6] { value: 3 } + } + } + } + loop_condition: { + CONSTANT [7] { value: false } + } + loop_step: { + IDENT [8] { + name: @r0 + } + } + result: { + COMPREHENSION [9] { + iter_var: #unused + iter_range: { + LIST [10] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + CALL [11] { + function: @in + args: { + CONSTANT [12] { value: 1 } + IDENT [13] { + name: @r0 + } + } + } + } + loop_condition: { + CONSTANT [14] { value: false } + } + loop_step: { + IDENT [15] { + name: @r1 + } + } + result: { + CALL [16] { + function: _&&_ + args: { + CALL [17] { + function: _&&_ + args: { + IDENT [18] { + name: @r1 + } + CALL [19] { + function: @in + args: { + CONSTANT [20] { value: 2 } + IDENT [21] { + name: @r0 + } + } + } + } + } + CALL [22] { + function: _&&_ + args: { + CALL [23] { + function: @in + args: { + CONSTANT [24] { value: 3 } + LIST [25] { + elements: { + CONSTANT [26] { value: 3 } + IDENT [27] { + name: @r0 + } + } + } + } + } + IDENT [28] { + name: @r1 + } + } + } + } + } + } + } + } +} +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +CALL [1] { + function: @in + args: { + CONSTANT [2] { value: 2 } + COMPREHENSION [3] { + iter_var: #unused + iter_range: { + LIST [4] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + MAP [5] { + MAP_ENTRY [6] { + key: { + CONSTANT [7] { value: true } + } + value: { + CONSTANT [8] { value: false } + } + } + } + } + loop_condition: { + CONSTANT [9] { value: false } + } + loop_step: { + IDENT [10] { + name: @r0 + } + } + result: { + MAP [11] { + MAP_ENTRY [12] { + key: { + CONSTANT [13] { value: "a" } + } + value: { + CONSTANT [14] { value: 1 } + } + } + MAP_ENTRY [15] { + key: { + CONSTANT [16] { value: 2 } + } + value: { + IDENT [17] { + name: @r0 + } + } + } + MAP_ENTRY [18] { + key: { + CONSTANT [19] { value: 3 } + } + value: { + IDENT [20] { + name: @r0 + } + } + } + } + } + } + } +} +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + LIST [3] { + elements: { + CONSTANT [4] { value: 3 } + CONSTANT [5] { value: 4 } + } + } + } + loop_condition: { + CONSTANT [6] { value: false } + } + loop_step: { + IDENT [7] { + name: @r1 + } + } + result: { + CALL [8] { + function: _==_ + args: { + COMPREHENSION [9] { + iter_var: #unused + iter_range: { + LIST [10] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + LIST [11] { + elements: { + CONSTANT [12] { value: 1 } + CONSTANT [13] { value: 2 } + } + } + } + loop_condition: { + CONSTANT [14] { value: false } + } + loop_step: { + IDENT [15] { + name: @r0 + } + } + result: { + COMPREHENSION [16] { + iter_var: @it:1 + iter_range: { + IDENT [17] { + name: @r0 + } + } + accu_var: @ac:1 + accu_init: { + LIST [18] { + elements: { + } + } + } + loop_condition: { + CONSTANT [19] { value: true } + } + loop_step: { + CALL [20] { + function: _+_ + args: { + IDENT [21] { + name: @ac:1 + } + LIST [22] { + elements: { + COMPREHENSION [23] { + iter_var: @it:0 + iter_range: { + IDENT [24] { + name: @r0 + } + } + accu_var: @ac:0 + accu_init: { + LIST [25] { + elements: { + } + } + } + loop_condition: { + CONSTANT [26] { value: true } + } + loop_step: { + CALL [27] { + function: _+_ + args: { + IDENT [28] { + name: @ac:0 + } + LIST [29] { + elements: { + IDENT [30] { + name: @r1 + } + } + } + } + } + } + result: { + IDENT [31] { + name: @ac:0 + } + } + } + } + } + } + } + } + result: { + IDENT [32] { + name: @ac:1 + } + } + } + } + } + COMPREHENSION [33] { + iter_var: #unused + iter_range: { + LIST [34] { + elements: { + } + } + } + accu_var: @r2 + accu_init: { + LIST [35] { + elements: { + IDENT [36] { + name: @r1 + } + IDENT [37] { + name: @r1 + } + } + } + } + loop_condition: { + CONSTANT [38] { value: false } + } + loop_step: { + IDENT [39] { + name: @r2 + } + } + result: { + LIST [40] { + elements: { + IDENT [41] { + name: @r2 + } + IDENT [42] { + name: @r2 + } + } + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [3] { + function: _-_ + args: { + IDENT [4] { + name: x + } + CONSTANT [5] { value: 1 } + } + } + } + loop_condition: { + CONSTANT [6] { value: false } + } + loop_step: { + IDENT [7] { + name: @r0 + } + } + result: { + COMPREHENSION [8] { + iter_var: #unused + iter_range: { + LIST [9] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + CALL [10] { + function: _>_ + args: { + IDENT [11] { + name: @r0 + } + CONSTANT [12] { value: 3 } + } + } + } + loop_condition: { + CONSTANT [13] { value: false } + } + loop_step: { + IDENT [14] { + name: @r1 + } + } + result: { + CALL [15] { + function: _||_ + args: { + COMPREHENSION [16] { + iter_var: @it:0 + iter_range: { + LIST [17] { + elements: { + CALL [18] { + function: _?_:_ + args: { + IDENT [19] { + name: @r1 + } + IDENT [20] { + name: @r0 + } + CONSTANT [21] { value: 5 } + } + } + } + } + } + accu_var: @ac:0 + accu_init: { + CONSTANT [22] { value: false } + } + loop_condition: { + CALL [23] { + function: @not_strictly_false + args: { + CALL [24] { + function: !_ + args: { + IDENT [25] { + name: @ac:0 + } + } + } + } + } + } + loop_step: { + CALL [26] { + function: _||_ + args: { + IDENT [27] { + name: @ac:0 + } + CALL [28] { + function: _>_ + args: { + CALL [29] { + function: _-_ + args: { + IDENT [30] { + name: @it:0 + } + CONSTANT [31] { value: 1 } + } + } + CONSTANT [32] { value: 3 } + } + } + } + } + } + result: { + IDENT [33] { + name: @ac:0 + } + } + } + IDENT [34] { + name: @r1 + } + } + } + } + } + } +} +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +COMPREHENSION [35] { + iter_var: x + iter_range: { + COMPREHENSION [19] { + iter_var: x + iter_range: { + LIST [1] { + elements: { + CONSTANT [2] { value: "foo" } + CONSTANT [3] { value: "bar" } + } + } + } + accu_var: @result + accu_init: { + LIST [13] { + elements: { + } + } + } + loop_condition: { + CONSTANT [14] { value: true } + } + loop_step: { + CALL [17] { + function: _+_ + args: { + IDENT [15] { + name: @result + } + LIST [16] { + elements: { + LIST [6] { + elements: { + CALL [8] { + function: _+_ + args: { + IDENT [7] { + name: x + } + IDENT [9] { + name: x + } + } + } + CALL [11] { + function: _+_ + args: { + IDENT [10] { + name: x + } + IDENT [12] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [18] { + name: @result + } + } + } + } + accu_var: @result + accu_init: { + LIST [29] { + elements: { + } + } + } + loop_condition: { + CONSTANT [30] { value: true } + } + loop_step: { + CALL [33] { + function: _+_ + args: { + IDENT [31] { + name: @result + } + LIST [32] { + elements: { + LIST [22] { + elements: { + CALL [24] { + function: _+_ + args: { + IDENT [23] { + name: x + } + IDENT [25] { + name: x + } + } + } + CALL [27] { + function: _+_ + args: { + IDENT [26] { + name: x + } + IDENT [28] { + name: x + } + } + } + } + } + } + } + } + } + } + result: { + IDENT [34] { + name: @result + } + } +} +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + MAP [3] { + MAP_ENTRY [4] { + key: { + CONSTANT [5] { value: "a" } + } + value: { + CONSTANT [6] { value: true } + } + } + } + } + loop_condition: { + CONSTANT [7] { value: false } + } + loop_step: { + IDENT [8] { + name: @r0 + } + } + result: { + CALL [9] { + function: _&&_ + args: { + SELECT [10] { + IDENT [11] { + name: @r0 + }.a~presence_test + } + CALL [12] { + function: _[_] + args: { + IDENT [13] { + name: @r0 + } + CONSTANT [14] { value: "a" } + } + } + } + } + } +} +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [3] { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "a" } + } + value: { + CONSTANT [7] { value: true } + } + } + }.a~presence_test + } + } + loop_condition: { + CONSTANT [8] { value: false } + } + loop_step: { + IDENT [9] { + name: @r0 + } + } + result: { + CALL [10] { + function: _&&_ + args: { + IDENT [11] { + name: @r0 + } + IDENT [12] { + name: @r0 + } + } + } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + } + } + loop_condition: { + CONSTANT [6] { value: false } + } + loop_step: { + IDENT [7] { + name: @r0 + } + } + result: { + CALL [8] { + function: _?_:_ + args: { + SELECT [9] { + IDENT [10] { + name: @r0 + }.payload~presence_test + } + SELECT [11] { + SELECT [12] { + IDENT [13] { + name: @r0 + }.payload + }.single_int64 + } + CONSTANT [14] { value: 0 } + } + } + } + } + CONSTANT [15] { value: 10 } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + IDENT [5] { + name: msg + }.oneof_type + } + } + loop_condition: { + CONSTANT [6] { value: false } + } + loop_step: { + IDENT [7] { + name: @r0 + } + } + result: { + COMPREHENSION [8] { + iter_var: #unused + iter_range: { + LIST [9] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + SELECT [10] { + SELECT [11] { + IDENT [12] { + name: @r0 + }.payload + }.single_int64 + } + } + loop_condition: { + CONSTANT [13] { value: false } + } + loop_step: { + IDENT [14] { + name: @r1 + } + } + result: { + CALL [15] { + function: _?_:_ + args: { + SELECT [16] { + IDENT [17] { + name: @r0 + }.payload~presence_test + } + IDENT [18] { + name: @r1 + } + CALL [19] { + function: _*_ + args: { + IDENT [20] { + name: @r1 + } + CONSTANT [21] { value: 0 } + } + } + } + } + } + } + } + } + CONSTANT [22] { value: 10 } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + } + } + loop_condition: { + CONSTANT [7] { value: false } + } + loop_step: { + IDENT [8] { + name: @r0 + } + } + result: { + COMPREHENSION [9] { + iter_var: #unused + iter_range: { + LIST [10] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + SELECT [11] { + IDENT [12] { + name: @r0 + }.single_int64 + } + } + loop_condition: { + CONSTANT [13] { value: false } + } + loop_step: { + IDENT [14] { + name: @r1 + } + } + result: { + CALL [15] { + function: _?_:_ + args: { + SELECT [16] { + IDENT [17] { + name: @r0 + }.single_int64~presence_test + } + IDENT [18] { + name: @r1 + } + CALL [19] { + function: _*_ + args: { + IDENT [20] { + name: @r1 + } + CONSTANT [21] { value: 0 } + } + } + } + } + } + } + } + } + CONSTANT [22] { value: 10 } + } +} +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [3] { + IDENT [4] { + name: msg + }.oneof_type + } + } + loop_condition: { + CONSTANT [5] { value: false } + } + loop_step: { + IDENT [6] { + name: @r0 + } + } + result: { + COMPREHENSION [7] { + iter_var: #unused + iter_range: { + LIST [8] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + SELECT [9] { + IDENT [10] { + name: @r0 + }.payload + } + } + loop_condition: { + CONSTANT [11] { value: false } + } + loop_step: { + IDENT [12] { + name: @r1 + } + } + result: { + CALL [13] { + function: _?_:_ + args: { + CALL [14] { + function: _&&_ + args: { + CALL [15] { + function: _&&_ + args: { + SELECT [16] { + IDENT [17] { + name: msg + }.oneof_type~presence_test + } + SELECT [18] { + IDENT [19] { + name: @r0 + }.payload~presence_test + } + } + } + SELECT [20] { + IDENT [21] { + name: @r1 + }.single_int64~presence_test + } + } + } + COMPREHENSION [22] { + iter_var: #unused + iter_range: { + LIST [23] { + elements: { + } + } + } + accu_var: @r2 + accu_init: { + SELECT [24] { + IDENT [25] { + name: @r1 + }.map_string_string + } + } + loop_condition: { + CONSTANT [26] { value: false } + } + loop_step: { + IDENT [27] { + name: @r2 + } + } + result: { + CALL [28] { + function: _?_:_ + args: { + CALL [29] { + function: _&&_ + args: { + SELECT [30] { + IDENT [31] { + name: @r1 + }.map_string_string~presence_test + } + SELECT [32] { + IDENT [33] { + name: @r2 + }.key~presence_test + } + } + } + CALL [34] { + function: _==_ + args: { + SELECT [35] { + IDENT [36] { + name: @r2 + }.key + } + CONSTANT [37] { value: "A" } + } + } + CONSTANT [38] { value: false } + } + } + } + } + CONSTANT [39] { value: false } + } + } + } + } + } +} +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [4] { + function: optional.none + args: { + } + } + } + loop_condition: { + CONSTANT [5] { value: false } + } + loop_step: { + IDENT [6] { + name: @r0 + } + } + result: { + COMPREHENSION [7] { + iter_var: #unused + iter_range: { + LIST [8] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + LIST [9] { + elements: { + IDENT [10] { + name: @r0 + } + IDENT [11] { + name: opt_x + } + } + optional_indices: [0, 1] + } + } + loop_condition: { + CONSTANT [12] { value: false } + } + loop_step: { + IDENT [13] { + name: @r1 + } + } + result: { + LIST [14] { + elements: { + CONSTANT [15] { value: 10 } + IDENT [16] { + name: @r0 + } + IDENT [17] { + name: @r1 + } + IDENT [18] { + name: @r1 + } + } + optional_indices: [0] + } + } + } + } + } + COMPREHENSION [19] { + iter_var: #unused + iter_range: { + LIST [20] { + elements: { + } + } + } + accu_var: @r2 + accu_init: { + LIST [21] { + elements: { + CONSTANT [22] { value: 5 } + } + } + } + loop_condition: { + CONSTANT [23] { value: false } + } + loop_step: { + IDENT [24] { + name: @r2 + } + } + result: { + LIST [25] { + elements: { + CONSTANT [26] { value: 10 } + IDENT [27] { + name: @r2 + } + IDENT [28] { + name: @r2 + } + } + } + } + } + } +} +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [4] { + function: _[_] + args: { + MAP [5] { + MAP_ENTRY [6] { + key: { + CONSTANT [7] { value: "hello" } + } + optional_entry: true + value: { + CALL [8] { + function: optional.of + args: { + CONSTANT [9] { value: "hello" } + } + } + } + } + } + CONSTANT [10] { value: "hello" } + } + } + } + loop_condition: { + CONSTANT [11] { value: false } + } + loop_step: { + IDENT [12] { + name: @r0 + } + } + result: { + CALL [13] { + function: _+_ + args: { + IDENT [14] { + name: @r0 + } + IDENT [15] { + name: @r0 + } + } + } + } + } + CONSTANT [16] { value: "hellohello" } + } +} +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + MAP [4] { + MAP_ENTRY [5] { + key: { + CONSTANT [6] { value: "key" } + } + value: { + CONSTANT [7] { value: "test" } + } + } + } + } + loop_condition: { + CONSTANT [8] { value: false } + } + loop_step: { + IDENT [9] { + name: @r0 + } + } + result: { + CALL [10] { + function: orValue + target: { + CALL [11] { + function: or + target: { + CALL [12] { + function: _[?_] + args: { + MAP [13] { + MAP_ENTRY [14] { + key: { + CONSTANT [15] { value: "key" } + } + optional_entry: true + value: { + CALL [16] { + function: optional.of + args: { + CONSTANT [17] { value: "test" } + } + } + } + } + } + CONSTANT [18] { value: "bogus" } + } + } + } + args: { + CALL [19] { + function: _[?_] + args: { + IDENT [20] { + name: @r0 + } + CONSTANT [21] { value: "bogus" } + } + } + } + } + } + args: { + CALL [22] { + function: _[_] + args: { + IDENT [23] { + name: @r0 + } + CONSTANT [24] { value: "key" } + } + } + } + } + } + } + CONSTANT [25] { value: "test" } + } +} +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +CALL [1] { + function: _==_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + STRUCT [4] { + name: TestAllTypes + entries: { + ENTRY [5] { + field_key: single_int64 + optional_entry: true + value: { + CALL [6] { + function: optional.ofNonZeroValue + args: { + CONSTANT [7] { value: 1 } + } + } + } + } + ENTRY [8] { + field_key: single_int32 + optional_entry: true + value: { + CALL [9] { + function: optional.of + args: { + CONSTANT [10] { value: 4 } + } + } + } + } + } + } + } + loop_condition: { + CONSTANT [11] { value: false } + } + loop_step: { + IDENT [12] { + name: @r0 + } + } + result: { + CALL [13] { + function: _+_ + args: { + SELECT [14] { + IDENT [15] { + name: @r0 + }.single_int32 + } + SELECT [16] { + IDENT [17] { + name: @r0 + }.single_int64 + } + } + } + } + } + CONSTANT [18] { value: 5 } + } +} +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +COMPREHENSION [1] { + iter_var: #unused + iter_range: { + LIST [2] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + CALL [3] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [5] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CONSTANT [7] { value: "h" } + CONSTANT [8] { value: "e" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [10] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } + loop_condition: { + CONSTANT [12] { value: false } + } + loop_step: { + IDENT [13] { + name: @r0 + } + } + result: { + CALL [14] { + function: matches + target: { + CALL [15] { + function: _+_ + args: { + IDENT [16] { + name: @r0 + } + CONSTANT [17] { value: " world" } + } + } + } + args: { + IDENT [18] { + name: @r0 + } + } + } + } +} +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +CALL [2] { + function: matches + target: { + CONSTANT [1] { value: "hello world" } + } + args: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CONSTANT [3] { value: "h" } + CONSTANT [5] { value: "e" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "l" } + } + } + CONSTANT [11] { value: "o" } + } + } + } +} +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CONSTANT [13] { value: "hello" } + } +} +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +CALL [12] { + function: matches + target: { + CALL [10] { + function: _+_ + args: { + CALL [8] { + function: _+_ + args: { + CALL [6] { + function: _+_ + args: { + CALL [4] { + function: _+_ + args: { + CALL [2] { + function: _+_ + args: { + CONSTANT [1] { value: "h" } + CONSTANT [3] { value: "e" } + } + } + CONSTANT [5] { value: "l" } + } + } + CONSTANT [7] { value: "l" } + } + } + CONSTANT [9] { value: "o" } + } + } + CONSTANT [11] { value: " world" } + } + } + } + args: { + CALL [20] { + function: _+_ + args: { + CALL [18] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [14] { + function: _+_ + args: { + CONSTANT [13] { value: "w" } + CONSTANT [15] { value: "o" } + } + } + CONSTANT [17] { value: "r" } + } + } + CONSTANT [19] { value: "l" } + } + } + CONSTANT [21] { value: "d" } + } + } + } +} +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: _+_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + } + } + loop_condition: { + CONSTANT [7] { value: false } + } + loop_step: { + IDENT [8] { + name: @r0 + } + } + result: { + COMPREHENSION [9] { + iter_var: #unused + iter_range: { + LIST [10] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + SELECT [11] { + IDENT [12] { + name: @r0 + }.single_int64 + } + } + loop_condition: { + CONSTANT [13] { value: false } + } + loop_step: { + IDENT [14] { + name: @r1 + } + } + result: { + CALL [15] { + function: _+_ + args: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: non_pure_custom_func + args: { + IDENT [18] { + name: @r1 + } + } + } + CALL [19] { + function: non_pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: @r0 + }.single_int32 + } + } + } + } + } + CALL [22] { + function: non_pure_custom_func + args: { + IDENT [23] { + name: @r1 + } + } + } + } + } + } + } + } + } + CALL [24] { + function: non_pure_custom_func + args: { + SELECT [25] { + IDENT [26] { + name: msg + }.single_int64 + } + } + } + } +} +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +CALL [1] { + function: _+_ + args: { + COMPREHENSION [2] { + iter_var: #unused + iter_range: { + LIST [3] { + elements: { + } + } + } + accu_var: @r0 + accu_init: { + SELECT [4] { + SELECT [5] { + IDENT [6] { + name: msg + }.oneof_type + }.payload + } + } + loop_condition: { + CONSTANT [7] { value: false } + } + loop_step: { + IDENT [8] { + name: @r0 + } + } + result: { + COMPREHENSION [9] { + iter_var: #unused + iter_range: { + LIST [10] { + elements: { + } + } + } + accu_var: @r1 + accu_init: { + CALL [11] { + function: pure_custom_func + args: { + SELECT [12] { + IDENT [13] { + name: @r0 + }.single_int64 + } + } + } + } + loop_condition: { + CONSTANT [14] { value: false } + } + loop_step: { + IDENT [15] { + name: @r1 + } + } + result: { + CALL [16] { + function: _+_ + args: { + CALL [17] { + function: _+_ + args: { + IDENT [18] { + name: @r1 + } + CALL [19] { + function: pure_custom_func + args: { + SELECT [20] { + IDENT [21] { + name: @r0 + }.single_int32 + } + } + } + } + } + IDENT [22] { + name: @r1 + } + } + } + } + } + } + } + CALL [23] { + function: pure_custom_func + args: { + SELECT [24] { + IDENT [25] { + name: msg + }.single_int64 + } + } + } + } +} \ No newline at end of file diff --git a/optimizer/src/test/resources/subexpression_unparsed.baseline b/optimizer/src/test/resources/subexpression_unparsed.baseline new file mode 100644 index 000000000..780664a14 --- /dev/null +++ b/optimizer/src/test/resources/subexpression_unparsed.baseline @@ -0,0 +1,794 @@ +Test case: SIZE_1 +Source: size([1,2]) + size([1,2]) + 1 == 5 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([size([1, 2])], @index0 + @index0 + 1 == 5) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2], size(@index0), @index1 + @index1, @index2 + 1], @index3 == 5) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([size([1, 2]), @index0 + @index0 + 1], @index1 == 5) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([size([1, 2])], @index0 + @index0 + 1 == 5) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([size([1, 2])], @index0 + @index0 + 1 == 5) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([size([1, 2])], @index0 + @index0 + 1 == 5) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([size([1, 2])], @index0 + @index0 + 1 == 5) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([size([1, 2])], @index0 + @index0 + 1 == 5) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([size([1, 2])], @index0 + @index0 + 1 == 5) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([size([1, 2])], @index0 + @index0 + 1 == 5) + +Test case: SIZE_2 +Source: 2 + size([1,2]) + size([1,2]) + 1 == 7 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([size([1, 2])], 2 + @index0 + @index0 + 1 == 7) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2], size(@index0), 2 + @index1, @index2 + @index1, @index3 + 1], @index4 == 7) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([size([1, 2]), 2 + @index0 + @index0], @index1 + 1 == 7) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([size([1, 2]), 2 + @index0 + @index0 + 1], @index1 == 7) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([size([1, 2])], 2 + @index0 + @index0 + 1 == 7) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([size([1, 2])], 2 + @index0 + @index0 + 1 == 7) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([size([1, 2])], 2 + @index0 + @index0 + 1 == 7) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([size([1, 2])], 2 + @index0 + @index0 + 1 == 7) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([size([1, 2])], 2 + @index0 + @index0 + 1 == 7) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([size([1, 2])], 2 + @index0 + @index0 + 1 == 7) + +Test case: SIZE_3 +Source: size([0]) + size([0]) + size([1,2]) + size([1,2]) == 6 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([size([0]), size([1, 2])], @index0 + @index0 + @index1 + @index1 == 6) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[0], size(@index0), [1, 2], size(@index2), @index1 + @index1, @index4 + @index3, @index5 + @index3], @index6 == 6) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([size([0]), size([1, 2]), @index0 + @index0 + @index1], @index2 + @index1 == 6) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([size([0]), size([1, 2]), @index0 + @index0 + @index1 + @index1], @index2 == 6) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([size([0]), size([1, 2])], @index0 + @index0 + @index1 + @index1 == 6) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([size([0]), size([1, 2])], @index0 + @index0 + @index1 + @index1 == 6) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([size([0]), size([1, 2])], @index0 + @index0 + @index1 + @index1 == 6) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([size([0]), size([1, 2])], @index0 + @index0 + @index1 + @index1 == 6) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([size([0]), size([1, 2])], @index0 + @index0 + @index1 + @index1 == 6) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([size([0]), size([1, 2])], @index0 + @index0 + @index1 + @index1 == 6) + +Test case: SIZE_4 +Source: 5 + size([0]) + size([0]) + size([1,2]) + size([1,2]) + size([1,2,3]) + size([1,2,3]) == 17 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([size([0]), size([1, 2]), size([1, 2, 3])], 5 + @index0 + @index0 + @index1 + @index1 + @index2 + @index2 == 17) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[0], size(@index0), [1, 2], size(@index2), [1, 2, 3], size(@index4), 5 + @index1, @index6 + @index1, @index7 + @index3, @index8 + @index3, @index9 + @index5, @index10 + @index5], @index11 == 17) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([size([0]), size([1, 2]), size([1, 2, 3]), 5 + @index0 + @index0, @index3 + @index1 + @index1, @index4 + @index2 + @index2], @index5 == 17) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([size([0]), size([1, 2]), size([1, 2, 3]), 5 + @index0 + @index0 + @index1, @index3 + @index1 + @index2 + @index2], @index4 == 17) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([size([0]), size([1, 2]), size([1, 2, 3]), 5 + @index0 + @index0 + @index1 + @index1], @index3 + @index2 + @index2 == 17) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([size([0]), size([1, 2]), size([1, 2, 3]), 5 + @index0 + @index0 + @index1 + @index1 + @index2], @index3 + @index2 == 17) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([size([0]), size([1, 2]), size([1, 2, 3]), 5 + @index0 + @index0 + @index1 + @index1 + @index2 + @index2], @index3 == 17) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([size([0]), size([1, 2]), size([1, 2, 3])], 5 + @index0 + @index0 + @index1 + @index1 + @index2 + @index2 == 17) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([size([0]), size([1, 2]), size([1, 2, 3])], 5 + @index0 + @index0 + @index1 + @index1 + @index2 + @index2 == 17) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([size([0]), size([1, 2]), size([1, 2, 3])], 5 + @index0 + @index0 + @index1 + @index1 + @index2 + @index2 == 17) + +Test case: TIMESTAMP +Source: timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(75))).getFullYear() + timestamp(int(timestamp(50))).getFullYear() + timestamp(int(timestamp(1000000000))).getFullYear() + timestamp(int(timestamp(50))).getSeconds() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(200))).getFullYear() + timestamp(int(timestamp(75))).getMinutes() + timestamp(int(timestamp(1000000000))).getFullYear() == 13934 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([timestamp(int(timestamp(1000000000))).getFullYear(), timestamp(int(timestamp(50))), timestamp(int(timestamp(200))).getFullYear(), timestamp(int(timestamp(75)))], @index0 + @index3.getFullYear() + @index1.getFullYear() + @index0 + @index1.getSeconds() + @index2 + @index2 + @index3.getMinutes() + @index0 == 13934) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([timestamp(1000000000), int(@index0), timestamp(@index1), @index2.getFullYear(), timestamp(50), int(@index4), timestamp(@index5), timestamp(200), int(@index7), timestamp(@index8), @index9.getFullYear(), timestamp(75), int(@index11), timestamp(@index12), @index13.getFullYear(), @index3 + @index14, @index6.getFullYear(), @index15 + @index16, @index17 + @index3, @index6.getSeconds(), @index18 + @index19, @index20 + @index10, @index21 + @index10, @index13.getMinutes(), @index22 + @index23, @index24 + @index3], @index25 == 13934) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([int(timestamp(1000000000)), timestamp(@index0).getFullYear(), int(timestamp(50)), int(timestamp(200)), timestamp(@index3).getFullYear(), int(timestamp(75)), timestamp(@index2), timestamp(@index5), @index1 + @index7.getFullYear(), @index8 + @index6.getFullYear(), @index9 + @index1 + @index6.getSeconds(), @index10 + @index4 + @index4, @index11 + @index7.getMinutes()], @index12 + @index1 == 13934) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([timestamp(int(timestamp(1000000000))), timestamp(int(timestamp(50))), timestamp(int(timestamp(200))), timestamp(int(timestamp(75))), @index0.getFullYear(), @index2.getFullYear(), @index4 + @index3.getFullYear() + @index1.getFullYear(), @index6 + @index4 + @index1.getSeconds() + @index5, @index7 + @index5 + @index3.getMinutes() + @index4], @index8 == 13934) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([timestamp(int(timestamp(1000000000))).getFullYear(), timestamp(int(timestamp(200))).getFullYear(), timestamp(int(timestamp(50))), timestamp(int(timestamp(75))), @index0 + @index3.getFullYear() + @index2.getFullYear() + @index0, @index4 + @index2.getSeconds() + @index1 + @index1], @index5 + @index3.getMinutes() + @index0 == 13934) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([timestamp(int(timestamp(1000000000))).getFullYear(), timestamp(int(timestamp(200))).getFullYear(), timestamp(int(timestamp(50))), timestamp(int(timestamp(75))), @index0 + @index3.getFullYear() + @index2.getFullYear() + @index0 + @index2.getSeconds()], @index4 + @index1 + @index1 + @index3.getMinutes() + @index0 == 13934) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([timestamp(int(timestamp(1000000000))).getFullYear(), timestamp(int(timestamp(200))).getFullYear(), timestamp(int(timestamp(50))), timestamp(int(timestamp(75))), @index0 + @index3.getFullYear() + @index2.getFullYear() + @index0 + @index2.getSeconds() + @index1], @index4 + @index1 + @index3.getMinutes() + @index0 == 13934) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([timestamp(int(timestamp(1000000000))).getFullYear(), timestamp(int(timestamp(200))).getFullYear(), timestamp(int(timestamp(50))), timestamp(int(timestamp(75))), @index0 + @index3.getFullYear() + @index2.getFullYear() + @index0 + @index2.getSeconds() + @index1 + @index1], @index4 + @index3.getMinutes() + @index0 == 13934) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([timestamp(int(timestamp(1000000000))).getFullYear(), timestamp(int(timestamp(200))).getFullYear(), timestamp(int(timestamp(50))), timestamp(int(timestamp(75))), @index0 + @index3.getFullYear() + @index2.getFullYear() + @index0 + @index2.getSeconds() + @index1 + @index1 + @index3.getMinutes()], @index4 + @index0 == 13934) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([timestamp(int(timestamp(1000000000))).getFullYear(), timestamp(int(timestamp(200))).getFullYear(), timestamp(int(timestamp(50))), timestamp(int(timestamp(75))), @index0 + @index3.getFullYear() + @index2.getFullYear() + @index0 + @index2.getSeconds() + @index1 + @index1 + @index3.getMinutes() + @index0], @index4 == 13934) + +Test case: MAP_INDEX +Source: {"a": 2}["a"] + {"a": 2}["a"] * {"a": 2}["a"] == 6 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([{"a": 2}["a"]], @index0 + @index0 * @index0 == 6) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([{"a": 2}, @index0["a"], @index1 * @index1, @index1 + @index2], @index3 == 6) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([{"a": 2}["a"], @index0 + @index0 * @index0], @index1 == 6) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([{"a": 2}["a"]], @index0 + @index0 * @index0 == 6) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([{"a": 2}["a"]], @index0 + @index0 * @index0 == 6) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([{"a": 2}["a"]], @index0 + @index0 * @index0 == 6) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([{"a": 2}["a"]], @index0 + @index0 * @index0 == 6) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([{"a": 2}["a"]], @index0 + @index0 * @index0 == 6) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([{"a": 2}["a"]], @index0 + @index0 * @index0 == 6) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([{"a": 2}["a"]], @index0 + @index0 * @index0 == 6) + +Test case: NESTED_MAP_CONSTRUCTION +Source: {'a': {'b': 1}, 'c': {'b': 1}, 'd': {'e': {'b': 1}}, 'e': {'e': {'b': 1}}} +=====> +Result: {a={b=1}, c={b=1}, d={e={b=1}}, e={e={b=1}}} +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([{"b": 1}, {"e": @index0}], {"a": @index0, "c": @index0, "d": @index1, "e": @index1}) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([{"b": 1}, {"e": @index0}], {"a": @index0, "c": @index0, "d": @index1, "e": @index1}) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([{"e": {"b": 1}}, {"b": 1}], {"a": @index1, "c": @index1, "d": @index0, "e": @index0}) + +Test case: NESTED_LIST_CONSTRUCTION +Source: [1, [1,2,3,4], 2, [1,2,3,4], 5, [1,2,3,4], 7, [[1,2], [1,2,3,4]], [1,2]] +=====> +Result: [1, [1, 2, 3, 4], 2, [1, 2, 3, 4], 5, [1, 2, 3, 4], 7, [[1, 2], [1, 2, 3, 4]], [1, 2]] +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2, 3, 4], [1, 2], [@index1, @index0]], [1, @index0, 2, @index0, 5, @index0, 7, @index2, @index1]) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1, 2, 3, 4], [1, 2]], [1, @index0, 2, @index0, 5, @index0, 7, [@index1, @index0], @index1]) + +Test case: SELECT +Source: msg.single_int64 + msg.single_int64 == 6 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.single_int64, @index0 + @index0], @index1 == 6) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.single_int64], @index0 + @index0 == 6) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.single_int64], @index0 + @index0 == 6) + +Test case: SELECT_NESTED_1 +Source: msg.oneof_type.payload.single_int64 + msg.oneof_type.payload.single_int32 + msg.oneof_type.payload.single_int64 + msg.single_int64 + msg.oneof_type.payload.oneof_type.payload.single_int64 == 31 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload, @index0.single_int64], @index1 + @index0.single_int32 + @index1 + msg.single_int64 + @index0.oneof_type.payload.single_int64 == 31) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64, @index1.single_int32, @index2 + @index3, @index4 + @index2, msg.single_int64, @index5 + @index6, @index1.oneof_type, @index8.payload, @index9.single_int64, @index7 + @index10], @index11 == 31) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.single_int64, @index1 + @index0.single_int32, @index2 + @index1 + msg.single_int64, @index0.oneof_type.payload, @index3 + @index4.single_int64], @index5 == 31) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload, @index0 + @index1.single_int32 + @index0, @index1.oneof_type.payload.single_int64, @index2 + msg.single_int64 + @index3], @index4 == 31) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload, @index0 + @index1.single_int32 + @index0 + msg.single_int64, @index2 + @index1.oneof_type.payload.single_int64], @index3 == 31) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload, @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64], @index2 == 31) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload], @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64 == 31) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload], @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64 == 31) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload], @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64 == 31) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.single_int64, msg.oneof_type.payload], @index0 + @index1.single_int32 + @index0 + msg.single_int64 + @index1.oneof_type.payload.single_int64 == 31) + +Test case: SELECT_NESTED_2 +Source: true || msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_bool || msg.oneof_type.payload.oneof_type.payload.oneof_type.child.child.payload.single_bool +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type], true || @index0.payload.oneof_type.payload.single_bool || @index0.child.child.payload.single_bool) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.oneof_type, @index2.payload, @index3.oneof_type, @index4.payload, @index5.oneof_type, @index6.payload, @index7.single_bool, true || @index8, @index4.child, @index10.child, @index11.payload, @index12.single_bool], @index9 || @index13) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.oneof_type.payload, @index1.oneof_type, @index2.payload.oneof_type, @index3.payload.single_bool, @index2.child.child, @index5.payload.single_bool], true || @index4 || @index6) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.oneof_type, @index0.payload.oneof_type, @index1.payload.oneof_type.payload, @index1.child.child.payload], true || @index2.single_bool || @index3.single_bool) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.oneof_type.payload, @index0.oneof_type, @index1.payload.oneof_type.payload.single_bool, @index1.child.child.payload.single_bool], true || @index2 || @index3) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type, true || @index0.payload.oneof_type.payload.single_bool], @index1 || @index0.child.child.payload.single_bool) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type], true || @index0.payload.oneof_type.payload.single_bool || @index0.child.child.payload.single_bool) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type], true || @index0.payload.oneof_type.payload.single_bool || @index0.child.child.payload.single_bool) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type], true || @index0.payload.oneof_type.payload.single_bool || @index0.child.child.payload.single_bool) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type], true || @index0.payload.oneof_type.payload.single_bool || @index0.child.child.payload.single_bool) + +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_1 +Source: msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[1] == 15 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.map_int32_int64, @index2[1], @index3 + @index3, @index4 + @index3], @index5 == 15) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.map_int32_int64[1], @index1 + @index1 + @index1], @index2 == 15) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.map_int32_int64, @index0[1]], @index1 + @index1 + @index1 == 15) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.map_int32_int64[1]], @index0 + @index0 + @index0 == 15) + +Test case: SELECT_NESTED_MESSAGE_MAP_INDEX_2 +Source: msg.oneof_type.payload.map_int32_int64[0] + msg.oneof_type.payload.map_int32_int64[1] + msg.oneof_type.payload.map_int32_int64[2] == 8 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.map_int32_int64, @index2[0], @index2[1], @index3 + @index4, @index2[2], @index5 + @index6], @index7 == 8) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.map_int32_int64, @index1[0] + @index1[1], @index2 + @index1[2]], @index3 == 8) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.map_int32_int64, @index0[0] + @index0[1] + @index0[2]], @index1 == 8) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.map_int32_int64], @index0[0] + @index0[1] + @index0[2] == 8) + +Test case: SELECT_NESTED_NO_COMMON_SUBEXPR +Source: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +=====> +Result: 0 +[BLOCK_COMMON_SUBEXPR_ONLY]: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.oneof_type, @index2.payload, @index3.oneof_type, @index4.payload, @index5.oneof_type, @index6.payload], @index7.single_int64) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.oneof_type.payload, @index1.oneof_type.payload, @index2.oneof_type.payload], @index3.single_int64) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.oneof_type, @index0.payload.oneof_type.payload], @index1.oneof_type.payload.single_int64) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.oneof_type.payload, @index0.oneof_type.payload.oneof_type.payload], @index1.single_int64) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type], @index0.payload.oneof_type.payload.single_int64) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type.payload], @index0.oneof_type.payload.single_int64) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type], @index0.payload.single_int64) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload], @index0.single_int64) +[BLOCK_RECURSION_DEPTH_9]: msg.oneof_type.payload.oneof_type.payload.oneof_type.payload.oneof_type.payload.single_int64 + +Test case: TERNARY +Source: (msg.single_int64 > 0 ? msg.single_int64 : 0) == 3 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.single_int64, @index0 > 0, @index1 ? @index0 : 0], @index2 == 3) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.single_int64, (@index0 > 0) ? @index0 : 0], @index1 == 3) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.single_int64], ((@index0 > 0) ? @index0 : 0) == 3) + +Test case: TERNARY_BIND_RHS_ONLY +Source: false ? false : (msg.single_int64) + ((msg.single_int64 + 1) * 2) == 11 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.single_int64], false ? false : (@index0 + (@index0 + 1) * 2 == 11)) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.single_int64, @index0 + 1, @index1 * 2, @index0 + @index2, @index3 == 11], false ? false : @index4) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.single_int64, (@index0 + 1) * 2, @index0 + @index1 == 11], false ? false : @index2) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.single_int64, @index0 + (@index0 + 1) * 2], false ? false : (@index1 == 11)) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.single_int64, @index0 + (@index0 + 1) * 2 == 11], false ? false : @index1) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.single_int64], false ? false : (@index0 + (@index0 + 1) * 2 == 11)) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.single_int64], false ? false : (@index0 + (@index0 + 1) * 2 == 11)) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.single_int64], false ? false : (@index0 + (@index0 + 1) * 2 == 11)) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.single_int64], false ? false : (@index0 + (@index0 + 1) * 2 == 11)) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.single_int64], false ? false : (@index0 + (@index0 + 1) * 2 == 11)) + +Test case: NESTED_TERNARY +Source: (msg.single_int64 > 0 ? (msg.single_int32 > 0 ? msg.single_int64 + msg.single_int32 : 0) : 0) == 8 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.single_int64, msg.single_int32, @index0 > 0, @index1 > 0, @index0 + @index1, @index3 ? @index4 : 0, @index2 ? @index5 : 0], @index6 == 8) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.single_int64, msg.single_int32, (@index1 > 0) ? (@index0 + @index1) : 0, (@index0 > 0) ? @index2 : 0], @index3 == 8) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.single_int64, msg.single_int32, (@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0], @index2 == 8) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.single_int64, msg.single_int32], ((@index0 > 0) ? ((@index1 > 0) ? (@index0 + @index1) : 0) : 0) == 8) + +Test case: MULTIPLE_MACROS_1 +Source: size([[1].exists(i, i > 0)]) + size([[1].exists(j, j > 0)]) + size([[2].exists(k, k > 1)]) + size([[2].exists(l, l > 1)]) == 4 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), size([@index0]), [2].exists(@it:0:0, @it:0:0 > 1), size([@index2])], @index1 + @index1 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1], [2]], size([@index0.exists(@it:0:0, @it:0:0 > 0)]) + size([@index0.exists(@it:0:0, @it:0:0 > 0)]) + size([@index1.exists(@it:0:0, @it:0:0 > 1)]) + size([@index1.exists(@it:0:0, @it:0:0 > 1)]) == 4) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1], [2]], size([@index0.exists(@it:0:0, @it:0:0 > 0)]) + size([@index0.exists(@it:0:0, @it:0:0 > 0)]) + size([@index1.exists(@it:0:0, @it:0:0 > 1)]) + size([@index1.exists(@it:0:0, @it:0:0 > 1)]) == 4) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), [2].exists(@it:0:0, @it:0:0 > 1), size([@index0]), size([@index1]), @index2 + @index2 + @index3 + @index3], @index4 == 4) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), [2].exists(@it:0:0, @it:0:0 > 1), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), [2].exists(@it:0:0, @it:0:0 > 1), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), [2].exists(@it:0:0, @it:0:0 > 1), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), [2].exists(@it:0:0, @it:0:0 > 1), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), [2].exists(@it:0:0, @it:0:0 > 1), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), [2].exists(@it:0:0, @it:0:0 > 1), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) + +Test case: MULTIPLE_MACROS_2 +Source: [[1].exists(i, i > 0)] + [[1].exists(j, j > 0)] + [['a'].exists(k, k == 'a')] + [['a'].exists(l, l == 'a')] == [true, true, true, true] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), [@index0], ["a"].exists(@it:0:1, @it:0:1 == "a"), [@index2]], @index1 + @index1 + @index3 + @index3 == [true, true, true, true]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1], ["a"], [true, true, true, true]], [@index0.exists(@it:0:0, @it:0:0 > 0)] + [@index0.exists(@it:0:0, @it:0:0 > 0)] + [@index1.exists(@it:0:1, @it:0:1 == "a")] + [@index1.exists(@it:0:1, @it:0:1 == "a")] == @index2) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1], ["a"], [true, true, true, true]], [@index0.exists(@it:0:0, @it:0:0 > 0)] + [@index0.exists(@it:0:0, @it:0:0 > 0)] + [@index1.exists(@it:0:1, @it:0:1 == "a")] + [@index1.exists(@it:0:1, @it:0:1 == "a")] == @index2) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), ["a"].exists(@it:0:1, @it:0:1 == "a"), [@index0], [@index1], @index2 + @index2 + @index3 + @index3], @index4 == [true, true, true, true]) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), ["a"].exists(@it:0:1, @it:0:1 == "a"), [@index0], [@index1]], @index2 + @index2 + @index3 + @index3 == [true, true, true, true]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), ["a"].exists(@it:0:1, @it:0:1 == "a"), [@index0], [@index1]], @index2 + @index2 + @index3 + @index3 == [true, true, true, true]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), ["a"].exists(@it:0:1, @it:0:1 == "a"), [@index0], [@index1]], @index2 + @index2 + @index3 + @index3 == [true, true, true, true]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), ["a"].exists(@it:0:1, @it:0:1 == "a"), [@index0], [@index1]], @index2 + @index2 + @index3 + @index3 == [true, true, true, true]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), ["a"].exists(@it:0:1, @it:0:1 == "a"), [@index0], [@index1]], @index2 + @index2 + @index3 + @index3 == [true, true, true, true]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0), ["a"].exists(@it:0:1, @it:0:1 == "a"), [@index0], [@index1]], @index2 + @index2 + @index3 + @index3 == [true, true, true, true]) + +Test case: MULTIPLE_MACROS_3 +Source: [1].exists(i, i > 0) && [1].exists(j, j > 0) && [1].exists(k, k > 1) && [2].exists(l, l > 1) +=====> +Result: false +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it:0:0 > 1) && [2].exists(@it:0:0, @it:0:0 > 1)) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1], [2]], @index0.exists(@it:0:0, @it:0:0 > 0) && @index0.exists(@it:0:0, @it:0:0 > 0) && @index0.exists(@it:0:0, @it:0:0 > 1) && @index1.exists(@it:0:0, @it:0:0 > 1)) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1], [2]], @index0.exists(@it:0:0, @it:0:0 > 0) && @index0.exists(@it:0:0, @it:0:0 > 0) && @index0.exists(@it:0:0, @it:0:0 > 1) && @index1.exists(@it:0:0, @it:0:0 > 1)) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it:0:0 > 1) && [2].exists(@it:0:0, @it:0:0 > 1)) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it:0:0 > 1) && [2].exists(@it:0:0, @it:0:0 > 1)) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it:0:0 > 1) && [2].exists(@it:0:0, @it:0:0 > 1)) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it:0:0 > 1) && [2].exists(@it:0:0, @it:0:0 > 1)) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it:0:0 > 1) && [2].exists(@it:0:0, @it:0:0 > 1)) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it:0:0 > 1) && [2].exists(@it:0:0, @it:0:0 > 1)) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1].exists(@it:0:0, @it:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it:0:0 > 1) && [2].exists(@it:0:0, @it:0:0 > 1)) + +Test case: MULTIPLE_MACROS_COMP_V2_1 +Source: size([[1].exists(i,x,i > 0 && x >= 0)]) + size([[1].exists(j, y, j > 0 && y >= 0)]) + size([[2].exists(k,z,k > 1 && z >= 0)]) + size([[2].exists(l, w, l > 1 && w >= 0)]) == 4 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0), size([@index0]), [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0), size([@index2])], @index1 + @index1 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1], [2]], size([@index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0)]) + size([@index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0)]) + size([@index1.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0)]) + size([@index1.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0)]) == 4) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1], [2]], size([@index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0)]) + size([@index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0)]) + size([@index1.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0)]) + size([@index1.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0)]) == 4) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1], [2]], size([@index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0)]) + size([@index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0)]) + size([@index1.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0)]) + size([@index1.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0)]) == 4) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0), [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0), [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0), [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0), [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0), [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 >= 0), [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 >= 0), size([@index0]), size([@index1])], @index2 + @index2 + @index3 + @index3 == 4) + +Test case: MULTIPLE_MACROS_COMP_V2_2 +Source: [1].exists(i, x, i > 0 && x > 0) && [1].exists(j, y, j > 0 && y > 0) && [1].exists(k, z, k > 1 && z > 0) && [2].exists(l, w, l > 1 && w > 0) +=====> +Result: false +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1], [2]], @index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0) && @index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0) && @index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && @index1.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1], [2]], @index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0) && @index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0) && @index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && @index1.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1], [2]], @index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0) && @index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0) && @index0.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && @index1.exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1].exists(@it:0:0, @it2:0:0, @it:0:0 > 0 && @it2:0:0 > 0)], @index0 && @index0 && [1].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0) && [2].exists(@it:0:0, @it2:0:0, @it:0:0 > 1 && @it2:0:0 > 0)) + +Test case: NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [[2, 3, 4], [2, 3, 4], [2, 3, 4]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2, 3], [2, 3, 4]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2, 3], [2, 3, 4], [@index1, @index1, @index1]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == @index2) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1, 2, 3], [2, 3, 4], [@index1, @index1, @index1]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == @index2) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1, 2, 3], [2, 3, 4], [@index1, @index1, @index1]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == @index2) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1, 2, 3], [2, 3, 4], @index0.map(@it:0:0, @it:0:0 + 1)], @index0.map(@it:1:0, @index2) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1, 2, 3], [2, 3, 4], @index0.map(@it:0:0, @it:0:0 + 1)], @index0.map(@it:1:0, @index2) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1, 2, 3], [2, 3, 4], @index0.map(@it:0:0, @it:0:0 + 1)], @index0.map(@it:1:0, @index2) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1, 2, 3], [2, 3, 4]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1, 2, 3], [2, 3, 4]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1, 2, 3], [2, 3, 4]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == [@index1, @index1, @index1]) + +Test case: NESTED_MACROS_2 +Source: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2], [1, 2, 3], [1], [2], [@index2, @index3]], @index0.map(@it:1:0, @index1.filter(@it:0:0, @it:0:0 == @it:1:0)) == @index4) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.map(@it:1:0, @index2.filter(@it:0:0, @it:0:0 == @it:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.map(@it:1:0, @index2.filter(@it:0:0, @it:0:0 == @it:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.map(@it:1:0, @index2.filter(@it:0:0, @it:0:0 == @it:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.map(@it:1:0, @index2.filter(@it:0:0, @it:0:0 == @it:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.map(@it:1:0, @index2.filter(@it:0:0, @it:0:0 == @it:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_7]: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +[BLOCK_RECURSION_DEPTH_8]: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] +[BLOCK_RECURSION_DEPTH_9]: [1, 2].map(y, [1, 2, 3].filter(x, x == y)) == [[1], [2]] + +Test case: NESTED_MACROS_3 +Source: [1,2,3].map(i, i * 2) + [1,2,3].map(i, i * 2).map(i, i * 2) +=====> +Result: [2, 4, 6, 4, 8, 12] +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 * 2)], @index0 + @index0.map(@it:1:0, @it:1:0 * 2)) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2, 3]], @index0.map(@it:0:0, @it:0:0 * 2) + @index0.map(@it:0:0, @it:0:0 * 2).map(@it:1:0, @it:1:0 * 2)) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1, 2, 3]], @index0.map(@it:0:0, @it:0:0 * 2) + @index0.map(@it:0:0, @it:0:0 * 2).map(@it:1:0, @it:1:0 * 2)) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1, 2, 3]], @index0.map(@it:0:0, @it:0:0 * 2) + @index0.map(@it:0:0, @it:0:0 * 2).map(@it:1:0, @it:1:0 * 2)) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 * 2)], @index0 + @index0.map(@it:1:0, @it:1:0 * 2)) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 * 2)], @index0 + @index0.map(@it:1:0, @it:1:0 * 2)) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 * 2)], @index0 + @index0.map(@it:1:0, @it:1:0 * 2)) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 * 2)], @index0 + @index0.map(@it:1:0, @it:1:0 * 2)) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 * 2)], @index0 + @index0.map(@it:1:0, @it:1:0 * 2)) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 * 2)], @index0 + @index0.map(@it:1:0, @it:1:0 * 2)) + +Test case: NESTED_MACROS_COMP_V2_1 +Source: [1,2,3].transformList(i, v, [1, 2, 3].transformList(i, v, i + v + 1)) == [[2, 4, 6], [2, 4, 6], [2, 4, 6]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2, 3], [2, 4, 6]], @index0.transformList(@it:1:0, @it2:1:0, @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2, 3], [2, 4, 6], [@index1, @index1, @index1]], @index0.transformList(@it:1:0, @it2:1:0, @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == @index2) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1, 2, 3], [2, 4, 6], [@index1, @index1, @index1]], @index0.transformList(@it:1:0, @it2:1:0, @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == @index2) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1, 2, 3], [2, 4, 6], [@index1, @index1, @index1]], @index0.transformList(@it:1:0, @it2:1:0, @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == @index2) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1, 2, 3], [2, 4, 6], [@index1, @index1, @index1]], @index0.transformList(@it:1:0, @it2:1:0, @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == @index2) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1, 2, 3], [2, 4, 6], @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)], @index0.transformList(@it:1:0, @it2:1:0, @index2) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1, 2, 3], [2, 4, 6], @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)], @index0.transformList(@it:1:0, @it2:1:0, @index2) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1, 2, 3], [2, 4, 6], @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)], @index0.transformList(@it:1:0, @it2:1:0, @index2) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1, 2, 3], [2, 4, 6]], @index0.transformList(@it:1:0, @it2:1:0, @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == [@index1, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1, 2, 3], [2, 4, 6]], @index0.transformList(@it:1:0, @it2:1:0, @index0.transformList(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == [@index1, @index1, @index1]) + +Test case: NESTED_MACROS_COMP_V2_2 +Source: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2], [1, 2, 3], [1], [2], [@index2, @index3]], @index0.transformList(@it:1:0, @it2:1:0, @index1.filter(@it:0:0, @it:0:0 == @it2:1:0 && @it:1:0 < @it2:1:0)) == @index4) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.transformList(@it:1:0, @it2:1:0, @index2.filter(@it:0:0, @it:0:0 == @it2:1:0 && @it:1:0 < @it2:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.transformList(@it:1:0, @it2:1:0, @index2.filter(@it:0:0, @it:0:0 == @it2:1:0 && @it:1:0 < @it2:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.transformList(@it:1:0, @it2:1:0, @index2.filter(@it:0:0, @it:0:0 == @it2:1:0 && @it:1:0 < @it2:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.transformList(@it:1:0, @it2:1:0, @index2.filter(@it:0:0, @it:0:0 == @it2:1:0 && @it:1:0 < @it2:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[[1], [2]], [1, 2], [1, 2, 3]], @index1.transformList(@it:1:0, @it2:1:0, @index2.filter(@it:0:0, @it:0:0 == @it2:1:0 && @it:1:0 < @it2:1:0)) == @index0) +[BLOCK_RECURSION_DEPTH_7]: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +[BLOCK_RECURSION_DEPTH_8]: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] +[BLOCK_RECURSION_DEPTH_9]: [1, 2].transformList(i, y, [1, 2, 3].filter(x, x == y && i < y)) == [[1], [2]] + +Test case: ADJACENT_NESTED_MACROS +Source: [1,2,3].map(i, [1, 2, 3].map(i, i + 1)) == [1,2,3].map(j, [1, 2, 3].map(j, j + 1)) +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2, 3], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1))], @index1 == @index1) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2, 3]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1))) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1, 2, 3]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1))) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1, 2, 3]], @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1)) == @index0.map(@it:1:0, @index0.map(@it:0:0, @it:0:0 + 1))) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 + 1), [1, 2, 3].map(@it:1:0, @index0)], @index1 == @index1) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 + 1), [1, 2, 3].map(@it:1:0, @index0)], @index1 == @index1) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1, 2, 3].map(@it:0:0, @it:0:0 + 1), [1, 2, 3].map(@it:1:0, @index0)], @index1 == @index1) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1, 2, 3].map(@it:1:0, [1, 2, 3].map(@it:0:0, @it:0:0 + 1))], @index0 == @index0) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1, 2, 3].map(@it:1:0, [1, 2, 3].map(@it:0:0, @it:0:0 + 1))], @index0 == @index0) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1, 2, 3].map(@it:1:0, [1, 2, 3].map(@it:0:0, @it:0:0 + 1))], @index0 == @index0) + +Test case: ADJACENT_NESTED_MACROS_COMP_V2 +Source: [1,2,3].transformMap(i, x, [1, 2, 3].transformMap(i, x, i + x + 1)) == [1,2,3].transformMap(j, y, [1, 2, 3].transformMap(j, y, j + y + 1)) +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2, 3], @index0.transformMap(@it:1:0, @it2:1:0, @index0.transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1))], @index1 == @index1) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2, 3]], @index0.transformMap(@it:1:0, @it2:1:0, @index0.transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == @index0.transformMap(@it:1:0, @it2:1:0, @index0.transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1))) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[1, 2, 3]], @index0.transformMap(@it:1:0, @it2:1:0, @index0.transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == @index0.transformMap(@it:1:0, @it2:1:0, @index0.transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1))) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[1, 2, 3]], @index0.transformMap(@it:1:0, @it2:1:0, @index0.transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1)) == @index0.transformMap(@it:1:0, @it2:1:0, @index0.transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1))) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[1, 2, 3].transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1), [1, 2, 3].transformMap(@it:1:0, @it2:1:0, @index0)], @index1 == @index1) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[1, 2, 3].transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1), [1, 2, 3].transformMap(@it:1:0, @it2:1:0, @index0)], @index1 == @index1) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[1, 2, 3].transformMap(@it:1:0, @it2:1:0, [1, 2, 3].transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1))], @index0 == @index0) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[1, 2, 3].transformMap(@it:1:0, @it2:1:0, [1, 2, 3].transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1))], @index0 == @index0) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[1, 2, 3].transformMap(@it:1:0, @it2:1:0, [1, 2, 3].transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1))], @index0 == @index0) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[1, 2, 3].transformMap(@it:1:0, @it2:1:0, [1, 2, 3].transformMap(@it:0:0, @it2:0:0, @it:0:0 + @it2:0:0 + 1))], @index0 == @index0) + +Test case: INCLUSION_LIST +Source: 1 in [1,2,3] && 2 in [1,2,3] && 3 in [3, [1,2,3]] && 1 in [1,2,3] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2, 3], 1 in @index0], @index1 && 2 in @index0 && 3 in [3, @index0] && @index1) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2, 3], 1 in @index0, 2 in @index0, @index1 && @index2, [3, @index0], 3 in @index4, @index5 && @index1], @index3 && @index6) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([1 in [1, 2, 3], [1, 2, 3], @index0 && 2 in @index1, 3 in [3, @index1]], @index2 && @index3 && @index0) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([1 in [1, 2, 3], [1, 2, 3], 3 in [3, @index1] && @index0], @index0 && 2 in @index1 && @index2) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([1 in [1, 2, 3], [1, 2, 3]], @index0 && 2 in @index1 && 3 in [3, @index1] && @index0) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([1 in [1, 2, 3], [1, 2, 3]], @index0 && 2 in @index1 && 3 in [3, @index1] && @index0) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([1 in [1, 2, 3], [1, 2, 3]], @index0 && 2 in @index1 && 3 in [3, @index1] && @index0) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([1 in [1, 2, 3], [1, 2, 3]], @index0 && 2 in @index1 && 3 in [3, @index1] && @index0) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([1 in [1, 2, 3], [1, 2, 3]], @index0 && 2 in @index1 && 3 in [3, @index1] && @index0) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([1 in [1, 2, 3], [1, 2, 3]], @index0 && 2 in @index1 && 3 in [3, @index1] && @index0) + +Test case: INCLUSION_MAP +Source: 2 in {'a': 1, 2: {true: false}, 3: {true: false}} +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([{true: false}], 2 in {"a": 1, 2: @index0, 3: @index0}) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([{true: false}, {"a": 1, 2: @index0, 3: @index0}], 2 in @index1) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([{true: false}], 2 in {"a": 1, 2: @index0, 3: @index0}) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([{true: false}], 2 in {"a": 1, 2: @index0, 3: @index0}) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([{true: false}], 2 in {"a": 1, 2: @index0, 3: @index0}) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([{true: false}], 2 in {"a": 1, 2: @index0, 3: @index0}) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([{true: false}], 2 in {"a": 1, 2: @index0, 3: @index0}) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([{true: false}], 2 in {"a": 1, 2: @index0, 3: @index0}) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([{true: false}], 2 in {"a": 1, 2: @index0, 3: @index0}) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([{true: false}], 2 in {"a": 1, 2: @index0, 3: @index0}) + +Test case: MACRO_ITER_VAR_NOT_REFERENCED +Source: [1,2].map(i, [1, 2].map(i, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2], [3, 4], [@index1, @index1]], @index0.map(@it:1:0, @index0.map(@it:0:0, @index1)) == [@index2, @index2]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2], [3, 4], [@index1, @index1], [@index1], [@index2, @index2]], @index0.map(@it:1:0, @index0.map(@it:0:0, @index1)) == @index4) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[[3, 4], [3, 4]], [1, 2], [[3, 4]], @index1.map(@it:0:0, [3, 4]), [@index3]], @index1.map(@it:1:0, @index3) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[[3, 4], [3, 4]], [1, 2], [[3, 4]], @index1.map(@it:0:0, [3, 4])], @index1.map(@it:1:0, @index3) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[[3, 4], [3, 4]], [1, 2], @index1.map(@it:0:0, [3, 4])], @index1.map(@it:1:0, @index2) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[[3, 4], [3, 4]], [1, 2], @index1.map(@it:0:0, [3, 4])], @index1.map(@it:1:0, @index2) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[[3, 4], [3, 4]], [1, 2], @index1.map(@it:0:0, [3, 4])], @index1.map(@it:1:0, @index2) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[[3, 4], [3, 4]], [1, 2]], @index1.map(@it:1:0, @index1.map(@it:0:0, [3, 4])) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[[3, 4], [3, 4]], [1, 2]], @index1.map(@it:1:0, @index1.map(@it:0:0, [3, 4])) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[[3, 4], [3, 4]], [1, 2]], @index1.map(@it:1:0, @index1.map(@it:0:0, [3, 4])) == [@index0, @index0]) + +Test case: MACRO_ITER_VAR2_NOT_REFERENCED +Source: [1,2].transformList(i, v, [1, 2].transformList(i, v, [3,4])) == [[[3, 4], [3, 4]], [[3, 4], [3, 4]]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([[1, 2], [3, 4], [@index1, @index1]], @index0.transformList(@it:1:0, @it2:1:0, @index0.transformList(@it:0:0, @it2:0:0, @index1)) == [@index2, @index2]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([[1, 2], [3, 4], [@index1, @index1], [@index1], [@index2, @index2]], @index0.transformList(@it:1:0, @it2:1:0, @index0.transformList(@it:0:0, @it2:0:0, @index1)) == @index4) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[[3, 4], [3, 4]], [1, 2], [[3, 4]], @index1.transformList(@it:0:0, @it2:0:0, [3, 4]), [@index3]], @index1.transformList(@it:1:0, @it2:1:0, @index3) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[[3, 4], [3, 4]], [1, 2], [[3, 4]], @index1.transformList(@it:0:0, @it2:0:0, [3, 4])], @index1.transformList(@it:1:0, @it2:1:0, @index3) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[[3, 4], [3, 4]], [1, 2], @index1.transformList(@it:0:0, @it2:0:0, [3, 4])], @index1.transformList(@it:1:0, @it2:1:0, @index2) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[[3, 4], [3, 4]], [1, 2], @index1.transformList(@it:0:0, @it2:0:0, [3, 4])], @index1.transformList(@it:1:0, @it2:1:0, @index2) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[[3, 4], [3, 4]], [1, 2], @index1.transformList(@it:0:0, @it2:0:0, [3, 4])], @index1.transformList(@it:1:0, @it2:1:0, @index2) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[[3, 4], [3, 4]], [1, 2]], @index1.transformList(@it:1:0, @it2:1:0, @index1.transformList(@it:0:0, @it2:0:0, [3, 4])) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[[3, 4], [3, 4]], [1, 2]], @index1.transformList(@it:1:0, @it2:1:0, @index1.transformList(@it:0:0, @it2:0:0, [3, 4])) == [@index0, @index0]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[[3, 4], [3, 4]], [1, 2]], @index1.transformList(@it:1:0, @it2:1:0, @index1.transformList(@it:0:0, @it2:0:0, [3, 4])) == [@index0, @index0]) + +Test case: MACRO_SHADOWED_VARIABLE +Source: [x - 1 > 3 ? x - 1 : 5].exists(x, x - 1 > 3) || x - 1 > 3 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([x - 1, @index0 > 3], [@index1 ? @index0 : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index1) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([x - 1, @index0 > 3, @index1 ? @index0 : 5, [@index2]], @index3.exists(@it:0:0, @it:0:0 - 1 > 3) || @index1) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([x - 1 > 3, @index0 ? (x - 1) : 5, [@index1]], @index2.exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([x - 1 > 3, [@index0 ? (x - 1) : 5]], @index1.exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([x - 1 > 3], [@index0 ? (x - 1) : 5].exists(@it:0:0, @it:0:0 - 1 > 3) || @index0) + +Test case: MACRO_SHADOWED_VARIABLE_2 +Source: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +=====> +Result: [[[foofoo, foofoo, foofoo, foofoo], [foofoo, foofoo, foofoo, foofoo]], [[barbar, barbar, barbar, barbar], [barbar, barbar, barbar, barbar]]] +[BLOCK_COMMON_SUBEXPR_ONLY]: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([["foo", "bar"]], @index0.map(@it:0:0, [@it:0:0 + @it:0:0, @it:0:0 + @it:0:0]).map(@it:1:0, [@it:1:0 + @it:1:0, @it:1:0 + @it:1:0])) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([["foo", "bar"]], @index0.map(@it:0:0, [@it:0:0 + @it:0:0, @it:0:0 + @it:0:0]).map(@it:1:0, [@it:1:0 + @it:1:0, @it:1:0 + @it:1:0])) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([["foo", "bar"]], @index0.map(@it:0:0, [@it:0:0 + @it:0:0, @it:0:0 + @it:0:0]).map(@it:1:0, [@it:1:0 + @it:1:0, @it:1:0 + @it:1:0])) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([["foo", "bar"]], @index0.map(@it:0:0, [@it:0:0 + @it:0:0, @it:0:0 + @it:0:0]).map(@it:1:0, [@it:1:0 + @it:1:0, @it:1:0 + @it:1:0])) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([["foo", "bar"].map(@it:0:0, [@it:0:0 + @it:0:0, @it:0:0 + @it:0:0])], @index0.map(@it:1:0, [@it:1:0 + @it:1:0, @it:1:0 + @it:1:0])) +[BLOCK_RECURSION_DEPTH_6]: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +[BLOCK_RECURSION_DEPTH_7]: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +[BLOCK_RECURSION_DEPTH_8]: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) +[BLOCK_RECURSION_DEPTH_9]: ["foo", "bar"].map(x, [x + x, x + x]).map(x, [x + x, x + x]) + +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_1 +Source: [x - y - 1 > 3 ? x - y - 1 : 5].exists(x, y, x - y - 1 > 3) || x - y - 1 > 3 +=====> +Result: false +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([x - y - 1, @index0 > 3], [@index1 ? @index0 : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index1) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([x - y, @index0 - 1, @index1 > 3, @index2 ? @index1 : 5, [@index3]], @index4.exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index2) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([x - y - 1, @index0 > 3, [@index1 ? @index0 : 5]], @index2.exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index1) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([x - y - 1 > 3, @index0 ? (x - y - 1) : 5, [@index1]], @index2.exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([x - y - 1 > 3, [@index0 ? (x - y - 1) : 5]], @index1.exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([x - y - 1 > 3], [@index0 ? (x - y - 1) : 5].exists(@it:0:0, @it2:0:0, @it:0:0 - @it2:0:0 - 1 > 3) || @index0) + +Test case: MACRO_SHADOWED_VARIABLE_COMP_V2_2 +Source: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +=====> +Result: {0=[0, [0, foofoo, 0, foofoo]], 1=[2, [2, barbar, 2, barbar]]} +[BLOCK_COMMON_SUBEXPR_ONLY]: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([["foo", "bar"]], @index0.transformMap(@it:0:0, @it2:0:0, [@it:0:0 + @it:0:0, @it2:0:0 + @it2:0:0]).transformMap(@it:1:0, @it2:1:0, [@it:1:0 + @it:1:0, @it2:1:0 + @it2:1:0])) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([["foo", "bar"]], @index0.transformMap(@it:0:0, @it2:0:0, [@it:0:0 + @it:0:0, @it2:0:0 + @it2:0:0]).transformMap(@it:1:0, @it2:1:0, [@it:1:0 + @it:1:0, @it2:1:0 + @it2:1:0])) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([["foo", "bar"]], @index0.transformMap(@it:0:0, @it2:0:0, [@it:0:0 + @it:0:0, @it2:0:0 + @it2:0:0]).transformMap(@it:1:0, @it2:1:0, [@it:1:0 + @it:1:0, @it2:1:0 + @it2:1:0])) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([["foo", "bar"].transformMap(@it:0:0, @it2:0:0, [@it:0:0 + @it:0:0, @it2:0:0 + @it2:0:0])], @index0.transformMap(@it:1:0, @it2:1:0, [@it:1:0 + @it:1:0, @it2:1:0 + @it2:1:0])) +[BLOCK_RECURSION_DEPTH_5]: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +[BLOCK_RECURSION_DEPTH_6]: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +[BLOCK_RECURSION_DEPTH_7]: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +[BLOCK_RECURSION_DEPTH_8]: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) +[BLOCK_RECURSION_DEPTH_9]: ["foo", "bar"].transformMap(x, y, [x + x, y + y]).transformMap(x, y, [x + x, y + y]) + +Test case: PRESENCE_TEST +Source: has({'a': true}.a) && {'a':true}['a'] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([{"a": true}], has(@index0.a) && @index0["a"]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([{"a": true}, has(@index0.a), @index0["a"]], @index1 && @index2) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([{"a": true}], has(@index0.a) && @index0["a"]) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([{"a": true}], has(@index0.a) && @index0["a"]) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([{"a": true}], has(@index0.a) && @index0["a"]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([{"a": true}], has(@index0.a) && @index0["a"]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([{"a": true}], has(@index0.a) && @index0["a"]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([{"a": true}], has(@index0.a) && @index0["a"]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([{"a": true}], has(@index0.a) && @index0["a"]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([{"a": true}], has(@index0.a) && @index0["a"]) + +Test case: PRESENCE_TEST_2 +Source: has({'a': true}.a) && has({'a': true}.a) +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([has({"a": true}.a)], @index0 && @index0) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([{"a": true}, has(@index0.a)], @index1 && @index1) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([has({"a": true}.a)], @index0 && @index0) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([has({"a": true}.a)], @index0 && @index0) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([has({"a": true}.a)], @index0 && @index0) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([has({"a": true}.a)], @index0 && @index0) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([has({"a": true}.a)], @index0 && @index0) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([has({"a": true}.a)], @index0 && @index0) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([has({"a": true}.a)], @index0 && @index0) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([has({"a": true}.a)], @index0 && @index0) + +Test case: PRESENCE_TEST_WITH_TERNARY +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : 0) == 10 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, has(@index0.payload), @index0.payload, @index2.single_int64, @index1 ? @index3 : 0], @index4 == 10) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type, @index0.payload.single_int64, has(@index0.payload) ? @index1 : 0], @index2 == 10) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type, has(@index0.payload) ? @index0.payload.single_int64 : 0], @index1 == 10) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type], (has(@index0.payload) ? @index0.payload.single_int64 : 0) == 10) + +Test case: PRESENCE_TEST_WITH_TERNARY_2 +Source: (has(msg.oneof_type.payload) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type, @index0.payload.single_int64], (has(@index0.payload) ? @index1 : (@index1 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64, has(@index0.payload), @index2 * 0, @index3 ? @index2 : @index4], @index5 == 10) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.single_int64, has(msg.oneof_type.payload), @index2 ? @index1 : (@index1 * 0)], @index3 == 10) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64, has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)], @index1 == 10) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload) ? @index0 : (@index0 * 0)) == 10) + +Test case: PRESENCE_TEST_WITH_TERNARY_3 +Source: (has(msg.oneof_type.payload.single_int64) ? msg.oneof_type.payload.single_int64 : msg.oneof_type.payload.single_int64 * 0) == 10 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload, @index0.single_int64], (has(@index0.single_int64) ? @index1 : (@index1 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64, has(@index1.single_int64), @index2 * 0, @index3 ? @index2 : @index4], @index5 == 10) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.single_int64, has(@index0.single_int64) ? @index1 : (@index1 * 0)], @index2 == 10) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64, has(msg.oneof_type.payload.single_int64)], (@index1 ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.single_int64, has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)], @index1 == 10) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.single_int64], (has(msg.oneof_type.payload.single_int64) ? @index0 : (@index0 * 0)) == 10) + +Test case: PRESENCE_TEST_WITH_TERNARY_NESTED +Source: (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(msg.oneof_type.payload.single_int64)) ? ((has(msg.oneof_type.payload.map_string_string) && has(msg.oneof_type.payload.map_string_string.key)) ? msg.oneof_type.payload.map_string_string.key == 'A' : false) : false +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type, @index0.payload, @index1.map_string_string], (has(msg.oneof_type) && has(@index0.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index2.key)) ? (@index2.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.map_string_string, has(msg.oneof_type), has(@index0.payload), @index3 && @index4, has(@index1.single_int64), @index5 && @index6, has(@index1.map_string_string), has(@index2.key), @index8 && @index9, @index2.key, @index11 == "A", @index10 ? @index12 : false], @index7 ? @index13 : false) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.map_string_string, has(msg.oneof_type.payload), has(msg.oneof_type) && @index2, @index3 && has(@index0.single_int64), has(@index0.map_string_string) && has(@index1.key), @index1.key == "A"], @index4 ? (@index5 ? @index6 : false) : false) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload, has(msg.oneof_type) && has(msg.oneof_type.payload), (has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false], (@index2 && has(@index1.single_int64)) ? @index3 : false) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload, has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)], @index2 ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.map_string_string, msg.oneof_type.payload], (has(msg.oneof_type) && has(msg.oneof_type.payload) && has(@index1.single_int64)) ? ((has(@index1.map_string_string) && has(@index0.key)) ? (@index0.key == "A") : false) : false) + +Test case: OPTIONAL_LIST +Source: [10, ?optional.none(), [?optional.none(), ?opt_x], [?optional.none(), ?opt_x]] == [10, [5], [5]] +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([optional.none(), [?@index0, ?opt_x], [5]], [10, ?@index0, @index1, @index1] == [10, @index2, @index2]) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([optional.none(), [?@index0, ?opt_x], [5], [10, ?@index0, @index1, @index1], [10, @index2, @index2]], @index3 == @index4) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([[?optional.none(), ?opt_x], [5], [10, ?optional.none(), @index0, @index0]], @index2 == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([[?optional.none(), ?opt_x], [5]], [10, ?optional.none(), @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([[?optional.none(), ?opt_x], [5]], [10, ?optional.none(), @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([[?optional.none(), ?opt_x], [5]], [10, ?optional.none(), @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([[?optional.none(), ?opt_x], [5]], [10, ?optional.none(), @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([[?optional.none(), ?opt_x], [5]], [10, ?optional.none(), @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([[?optional.none(), ?opt_x], [5]], [10, ?optional.none(), @index0, @index0] == [10, @index1, @index1]) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([[?optional.none(), ?opt_x], [5]], [10, ?optional.none(), @index0, @index0] == [10, @index1, @index1]) + +Test case: OPTIONAL_MAP +Source: {?'hello': optional.of('hello')}['hello'] + {?'hello': optional.of('hello')}['hello'] == 'hellohello' +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([{?"hello": optional.of("hello")}["hello"]], @index0 + @index0 == "hellohello") +[BLOCK_RECURSION_DEPTH_1]: cel.@block([optional.of("hello"), {?"hello": @index0}, @index1["hello"], @index2 + @index2], @index3 == "hellohello") +[BLOCK_RECURSION_DEPTH_2]: cel.@block([{?"hello": optional.of("hello")}, @index0["hello"]], @index1 + @index1 == "hellohello") +[BLOCK_RECURSION_DEPTH_3]: cel.@block([{?"hello": optional.of("hello")}["hello"]], @index0 + @index0 == "hellohello") +[BLOCK_RECURSION_DEPTH_4]: cel.@block([{?"hello": optional.of("hello")}["hello"]], @index0 + @index0 == "hellohello") +[BLOCK_RECURSION_DEPTH_5]: cel.@block([{?"hello": optional.of("hello")}["hello"]], @index0 + @index0 == "hellohello") +[BLOCK_RECURSION_DEPTH_6]: cel.@block([{?"hello": optional.of("hello")}["hello"]], @index0 + @index0 == "hellohello") +[BLOCK_RECURSION_DEPTH_7]: cel.@block([{?"hello": optional.of("hello")}["hello"]], @index0 + @index0 == "hellohello") +[BLOCK_RECURSION_DEPTH_8]: cel.@block([{?"hello": optional.of("hello")}["hello"]], @index0 + @index0 == "hellohello") +[BLOCK_RECURSION_DEPTH_9]: cel.@block([{?"hello": optional.of("hello")}["hello"]], @index0 + @index0 == "hellohello") + +Test case: OPTIONAL_MAP_CHAINED +Source: {?'key': optional.of('test')}[?'bogus'].or({'key': 'test'}[?'bogus']).orValue({'key': 'test'}['key']) == 'test' +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([{"key": "test"}], {?"key": optional.of("test")}[?"bogus"].or(@index0[?"bogus"]).orValue(@index0["key"]) == "test") +[BLOCK_RECURSION_DEPTH_1]: cel.@block([{"key": "test"}, optional.of("test"), {?"key": @index1}, @index2[?"bogus"], @index0[?"bogus"], @index3.or(@index4), @index0["key"], @index5.orValue(@index6)], @index7 == "test") +[BLOCK_RECURSION_DEPTH_2]: cel.@block([{"key": "test"}, {?"key": optional.of("test")}, @index1[?"bogus"].or(@index0[?"bogus"]), @index2.orValue(@index0["key"])], @index3 == "test") +[BLOCK_RECURSION_DEPTH_3]: cel.@block([{"key": "test"}, {?"key": optional.of("test")}[?"bogus"], @index1.or(@index0[?"bogus"]).orValue(@index0["key"])], @index2 == "test") +[BLOCK_RECURSION_DEPTH_4]: cel.@block([{"key": "test"}, {?"key": optional.of("test")}[?"bogus"].or(@index0[?"bogus"])], @index1.orValue(@index0["key"]) == "test") +[BLOCK_RECURSION_DEPTH_5]: cel.@block([{"key": "test"}, {?"key": optional.of("test")}[?"bogus"].or(@index0[?"bogus"]).orValue(@index0["key"])], @index1 == "test") +[BLOCK_RECURSION_DEPTH_6]: cel.@block([{"key": "test"}], {?"key": optional.of("test")}[?"bogus"].or(@index0[?"bogus"]).orValue(@index0["key"]) == "test") +[BLOCK_RECURSION_DEPTH_7]: cel.@block([{"key": "test"}], {?"key": optional.of("test")}[?"bogus"].or(@index0[?"bogus"]).orValue(@index0["key"]) == "test") +[BLOCK_RECURSION_DEPTH_8]: cel.@block([{"key": "test"}], {?"key": optional.of("test")}[?"bogus"].or(@index0[?"bogus"]).orValue(@index0["key"]) == "test") +[BLOCK_RECURSION_DEPTH_9]: cel.@block([{"key": "test"}], {?"key": optional.of("test")}[?"bogus"].or(@index0[?"bogus"]).orValue(@index0["key"]) == "test") + +Test case: OPTIONAL_MESSAGE +Source: TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int32 + TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}.single_int64 == 5 +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([cel.expr.conformance.proto3.TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}], @index0.single_int32 + @index0.single_int64 == 5) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([optional.ofNonZeroValue(1), optional.of(4), cel.expr.conformance.proto3.TestAllTypes{?single_int64: @index0, ?single_int32: @index1}, @index2.single_int32, @index2.single_int64, @index3 + @index4], @index5 == 5) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([cel.expr.conformance.proto3.TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}, @index0.single_int32 + @index0.single_int64], @index1 == 5) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([cel.expr.conformance.proto3.TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}], @index0.single_int32 + @index0.single_int64 == 5) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([cel.expr.conformance.proto3.TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}], @index0.single_int32 + @index0.single_int64 == 5) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([cel.expr.conformance.proto3.TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}], @index0.single_int32 + @index0.single_int64 == 5) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([cel.expr.conformance.proto3.TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}], @index0.single_int32 + @index0.single_int64 == 5) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([cel.expr.conformance.proto3.TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}], @index0.single_int32 + @index0.single_int64 == 5) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([cel.expr.conformance.proto3.TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}], @index0.single_int32 + @index0.single_int64 == 5) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([cel.expr.conformance.proto3.TestAllTypes{?single_int64: optional.ofNonZeroValue(1), ?single_int32: optional.of(4)}], @index0.single_int32 + @index0.single_int64 == 5) + +Test case: CALL +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block(["h" + "e" + "l" + "l" + "o"], (@index0 + " world").matches(@index0)) +[BLOCK_RECURSION_DEPTH_1]: cel.@block(["h" + "e", @index0 + "l", @index1 + "l", @index2 + "o", @index3 + " world"], @index4.matches(@index3)) +[BLOCK_RECURSION_DEPTH_2]: cel.@block(["h" + "e" + "l", @index0 + "l" + "o"], (@index1 + " world").matches(@index1)) +[BLOCK_RECURSION_DEPTH_3]: cel.@block(["h" + "e" + "l" + "l", @index0 + "o"], (@index1 + " world").matches(@index1)) +[BLOCK_RECURSION_DEPTH_4]: cel.@block(["h" + "e" + "l" + "l" + "o"], (@index0 + " world").matches(@index0)) +[BLOCK_RECURSION_DEPTH_5]: cel.@block(["h" + "e" + "l" + "l" + "o"], (@index0 + " world").matches(@index0)) +[BLOCK_RECURSION_DEPTH_6]: cel.@block(["h" + "e" + "l" + "l" + "o"], (@index0 + " world").matches(@index0)) +[BLOCK_RECURSION_DEPTH_7]: cel.@block(["h" + "e" + "l" + "l" + "o"], (@index0 + " world").matches(@index0)) +[BLOCK_RECURSION_DEPTH_8]: cel.@block(["h" + "e" + "l" + "l" + "o"], (@index0 + " world").matches(@index0)) +[BLOCK_RECURSION_DEPTH_9]: cel.@block(["h" + "e" + "l" + "l" + "o"], (@index0 + " world").matches(@index0)) + +Test case: CALL_ARGUMENT_NESTED_NO_COMMON_SUBEXPR +Source: 'hello world'.matches('h' + 'e' + 'l' + 'l' + 'o') +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: "hello world".matches("h" + "e" + "l" + "l" + "o") +[BLOCK_RECURSION_DEPTH_1]: cel.@block(["h" + "e", @index0 + "l", @index1 + "l", @index2 + "o"], "hello world".matches(@index3)) +[BLOCK_RECURSION_DEPTH_2]: cel.@block(["h" + "e" + "l", @index0 + "l" + "o"], "hello world".matches(@index1)) +[BLOCK_RECURSION_DEPTH_3]: cel.@block(["h" + "e" + "l" + "l"], "hello world".matches(@index0 + "o")) +[BLOCK_RECURSION_DEPTH_4]: cel.@block(["h" + "e" + "l" + "l" + "o"], "hello world".matches(@index0)) +[BLOCK_RECURSION_DEPTH_5]: "hello world".matches("h" + "e" + "l" + "l" + "o") +[BLOCK_RECURSION_DEPTH_6]: "hello world".matches("h" + "e" + "l" + "l" + "o") +[BLOCK_RECURSION_DEPTH_7]: "hello world".matches("h" + "e" + "l" + "l" + "o") +[BLOCK_RECURSION_DEPTH_8]: "hello world".matches("h" + "e" + "l" + "l" + "o") +[BLOCK_RECURSION_DEPTH_9]: "hello world".matches("h" + "e" + "l" + "l" + "o") + +Test case: CALL_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('hello') +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: ("h" + "e" + "l" + "l" + "o" + " world").matches("hello") +[BLOCK_RECURSION_DEPTH_1]: cel.@block(["h" + "e", @index0 + "l", @index1 + "l", @index2 + "o", @index3 + " world"], @index4.matches("hello")) +[BLOCK_RECURSION_DEPTH_2]: cel.@block(["h" + "e" + "l", @index0 + "l" + "o"], (@index1 + " world").matches("hello")) +[BLOCK_RECURSION_DEPTH_3]: cel.@block(["h" + "e" + "l" + "l"], (@index0 + "o" + " world").matches("hello")) +[BLOCK_RECURSION_DEPTH_4]: cel.@block(["h" + "e" + "l" + "l" + "o"], (@index0 + " world").matches("hello")) +[BLOCK_RECURSION_DEPTH_5]: cel.@block(["h" + "e" + "l" + "l" + "o" + " world"], @index0.matches("hello")) +[BLOCK_RECURSION_DEPTH_6]: ("h" + "e" + "l" + "l" + "o" + " world").matches("hello") +[BLOCK_RECURSION_DEPTH_7]: ("h" + "e" + "l" + "l" + "o" + " world").matches("hello") +[BLOCK_RECURSION_DEPTH_8]: ("h" + "e" + "l" + "l" + "o" + " world").matches("hello") +[BLOCK_RECURSION_DEPTH_9]: ("h" + "e" + "l" + "l" + "o" + " world").matches("hello") + +Test case: CALL_BOTH_ARGUMENT_TARGET_NESTED_NO_COMMON_SUBEXPR +Source: ('h' + 'e' + 'l' + 'l' + 'o' + ' world').matches('w' + 'o' + 'r' + 'l' + 'd') +=====> +Result: true +[BLOCK_COMMON_SUBEXPR_ONLY]: ("h" + "e" + "l" + "l" + "o" + " world").matches("w" + "o" + "r" + "l" + "d") +[BLOCK_RECURSION_DEPTH_1]: cel.@block(["h" + "e", @index0 + "l", @index1 + "l", @index2 + "o", @index3 + " world", "w" + "o", @index5 + "r", @index6 + "l", @index7 + "d"], @index4.matches(@index8)) +[BLOCK_RECURSION_DEPTH_2]: cel.@block(["h" + "e" + "l", @index0 + "l" + "o", "w" + "o" + "r", @index2 + "l" + "d"], (@index1 + " world").matches(@index3)) +[BLOCK_RECURSION_DEPTH_3]: cel.@block(["h" + "e" + "l" + "l", "w" + "o" + "r" + "l"], (@index0 + "o" + " world").matches(@index1 + "d")) +[BLOCK_RECURSION_DEPTH_4]: cel.@block(["h" + "e" + "l" + "l" + "o", "w" + "o" + "r" + "l" + "d"], (@index0 + " world").matches(@index1)) +[BLOCK_RECURSION_DEPTH_5]: cel.@block(["h" + "e" + "l" + "l" + "o" + " world"], @index0.matches("w" + "o" + "r" + "l" + "d")) +[BLOCK_RECURSION_DEPTH_6]: ("h" + "e" + "l" + "l" + "o" + " world").matches("w" + "o" + "r" + "l" + "d") +[BLOCK_RECURSION_DEPTH_7]: ("h" + "e" + "l" + "l" + "o" + " world").matches("w" + "o" + "r" + "l" + "d") +[BLOCK_RECURSION_DEPTH_8]: ("h" + "e" + "l" + "l" + "o" + " world").matches("w" + "o" + "r" + "l" + "d") +[BLOCK_RECURSION_DEPTH_9]: ("h" + "e" + "l" + "l" + "o" + " world").matches("w" + "o" + "r" + "l" + "d") + +Test case: CUSTOM_FUNCTION_INELIMINABLE +Source: non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(msg.oneof_type.payload.single_int64) + non_pure_custom_func(msg.single_int64) +=====> +Result: 31 +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload, @index0.single_int64], non_pure_custom_func(@index1) + non_pure_custom_func(@index0.single_int32) + non_pure_custom_func(@index1) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64], non_pure_custom_func(@index2) + non_pure_custom_func(@index1.single_int32) + non_pure_custom_func(@index2) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, @index0.single_int64], non_pure_custom_func(@index1) + non_pure_custom_func(@index0.single_int32) + non_pure_custom_func(@index1) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([msg.oneof_type.payload.single_int64], non_pure_custom_func(@index0) + non_pure_custom_func(msg.oneof_type.payload.single_int32) + non_pure_custom_func(@index0) + non_pure_custom_func(msg.single_int64)) + +Test case: CUSTOM_FUNCTION_ELIMINABLE +Source: pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.oneof_type.payload.single_int32) + pure_custom_func(msg.oneof_type.payload.single_int64) + pure_custom_func(msg.single_int64) +=====> +Result: 31 +[BLOCK_COMMON_SUBEXPR_ONLY]: cel.@block([msg.oneof_type.payload, pure_custom_func(@index0.single_int64)], @index1 + pure_custom_func(@index0.single_int32) + @index1 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_1]: cel.@block([msg.oneof_type, @index0.payload, @index1.single_int64, pure_custom_func(@index2), @index1.single_int32, pure_custom_func(@index4), @index3 + @index5, @index6 + @index3, msg.single_int64, pure_custom_func(@index8)], @index7 + @index9) +[BLOCK_RECURSION_DEPTH_2]: cel.@block([msg.oneof_type.payload, pure_custom_func(@index0.single_int64), pure_custom_func(@index0.single_int32), @index1 + @index2 + @index1, pure_custom_func(msg.single_int64)], @index3 + @index4) +[BLOCK_RECURSION_DEPTH_3]: cel.@block([msg.oneof_type.payload.single_int64, pure_custom_func(@index0), msg.oneof_type.payload.single_int32, @index1 + pure_custom_func(@index2) + @index1], @index3 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_4]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64), pure_custom_func(msg.oneof_type.payload.single_int32)], @index0 + @index1 + @index0 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_5]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64), @index0 + pure_custom_func(msg.oneof_type.payload.single_int32)], @index1 + @index0 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_6]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64), @index0 + pure_custom_func(msg.oneof_type.payload.single_int32) + @index0], @index1 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_7]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64)], @index0 + pure_custom_func(msg.oneof_type.payload.single_int32) + @index0 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_8]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64)], @index0 + pure_custom_func(msg.oneof_type.payload.single_int32) + @index0 + pure_custom_func(msg.single_int64)) +[BLOCK_RECURSION_DEPTH_9]: cel.@block([pure_custom_func(msg.oneof_type.payload.single_int64)], @index0 + pure_custom_func(msg.oneof_type.payload.single_int32) + @index0 + pure_custom_func(msg.single_int64)) \ No newline at end of file diff --git a/parser/BUILD.bazel b/parser/BUILD.bazel new file mode 100644 index 000000000..1e662c3c5 --- /dev/null +++ b/parser/BUILD.bazel @@ -0,0 +1,43 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "parser", + visibility = ["//:internal"], + exports = ["//parser/src/main/java/dev/cel/parser"], +) + +java_library( + name = "parser_factory", + exports = ["//parser/src/main/java/dev/cel/parser:parser_factory"], +) + +java_library( + name = "parser_builder", + exports = ["//parser/src/main/java/dev/cel/parser:parser_builder"], +) + +java_library( + name = "unparser_visitor", + exports = ["//parser/src/main/java/dev/cel/parser:unparser_visitor"], +) + +java_library( + name = "macro", + exports = ["//parser/src/main/java/dev/cel/parser:macro"], +) + +java_library( + name = "cel_g4_visitors", + visibility = ["//:internal"], + exports = ["//parser/src/main/java/dev/cel/parser/gen:cel_g4_visitors"], +) + +java_library( + name = "unparser", + exports = ["//parser/src/main/java/dev/cel/parser:unparser"], +) diff --git a/parser/src/main/java/dev/cel/parser/BUILD.bazel b/parser/src/main/java/dev/cel/parser/BUILD.bazel new file mode 100644 index 000000000..e32c50ee8 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/BUILD.bazel @@ -0,0 +1,136 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//parser:__pkg__", + "//publish:__pkg__", + ], +) + +# keep sorted +PARSER_SOURCES = [ + "CelParserImpl.java", + "ExpressionBalancer.java", + "Parser.java", +] + +# keep sorted +PARSER_BUILDER_SOURCES = [ + "CelParser.java", + "CelParserBuilder.java", + "CelParserLibrary.java", +] + +# keep sorted +MACRO_SOURCES = [ + "CelMacro.java", + "CelMacroExpander.java", + "CelMacroExprFactory.java", + "CelStandardMacro.java", +] + +# keep sorted +UNPARSER_SOURCES = [ + "CelUnparser.java", + "CelUnparserFactory.java", + "CelUnparserImpl.java", +] + +java_library( + name = "parser_factory", + srcs = ["CelParserFactory.java"], + tags = [ + ], + deps = [ + ":parser", + "//common:options", + "//parser:parser_builder", + ], +) + +java_library( + name = "parser", + srcs = PARSER_SOURCES, + tags = [ + ], + deps = [ + ":macro", + ":parser_builder", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:operator", + "//common:options", + "//common:source_location", + "//common/annotations", + "//common/ast", + "//common/internal", + "//common/internal:code_point_stream", + "//common/internal:env_visitor", + "//parser:cel_g4_visitors", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_antlr_antlr4_runtime", + ], +) + +java_library( + name = "parser_builder", + srcs = PARSER_BUILDER_SOURCES, + tags = [ + ], + deps = [ + ":macro", + "//common:cel_source", + "//common:compiler_common", + "//common:options", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "macro", + srcs = MACRO_SOURCES, + tags = [ + ], + deps = [ + "//:auto_value", + "//common:compiler_common", + "//common:operator", + "//common:source_location", + "//common/ast", + "//common/ast:expr_factory", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "unparser", + srcs = UNPARSER_SOURCES, + tags = [ + ], + deps = [ + ":unparser_visitor", + "//common:cel_ast", + "//common:options", + ], +) + +java_library( + name = "unparser_visitor", + srcs = ["CelUnparserVisitor.java"], + tags = [ + ], + deps = [ + "//common:cel_ast", + "//common:cel_source", + "//common:operator", + "//common/ast", + "//common/ast:cel_expr_visitor", + "//common/values:cel_byte_string", + "@maven//:com_google_guava_guava", + "@maven//:com_google_re2j_re2j", + ], +) diff --git a/parser/src/main/java/dev/cel/parser/CelMacro.java b/parser/src/main/java/dev/cel/parser/CelMacro.java new file mode 100644 index 000000000..cf75714a0 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelMacro.java @@ -0,0 +1,187 @@ +// Copyright 2022 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.parser; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Strings.isNullOrEmpty; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; + +/** Describes a function signature to match and the {@link CelMacroExpander} to apply. */ +@AutoValue +@Immutable +public abstract class CelMacro implements Comparable { + // Package-private default constructor to prevent extensions outside of the codebase. + CelMacro() {} + + /** Returns the function name for this macro. */ + public abstract String getFunction(); + + /** Returns the number of arguments this macro expects. For variadic macros, this is 0. */ + public abstract int getArgumentCount(); + + abstract boolean getReceiverStyle(); + + /** True if this macro is receiver-style, false if it is global. */ + public final boolean isReceiverStyle() { + return getReceiverStyle(); + } + + /** Returns the unique string used to identify this macro. */ + public abstract String getKey(); + + abstract boolean getVariadic(); + + /** Returns true if this macro accepts any number of arguments, false otherwise. */ + public final boolean isVariadic() { + return getVariadic(); + } + + /** Returns the expander for this macro. */ + public abstract CelMacroExpander getExpander(); + + @Override + public final int compareTo(CelMacro other) { + if (other == null) { + return 1; + } + int diff = getFunction().compareTo(other.getFunction()); + if (diff != 0) { + return diff; + } + diff = Boolean.compare(!isVariadic(), !other.isVariadic()); + if (diff != 0) { + return diff; + } + if (!isVariadic()) { + diff = Integer.compare(getArgumentCount(), other.getArgumentCount()); + if (diff != 0) { + return diff; + } + } + return Boolean.compare(isReceiverStyle(), other.isReceiverStyle()); + } + + @Override + public final String toString() { + return getKey(); + } + + @Override + public final int hashCode() { + return getKey().hashCode(); + } + + @Override + public final boolean equals(Object other) { + return other instanceof CelMacro && getKey().equals(((CelMacro) other).getKey()); + } + + static Builder newBuilder() { + return new AutoValue_CelMacro.Builder(); + } + + /** Creates a new global macro that accepts a fixed number of arguments. */ + public static CelMacro newGlobalMacro(String function, int argCount, CelMacroExpander expander) { + checkArgument(!isNullOrEmpty(function)); + checkArgument(argCount >= 0); + checkNotNull(expander); + return newBuilder() + .setFunction(function) + .setArgumentCount(argCount) + .setReceiverStyle(false) + .setKey(formatKey(function, argCount, false)) + .setVariadic(false) + .setExpander(expander) + .build(); + } + + /** Creates a new global macro that accepts a variable number of arguments. */ + public static CelMacro newGlobalVarArgMacro(String function, CelMacroExpander expander) { + checkArgument(!isNullOrEmpty(function)); + checkNotNull(expander); + return newBuilder() + .setFunction(function) + .setArgumentCount(0) + .setReceiverStyle(false) + .setKey(formatVarArgKey(function, false)) + .setVariadic(true) + .setExpander(expander) + .build(); + } + + /** Creates a new receiver-style macro that accepts a fixed number of arguments. */ + public static CelMacro newReceiverMacro( + String function, int argCount, CelMacroExpander expander) { + checkArgument(!isNullOrEmpty(function)); + checkArgument(argCount >= 0); + checkNotNull(expander); + return newBuilder() + .setFunction(function) + .setArgumentCount(argCount) + .setReceiverStyle(true) + .setKey(formatKey(function, argCount, true)) + .setVariadic(false) + .setExpander(expander) + .build(); + } + + /** Creates a new receiver-style macro that accepts a variable number of arguments. */ + public static CelMacro newReceiverVarArgMacro(String function, CelMacroExpander expander) { + checkArgument(!isNullOrEmpty(function)); + checkNotNull(expander); + return newBuilder() + .setFunction(function) + .setArgumentCount(0) + .setReceiverStyle(true) + .setKey(formatVarArgKey(function, true)) + .setVariadic(true) + .setExpander(expander) + .build(); + } + + static String formatKey(String function, int argCount, boolean receiverStyle) { + checkArgument(!isNullOrEmpty(function)); + checkArgument(argCount >= 0); + return String.format("%s:%d:%s", function, argCount, receiverStyle); + } + + static String formatVarArgKey(String function, boolean receiverStyle) { + checkArgument(!isNullOrEmpty(function)); + return String.format("%s:*:%s", function, receiverStyle); + } + + @AutoValue.Builder + abstract static class Builder { + + abstract Builder setFunction(String function); + + abstract Builder setArgumentCount(int argumentCount); + + abstract Builder setReceiverStyle(boolean receiverStyle); + + abstract Builder setKey(String key); + + abstract Builder setVariadic(boolean variadic); + + abstract Builder setExpander(CelMacroExpander expander); + + @CheckReturnValue + abstract CelMacro build(); + } +} diff --git a/parser/src/main/java/dev/cel/parser/CelMacroExpander.java b/parser/src/main/java/dev/cel/parser/CelMacroExpander.java new file mode 100644 index 000000000..2b41f3629 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelMacroExpander.java @@ -0,0 +1,39 @@ +// Copyright 2022 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.parser; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import java.util.Optional; + +/** Converts the target and arguments of a function call that matches a macro. */ +@FunctionalInterface +@Immutable +public interface CelMacroExpander { + + /** + * Converts a call and its associated arguments into a new CEL AST. + * + * @param exprFactory Expression factory to assist with expansion of this macro. + * @param target Target expression which the macro is being invoked on. Default instance of Expr + * is provided instead for global macros. + * @param arguments Arguments of the call + * @return A newly generated CEL AST. Implementations may return Optional.Empty instead to signal + * that an expansion is not needed. + */ + Optional expandMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments); +} diff --git a/parser/src/main/java/dev/cel/parser/CelMacroExprFactory.java b/parser/src/main/java/dev/cel/parser/CelMacroExprFactory.java new file mode 100644 index 000000000..e0dcb5888 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelMacroExprFactory.java @@ -0,0 +1,162 @@ +// Copyright 2022 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.parser; + +import com.google.errorprone.annotations.FormatMethod; +import com.google.errorprone.annotations.FormatString; +import dev.cel.common.CelIssue; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExprFactory; + +/** + * Assists with the expansion of {@link CelMacro} in a manner which is consistent with the source + * position and expression ID generation code leveraged by both the parser and type-checker. + */ +public abstract class CelMacroExprFactory extends CelExprFactory { + + // Package-private default constructor to prevent extensions outside of the codebase. + CelMacroExprFactory() {} + + /** + * Creates a {@link CelIssue} and reports it, returning a sentinel {@link CelExpr} that indicates + * an error. + */ + @FormatMethod + public final CelExpr reportError(@FormatString String format, Object... args) { + return reportError( + CelIssue.formatError(currentSourceLocationForMacro(), String.format(format, args))); + } + + /** + * Creates a {@link CelIssue} and reports it, returning a sentinel {@link CelExpr} that indicates + * an error. + */ + public final CelExpr reportError(String message) { + return reportError(CelIssue.formatError(currentSourceLocationForMacro(), message)); + } + + /** Reports a {@link CelIssue} and returns a sentinel {@link CelExpr} that indicates an error. */ + public abstract CelExpr reportError(CelIssue error); + + /** Returns the default accumulator variable name used by macros implementing comprehensions. */ + public abstract String getAccumulatorVarName(); + + /** Retrieves the source location for the given {@link CelExpr} ID. */ + public final CelSourceLocation getSourceLocation(CelExpr expr) { + return getSourceLocation(expr.id()); + } + + /** Duplicates {@link CelExpr} with a brand new set of identifiers. */ + public final CelExpr copy(CelExpr expr) { + CelExpr.Builder builder = CelExpr.newBuilder().setId(copyExprId(expr.id())); + switch (expr.exprKind().getKind()) { + case CONSTANT: + builder.setConstant(expr.constant()); + break; + case IDENT: + builder.setIdent(expr.ident()); + break; + case SELECT: + builder.setSelect( + CelExpr.CelSelect.newBuilder() + .setOperand(copy(expr.select().operand())) + .setField(expr.select().field()) + .setTestOnly(expr.select().testOnly()) + .build()); + break; + case CALL: + { + CelExpr.CelCall.Builder callBuilder = + CelExpr.CelCall.newBuilder().setFunction(expr.call().function()); + expr.call().target().ifPresent(target -> callBuilder.setTarget(copy(target))); + for (CelExpr arg : expr.call().args()) { + callBuilder.addArgs(copy(arg)); + } + builder.setCall(callBuilder.build()); + } + break; + case LIST: + { + CelExpr.CelList.Builder listBuilder = + CelExpr.CelList.newBuilder().addOptionalIndices(expr.list().optionalIndices()); + for (CelExpr element : expr.list().elements()) { + listBuilder.addElements(copy(element)); + } + builder.setList(listBuilder.build()); + } + break; + case STRUCT: + { + CelExpr.CelStruct.Builder structBuilder = + CelExpr.CelStruct.newBuilder().setMessageName(expr.struct().messageName()); + for (CelExpr.CelStruct.Entry entry : expr.struct().entries()) { + structBuilder.addEntries( + CelExpr.CelStruct.Entry.newBuilder() + .setId(copyExprId(entry.id())) + .setFieldKey(entry.fieldKey()) + .setValue(copy(entry.value())) + .setOptionalEntry(entry.optionalEntry()) + .build()); + } + builder.setStruct(structBuilder.build()); + } + break; + case MAP: + { + CelExpr.CelMap.Builder mapBuilder = CelExpr.CelMap.newBuilder(); + for (CelExpr.CelMap.Entry entry : expr.map().entries()) { + mapBuilder.addEntries( + CelExpr.CelMap.Entry.newBuilder() + .setId(copyExprId(entry.id())) + .setKey(copy(entry.key())) + .setValue(copy(entry.value())) + .setOptionalEntry(entry.optionalEntry()) + .build()); + } + builder.setMap(mapBuilder.build()); + } + break; + case COMPREHENSION: + builder.setComprehension( + CelExpr.CelComprehension.newBuilder() + .setIterVar(expr.comprehension().iterVar()) + .setIterVar2(expr.comprehension().iterVar2()) + .setIterRange(copy(expr.comprehension().iterRange())) + .setAccuVar(expr.comprehension().accuVar()) + .setAccuInit(copy(expr.comprehension().accuInit())) + .setLoopCondition(copy(expr.comprehension().loopCondition())) + .setLoopStep(copy(expr.comprehension().loopStep())) + .setResult(copy(expr.comprehension().result())) + .build()); + break; + case NOT_SET: + break; + } + return builder.build(); + } + + /** + * Returns the next unique expression ID which is associated with the same metadata (i.e. source + * location, types, references, etc.) as `id`. + */ + protected abstract long copyExprId(long id); + + /** Retrieves the source location for the given {@link CelExpr} ID. */ + protected abstract CelSourceLocation getSourceLocation(long exprId); + + /** Returns the current (last known) source location. This should only be used for macros. */ + protected abstract CelSourceLocation currentSourceLocationForMacro(); +} diff --git a/parser/src/main/java/dev/cel/parser/CelParser.java b/parser/src/main/java/dev/cel/parser/CelParser.java new file mode 100644 index 000000000..da1b7ba2a --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelParser.java @@ -0,0 +1,57 @@ +// Copyright 2022 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.parser; + +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelSource; +import dev.cel.common.CelValidationResult; + +/** Public interface for the parsing CEL expressions. */ +@Immutable +public interface CelParser { + + /** + * Parse the input {@code expression} and return a {@code CelValidationResult}. + * + *

Parse validates the syntax of an expression. + */ + default CelValidationResult parse(String expression) { + return parse(expression, ""); + } + + /** + * Parse the input {@code expression} and return a {@code CelValidationResult}. + * + *

The {@code description} may be used to help tailor error messages for the location where the + * {@code expression} originates, e.g. a file name or form UI element. + * + *

Parse validates the syntax of an expression. + */ + CelValidationResult parse(String expression, String description); + + /** + * Parse the input {@code expression} and return a {@code CelValidationResult}. + * + *

The {@code description} may be used to help tailor error messages for the location where the + * {@code expression} originates, e.g. a file name or form UI element. + * + *

Parse validates the syntax of an expression. + */ + @CheckReturnValue + CelValidationResult parse(CelSource source); + + CelParserBuilder toParserBuilder(); +} diff --git a/parser/src/main/java/dev/cel/parser/CelParserBuilder.java b/parser/src/main/java/dev/cel/parser/CelParserBuilder.java new file mode 100644 index 000000000..79f33d31f --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelParserBuilder.java @@ -0,0 +1,85 @@ +// Copyright 2022 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.parser; + +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.CelOptions; + +/** Interface for building an instance of CelParser */ +public interface CelParserBuilder { + /** Configures the {@link CelOptions} used to enable fixes within the parser. */ + @CanIgnoreReturnValue + CelParserBuilder setOptions(CelOptions celOptions); + + /** Retrieves the currently configured {@link CelOptions} for the parser. */ + @CanIgnoreReturnValue + CelOptions getOptions(); + + /** + * Sets the macro set defined as part of CEL standard library for the parser, replacing the macros + * from any prior call. + */ + @CanIgnoreReturnValue + CelParserBuilder setStandardMacros(CelStandardMacro... macros); + + /** + * Sets the macro set defined as part of CEL standard library for the parser, replacing the macros + * from any prior call. + */ + @CanIgnoreReturnValue + CelParserBuilder setStandardMacros(Iterable macros); + + /** + * Registers the given macros, replacing any previous macros with the same key. + * + *

Use this to register a set of user-defined custom macro implementation for the parser. For + * registering macros defined as part of CEL standard library, use {@link #setStandardMacros} + * instead. + * + *

Custom macros should not use the same function names as the ones found in {@link + * CelStandardMacro} (ex: has, all, exists, etc.). Build method will throw if both standard macros + * and custom macros are set with the same name. + */ + @CanIgnoreReturnValue + CelParserBuilder addMacros(CelMacro... macros); + + /** + * Registers the given macros, replacing any previous macros with the same key. + * + *

Use this to register a set of user-defined custom macro implementation for the parser. For + * registering macros defined as part of CEL standard library, use {@link #setStandardMacros} + * instead. + * + *

Custom macros should not use the same function names as the ones found in {@link + * CelStandardMacro} (ex: has, all, exists, etc.). Build method will throw if both standard macros + * and custom macros are set with the same name. + */ + @CanIgnoreReturnValue + CelParserBuilder addMacros(Iterable macros); + + /** Adds one or more libraries for parsing */ + @CanIgnoreReturnValue + CelParserBuilder addLibraries(CelParserLibrary... libraries); + + /** Adds a collection of libraries for parsing */ + @CanIgnoreReturnValue + CelParserBuilder addLibraries(Iterable libraries); + + /** Build a new instance of the {@code CelParser}. */ + @CheckReturnValue + CelParser build(); +} + diff --git a/parser/src/main/java/dev/cel/parser/CelParserFactory.java b/parser/src/main/java/dev/cel/parser/CelParserFactory.java new file mode 100644 index 000000000..6b8a53068 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelParserFactory.java @@ -0,0 +1,32 @@ +// Copyright 2022 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.parser; + +import dev.cel.common.CelOptions; + +/** Factory class for producing {@link CelParser} instances and builders. */ +public final class CelParserFactory { + + /** + * Configure a builder to construct a current {@code CelParser} instance. + * + *

Note, the {@link CelOptions#current} are enabled by default. + */ + public static CelParserBuilder standardCelParserBuilder() { + return CelParserImpl.newBuilder().setOptions(CelOptions.DEFAULT); + } + + private CelParserFactory() {} +} diff --git a/parser/src/main/java/dev/cel/parser/CelParserImpl.java b/parser/src/main/java/dev/cel/parser/CelParserImpl.java new file mode 100644 index 000000000..615b073ef --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelParserImpl.java @@ -0,0 +1,231 @@ +// Copyright 2022 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.parser; + +import static com.google.common.base.Preconditions.checkNotNull; +import static java.util.stream.Collectors.toCollection; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelOptions; +import dev.cel.common.CelSource; +import dev.cel.common.CelValidationResult; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.EnvVisitable; +import dev.cel.common.internal.EnvVisitor; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.stream.Collectors; + +/** + * Modernized parser implementation for CEL. + * + *

CEL Library Internals. Do Not Use. Consumers should use factories, such as {@link + * CelParserFactory} instead to instantiate a parser. + */ +@Immutable +@Internal +public final class CelParserImpl implements CelParser, EnvVisitable { + + // Common feature flags to be used with all calls. + + // Set of macros configured for parsing. + private final ImmutableMap macros; + + // Specific options for limits on parsing power. + private final CelOptions options; + + private final ImmutableList standardMacros; + + @SuppressWarnings("Immutable") // Interface not marked as immutable, however it should be. + private final ImmutableSet parserLibraries; + + /** Creates a new {@link Builder}. */ + public static CelParserBuilder newBuilder() { + return new Builder().setOptions(CelOptions.DEFAULT); + } + + @Override + public CelValidationResult parse(String expression, String description) { + return parse(CelSource.newBuilder(expression).setDescription(description).build()); + } + + @Override + public CelValidationResult parse(CelSource source) { + return Parser.parse(this, source, getOptions()); + } + + @Override + public CelParserBuilder toParserBuilder() { + HashSet standardMacroKeys = + standardMacros.stream() + .map(s -> s.getDefinition().getKey()) + .collect(Collectors.toCollection(HashSet::new)); + + return new Builder() + .setOptions(options) + .setStandardMacros(standardMacros) + .addMacros( + // Separate standard macros from the custom macros before constructing the builder + macros.values().stream() + .filter(m -> !standardMacroKeys.contains(m.getKey())) + .collect(toCollection(ArrayList::new))) + .addLibraries(parserLibraries); + } + + Optional findMacro(String key) { + return Optional.ofNullable(macros.get(key)); + } + + /** Return the options the {@link CelParser} was originally created with. */ + public CelOptions getOptions() { + return options; + } + + /** Builder for {@link CelParserImpl}. */ + public static final class Builder implements CelParserBuilder { + + private final List standardMacros; + private final Map macros; + private final ImmutableSet.Builder celParserLibraries; + private CelOptions options; + + @Override + public CelParserBuilder setStandardMacros(CelStandardMacro... macros) { + checkNotNull(macros); + return setStandardMacros(Arrays.asList(macros)); + } + + @Override + public CelParserBuilder setStandardMacros(Iterable macros) { + checkNotNull(macros); + this.standardMacros.clear(); + Iterables.addAll(this.standardMacros, macros); + return this; + } + + @Override + public CelParserBuilder addMacros(CelMacro... macros) { + checkNotNull(macros); + return addMacros(Arrays.asList(macros)); + } + + @Override + public CelParserBuilder addMacros(Iterable macros) { + checkNotNull(macros); + for (CelMacro m : macros) { + CelMacro macro = checkNotNull(m); + this.macros.put(macro.getKey(), macro); + } + return this; + } + + @Override + public CelParserBuilder addLibraries(CelParserLibrary... libraries) { + checkNotNull(libraries); + return this.addLibraries(Arrays.asList(libraries)); + } + + @Override + public CelParserBuilder addLibraries(Iterable libraries) { + checkNotNull(libraries); + this.celParserLibraries.addAll(libraries); + return this; + } + + @CanIgnoreReturnValue + @Override + public Builder setOptions(CelOptions options) { + this.options = checkNotNull(options); + return this; + } + + @Override + public CelOptions getOptions() { + return this.options; + } + + // The following getters exist for asserting immutability for collections held by this builder, + // and shouldn't be exposed to the public. + @VisibleForTesting + List getStandardMacros() { + return this.standardMacros; + } + + @VisibleForTesting + Map getMacros() { + return this.macros; + } + + @VisibleForTesting + ImmutableSet.Builder getParserLibraries() { + return this.celParserLibraries; + } + + @Override + @CheckReturnValue + public CelParserImpl build() { + ImmutableSet parserLibrarySet = celParserLibraries.build(); + + // Add libraries, such as extensions + parserLibrarySet.forEach(celLibrary -> celLibrary.setParserOptions(this)); + + ImmutableMap.Builder macroMapBuilder = ImmutableMap.builder(); + macroMapBuilder.putAll(macros); + standardMacros.stream() + .map(CelStandardMacro::getDefinition) + .forEach(celMacro -> macroMapBuilder.put(celMacro.getKey(), celMacro)); + + return new CelParserImpl( + macroMapBuilder.buildOrThrow(), + options, + ImmutableList.copyOf(standardMacros), + celParserLibraries.build()); + } + + private Builder() { + this.macros = new HashMap<>(); + this.celParserLibraries = ImmutableSet.builder(); + this.standardMacros = new ArrayList<>(); + } + } + + private CelParserImpl( + ImmutableMap macros, + CelOptions options, + ImmutableList standardMacros, + ImmutableSet parserLibraries) { + this.macros = macros; + this.options = checkNotNull(options); + this.standardMacros = standardMacros; + this.parserLibraries = parserLibraries; + } + + @Override + public void accept(EnvVisitor visitor) { + macros.forEach((name, macro) -> visitor.visitMacro(macro)); + } +} diff --git a/parser/src/main/java/dev/cel/parser/CelParserLibrary.java b/parser/src/main/java/dev/cel/parser/CelParserLibrary.java new file mode 100644 index 000000000..b41fd8111 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelParserLibrary.java @@ -0,0 +1,24 @@ +// Copyright 2023 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.parser; + +/** + * CelParserLibrary defines the interface to extend functionalities beyond the CEL standard + * functions for {@link CelParser}. + */ +public interface CelParserLibrary { + /** Configures the parser to support the library implementation, such as adding macros */ + default void setParserOptions(CelParserBuilder parserBuilder) {} +} diff --git a/parser/src/main/java/dev/cel/parser/CelStandardMacro.java b/parser/src/main/java/dev/cel/parser/CelStandardMacro.java new file mode 100644 index 000000000..275159569 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelStandardMacro.java @@ -0,0 +1,338 @@ +// Copyright 2022 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.parser; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelIssue; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelExpr; +import java.util.Optional; + +/** + * CelStandardMacro enum represents all of the macros defined as part of the CEL standard library. + */ +public enum CelStandardMacro { + + /** Field presence test macro */ + HAS(CelMacro.newGlobalMacro(Operator.HAS.getFunction(), 1, CelStandardMacro::expandHasMacro)), + + /** + * Boolean comprehension which asserts that a predicate holds true for all elements in the input + * range. + */ + ALL(CelMacro.newReceiverMacro(Operator.ALL.getFunction(), 2, CelStandardMacro::expandAllMacro)), + + /** + * Boolean comprehension which asserts that a predicate holds true for at least one element in the + * input range. + */ + EXISTS( + CelMacro.newReceiverMacro( + Operator.EXISTS.getFunction(), 2, CelStandardMacro::expandExistsMacro)), + + /** + * Boolean comprehension which asserts that a predicate holds true for exactly one element in the + * input range. + */ + EXISTS_ONE( + CelMacro.newReceiverMacro( + Operator.EXISTS_ONE.getFunction(), 2, CelStandardMacro::expandExistsOneMacro)), + + /** + * Boolean comprehension which asserts that a predicate holds true for exactly one element in the + * input range. + */ + EXISTS_ONE_NEW( + CelMacro.newReceiverMacro( + Operator.EXISTS_ONE_NEW.getFunction(), 2, CelStandardMacro::expandExistsOneMacro)), + + /** + * Comprehension which applies a transform to each element in the input range and produces a list + * of equivalent size as output. + */ + MAP(CelMacro.newReceiverMacro(Operator.MAP.getFunction(), 2, CelStandardMacro::expandMapMacro)), + + /** + * Comprehension which conditionally applies a transform to elements in the list which satisfy the + * filter predicate. + */ + MAP_FILTER( + CelMacro.newReceiverMacro(Operator.MAP.getFunction(), 3, CelStandardMacro::expandMapMacro)), + + /** + * Comprehension which produces a list containing elements in the input range which match the + * filter. + */ + FILTER( + CelMacro.newReceiverMacro( + Operator.FILTER.getFunction(), 2, CelStandardMacro::expandFilterMacro)); + + /** Set of all standard macros supported by the CEL spec. */ + public static final ImmutableSet STANDARD_MACROS = + ImmutableSet.of(HAS, ALL, EXISTS, EXISTS_ONE, MAP, MAP_FILTER, FILTER); + + private final CelMacro macro; + + CelStandardMacro(CelMacro macro) { + this.macro = macro; + } + + /** Returns the function name associated with the macro. */ + public String getFunction() { + return macro.getFunction(); + } + + /** Returns the new-style {@code CelMacro} definition. */ + public CelMacro getDefinition() { + return macro; + } + + // CelMacroExpander implementation for CEL's has() macro. + private static Optional expandHasMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 1); + CelExpr arg = checkNotNull(arguments.get(0)); + if (arg.exprKind().getKind() != CelExpr.ExprKind.Kind.SELECT) { + return Optional.of(exprFactory.reportError("invalid argument to has() macro")); + } + return Optional.of(exprFactory.newSelect(arg.select().operand(), arg.select().field(), true)); + } + + // CelMacroExpander implementation for CEL's all() macro. + private static Optional expandAllMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 2); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = checkNotNull(arguments.get(1)); + CelExpr accuInit = exprFactory.newBoolLiteral(true); + CelExpr condition = + exprFactory.newGlobalCall( + Operator.NOT_STRICTLY_FALSE.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + CelExpr step = + exprFactory.newGlobalCall( + Operator.LOGICAL_AND.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + arg1); + CelExpr result = exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()); + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + result)); + } + + // CelMacroExpander implementation for CEL's exists() macro. + private static Optional expandExistsMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 2); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = checkNotNull(arguments.get(1)); + CelExpr accuInit = exprFactory.newBoolLiteral(false); + CelExpr condition = + exprFactory.newGlobalCall( + Operator.NOT_STRICTLY_FALSE.getFunction(), + exprFactory.newGlobalCall( + Operator.LOGICAL_NOT.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()))); + CelExpr step = + exprFactory.newGlobalCall( + Operator.LOGICAL_OR.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + arg1); + CelExpr result = exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()); + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + result)); + } + + // CelMacroExpander implementation for CEL's exists_one() macro. + private static Optional expandExistsOneMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 2); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = checkNotNull(arguments.get(1)); + CelExpr accuInit = exprFactory.newIntLiteral(0); + CelExpr condition = exprFactory.newBoolLiteral(true); + CelExpr step = + exprFactory.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + arg1, + exprFactory.newGlobalCall( + Operator.ADD.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + exprFactory.newIntLiteral(1)), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + CelExpr result = + exprFactory.newGlobalCall( + Operator.EQUALS.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + exprFactory.newIntLiteral(1)); + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + result)); + } + + // CelMacroExpander implementation for CEL's map() macro. + private static Optional expandMapMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 2 || arguments.size() == 3); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1; + CelExpr arg2; + if (arguments.size() == 3) { + arg2 = checkNotNull(arguments.get(1)); + arg1 = checkNotNull(arguments.get(2)); + } else { + arg1 = checkNotNull(arguments.get(1)); + arg2 = null; + } + CelExpr accuInit = exprFactory.newList(); + CelExpr condition = exprFactory.newBoolLiteral(true); + CelExpr step = + exprFactory.newGlobalCall( + Operator.ADD.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + exprFactory.newList(arg1)); + if (arg2 != null) { + step = + exprFactory.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + arg2, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + } + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()))); + } + + // CelMacroExpander implementation for CEL's filter() macro. + private static Optional expandFilterMacro( + CelMacroExprFactory exprFactory, CelExpr target, ImmutableList arguments) { + checkNotNull(exprFactory); + checkNotNull(target); + checkArgument(arguments.size() == 2); + CelExpr arg0 = validatedIterationVariable(exprFactory, arguments.get(0)); + if (arg0.exprKind().getKind() != CelExpr.ExprKind.Kind.IDENT) { + return Optional.of(arg0); + } + CelExpr arg1 = checkNotNull(arguments.get(1)); + CelExpr accuInit = exprFactory.newList(); + CelExpr condition = exprFactory.newBoolLiteral(true); + CelExpr step = + exprFactory.newGlobalCall( + Operator.ADD.getFunction(), + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()), + exprFactory.newList(arg0)); + step = + exprFactory.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + arg1, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName())); + return Optional.of( + exprFactory.fold( + arg0.ident().name(), + target, + exprFactory.getAccumulatorVarName(), + accuInit, + condition, + step, + exprFactory.newIdentifier(exprFactory.getAccumulatorVarName()))); + } + + private static CelExpr validatedIterationVariable( + CelMacroExprFactory exprFactory, CelExpr argument) { + CelExpr arg = checkNotNull(argument); + if (!isSimpleIdentifier(arg)) { + return reportArgumentError(exprFactory, arg); + } else if (arg.exprKind().ident().name().equals("__result__")) { + return reportAccumulatorOverwriteError(exprFactory, arg); + } else { + return arg; + } + } + + private static boolean isSimpleIdentifier(CelExpr expr) { + return expr.getKind() == CelExpr.ExprKind.Kind.IDENT + && !expr.ident().name().isEmpty() + && !expr.ident().name().startsWith("."); + } + + private static CelExpr reportArgumentError(CelMacroExprFactory exprFactory, CelExpr argument) { + return exprFactory.reportError( + CelIssue.formatError( + exprFactory.getSourceLocation(argument), "The argument must be a simple name")); + } + + private static CelExpr reportAccumulatorOverwriteError( + CelMacroExprFactory exprFactory, CelExpr argument) { + return exprFactory.reportError( + CelIssue.formatError( + exprFactory.getSourceLocation(argument), + String.format( + "The iteration variable %s overwrites accumulator variable", + argument.ident().name()))); + } +} diff --git a/parser/src/main/java/dev/cel/parser/CelUnparser.java b/parser/src/main/java/dev/cel/parser/CelUnparser.java new file mode 100644 index 000000000..ba3338e51 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelUnparser.java @@ -0,0 +1,36 @@ +// Copyright 2023 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.parser; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; + +/** + * Provides an unparsing utility that converts an AST back into a human-readable format. + * + *

Input to the unparser is a {@link CelAbstractSyntaxTree}. The unparser does not do any checks + * to see if the AST is syntactically or semantically correct but does check enough to prevent its + * crash and might return errors in such cases. + */ +public interface CelUnparser { + + /** + * Unparses the {@link CelAbstractSyntaxTree} value to a human-readable string. + * + *

To reconstruct an expression that originally contained a macro call, ensure the expression + * was parsed with {@link CelOptions#populateMacroCalls()} enabled. + */ + String unparse(CelAbstractSyntaxTree ast); +} diff --git a/parser/src/main/java/dev/cel/parser/CelUnparserFactory.java b/parser/src/main/java/dev/cel/parser/CelUnparserFactory.java new file mode 100644 index 000000000..e7a14bb8b --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelUnparserFactory.java @@ -0,0 +1,24 @@ +// Copyright 2023 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.parser; + +/** Factory class for producing {@link CelUnparser} instances and builders. */ +public final class CelUnparserFactory { + public static CelUnparser newUnparser() { + return new CelUnparserImpl(); + } + + private CelUnparserFactory() {} +} diff --git a/parser/src/main/java/dev/cel/parser/CelUnparserImpl.java b/parser/src/main/java/dev/cel/parser/CelUnparserImpl.java new file mode 100644 index 000000000..deffd9d5e --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelUnparserImpl.java @@ -0,0 +1,27 @@ +// Copyright 2023 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.parser; + +import dev.cel.common.CelAbstractSyntaxTree; + +/** Unparser implementation for CEL. */ +final class CelUnparserImpl implements CelUnparser { + + @Override + public String unparse(CelAbstractSyntaxTree ast) { + CelUnparserVisitor unparserVisitor = new CelUnparserVisitor(ast); + return unparserVisitor.unparse(); + } +} diff --git a/parser/src/main/java/dev/cel/parser/CelUnparserVisitor.java b/parser/src/main/java/dev/cel/parser/CelUnparserVisitor.java new file mode 100644 index 000000000..61c8b10e9 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/CelUnparserVisitor.java @@ -0,0 +1,399 @@ +// Copyright 2023 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.parser; + +import static dev.cel.common.Operator.LOGICAL_AND; +import static dev.cel.common.Operator.LOGICAL_OR; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableSet; +import com.google.re2j.Pattern; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelSource; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelComprehension; +import dev.cel.common.ast.CelExpr.CelIdent; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelExprVisitor; +import dev.cel.common.values.CelByteString; +import java.util.HashSet; +import java.util.Optional; + +/** Visitor implementation to unparse an AST. */ +public class CelUnparserVisitor extends CelExprVisitor { + protected static final String LEFT_PAREN = "("; + protected static final String RIGHT_PAREN = ")"; + protected static final String DOT = "."; + protected static final String COMMA = ","; + protected static final String SPACE = " "; + protected static final String LEFT_BRACKET = "["; + protected static final String RIGHT_BRACKET = "]"; + protected static final String LEFT_BRACE = "{"; + protected static final String RIGHT_BRACE = "}"; + protected static final String COLON = ":"; + protected static final String QUESTION_MARK = "?"; + protected static final String BACKTICK = "`"; + private static final Pattern IDENTIFIER_SEGMENT_PATTERN = + Pattern.compile("[a-zA-Z_][a-zA-Z0-9_]*"); + private static final ImmutableSet RESTRICTED_FIELD_NAMES = ImmutableSet.of("in"); + + protected final CelAbstractSyntaxTree ast; + protected final CelSource sourceInfo; + protected final StringBuilder stringBuilder; + + /** Creates a new {@link CelUnparserVisitor}. */ + public CelUnparserVisitor(CelAbstractSyntaxTree ast) { + this.ast = ast; + this.sourceInfo = ast.getSource(); + this.stringBuilder = new StringBuilder(); + } + + public String unparse() { + visit(ast.getExpr()); + return stringBuilder.toString(); + } + + /** + * Unparses a specific {@link CelExpr} node within the AST. + * + *

This method exists to allow unparsing of an arbitrary node within the stored AST in this + * visitor. + */ + public String unparse(CelExpr expr) { + visit(expr); + return stringBuilder.toString(); + } + + private static String maybeQuoteField(String field) { + if (RESTRICTED_FIELD_NAMES.contains(field) + || !IDENTIFIER_SEGMENT_PATTERN.matcher(field).matches()) { + return BACKTICK + field + BACKTICK; + } + return field; + } + + @Override + public void visit(CelExpr expr) { + if (sourceInfo.getMacroCalls().containsKey(expr.id())) { + visit(sourceInfo.getMacroCalls().get(expr.id())); + return; + } + super.visit(expr); + } + + @Override + protected void visit(CelExpr expr, CelConstant constant) { + switch (constant.getKind()) { + case STRING_VALUE: + stringBuilder.append("\"").append(constant.stringValue()).append("\""); + break; + case INT64_VALUE: + stringBuilder.append(constant.int64Value()); + break; + case UINT64_VALUE: + stringBuilder.append(constant.uint64Value()).append("u"); + break; + case BOOLEAN_VALUE: + stringBuilder.append(constant.booleanValue() ? "true" : "false"); + break; + case DOUBLE_VALUE: + stringBuilder.append(constant.doubleValue()); + break; + case NULL_VALUE: + stringBuilder.append("null"); + break; + case BYTES_VALUE: + stringBuilder.append("b\"").append(bytesToOctets(constant.bytesValue())).append("\""); + break; + default: + throw new IllegalArgumentException("unexpected expr kind"); + } + } + + @Override + protected void visit(CelExpr expr, CelIdent ident) { + stringBuilder.append(ident.name()); + } + + @Override + protected void visit(CelExpr expr, CelSelect select) { + visitSelect(select.operand(), select.testOnly(), DOT, select.field()); + } + + @Override + protected void visit(CelExpr expr, CelCall call) { + String fun = call.function(); + + Optional op = Operator.lookupUnaryOperator(fun); + if (op.isPresent()) { + visitUnary(call, op.get()); + return; + } + + op = Operator.lookupBinaryOperator(fun); + if (op.isPresent()) { + visitBinary(call, op.get()); + return; + } + + if (fun.equals(Operator.INDEX.getFunction())) { + visitIndex(call, LEFT_BRACKET); + return; + } + + if (fun.equals(Operator.OPTIONAL_INDEX.getFunction())) { + visitIndex(call, LEFT_BRACKET + QUESTION_MARK); + return; + } + + if (fun.equals(Operator.CONDITIONAL.getFunction())) { + visitTernary(call); + return; + } + + if (fun.equals(Operator.OPTIONAL_SELECT.getFunction())) { + CelExpr operand = call.args().get(0); + String field = call.args().get(1).constant().stringValue(); + visitSelect(operand, false, DOT + QUESTION_MARK, field); + return; + } + + if (call.target().isPresent()) { + boolean nested = isBinaryOrTernaryOperator(call.target().get()); + visitMaybeNested(call.target().get(), nested); + stringBuilder.append(DOT); + } + + stringBuilder.append(fun).append(LEFT_PAREN); + for (int i = 0; i < call.args().size(); i++) { + if (i > 0) { + stringBuilder.append(COMMA).append(SPACE); + } + visit(call.args().get(i)); + } + stringBuilder.append(RIGHT_PAREN); + } + + @Override + protected void visit(CelExpr expr, CelList list) { + stringBuilder.append(LEFT_BRACKET); + HashSet optionalIndices = new HashSet<>(list.optionalIndices()); + for (int i = 0; i < list.elements().size(); i++) { + if (i > 0) { + stringBuilder.append(COMMA).append(SPACE); + } + if (optionalIndices.contains(i)) { + stringBuilder.append(QUESTION_MARK); + } + visit(list.elements().get(i)); + } + stringBuilder.append(RIGHT_BRACKET); + } + + @Override + protected void visit(CelExpr expr, CelStruct struct) { + stringBuilder.append(struct.messageName()); + stringBuilder.append(LEFT_BRACE); + for (int i = 0; i < struct.entries().size(); i++) { + if (i > 0) { + stringBuilder.append(COMMA).append(SPACE); + } + + CelStruct.Entry e = struct.entries().get(i); + if (e.optionalEntry()) { + stringBuilder.append(QUESTION_MARK); + } + stringBuilder.append(maybeQuoteField(e.fieldKey())); + stringBuilder.append(COLON).append(SPACE); + visit(e.value()); + } + stringBuilder.append(RIGHT_BRACE); + } + + @Override + protected void visit(CelExpr expr, CelMap map) { + stringBuilder.append(LEFT_BRACE); + for (int i = 0; i < map.entries().size(); i++) { + if (i > 0) { + stringBuilder.append(COMMA).append(SPACE); + } + + CelMap.Entry e = map.entries().get(i); + if (e.optionalEntry()) { + stringBuilder.append(QUESTION_MARK); + } + visit(e.key()); + stringBuilder.append(COLON).append(SPACE); + visit(e.value()); + } + stringBuilder.append(RIGHT_BRACE); + } + + @Override + protected void visit(CelExpr expr, CelComprehension comprehension) { + throw new UnsupportedOperationException( + "Comprehension unparsing requires macro calls to be populated. Ensure the option is" + + " enabled."); + } + + private void visitUnary(CelCall expr, String op) { + if (expr.args().size() != 1) { + throw new IllegalArgumentException(String.format("unexpected unary: %s", expr)); + } + stringBuilder.append(op); + boolean nested = isComplexOperator(expr.args().get(0)); + visitMaybeNested(expr.args().get(0), nested); + } + + private void visitBinary(CelCall expr, String op) { + if (expr.args().size() != 2) { + throw new IllegalArgumentException(String.format("unexpected binary: %s", expr)); + } + + CelExpr lhs = expr.args().get(0); + CelExpr rhs = expr.args().get(1); + String fun = expr.function(); + + // add parens if the current operator is lower precedence than the lhs expr + // operator. + boolean lhsParen = isComplexOperatorWithRespectTo(lhs, fun); + // add parens if the current operator is lower precedence than the rhs expr + // operator, or the same precedence and the operator is left recursive. + boolean rhsParen = isComplexOperatorWithRespectTo(rhs, fun); + if (!rhsParen && isOperatorLeftRecursive(fun)) { + rhsParen = isOperatorSamePrecedence(fun, rhs); + } + + visitMaybeNested(lhs, lhsParen); + stringBuilder.append(SPACE).append(op).append(SPACE); + visitMaybeNested(rhs, rhsParen); + } + + private void visitSelect(CelExpr operand, boolean testOnly, String op, String field) { + if (testOnly) { + stringBuilder.append(Operator.HAS.getFunction()).append(LEFT_PAREN); + } + boolean nested = !testOnly && isBinaryOrTernaryOperator(operand); + visitMaybeNested(operand, nested); + stringBuilder.append(op).append(maybeQuoteField(field)); + if (testOnly) { + stringBuilder.append(RIGHT_PAREN); + } + } + + private void visitTernary(CelCall expr) { + if (expr.args().size() != 3) { + throw new IllegalArgumentException(String.format("unexpected ternary: %s", expr)); + } + + boolean nested = + isOperatorSamePrecedence(Operator.CONDITIONAL.getFunction(), expr.args().get(0)) + || isComplexOperator(expr.args().get(0)); + visitMaybeNested(expr.args().get(0), nested); + + stringBuilder.append(SPACE).append(QUESTION_MARK).append(SPACE); + + nested = + isOperatorSamePrecedence(Operator.CONDITIONAL.getFunction(), expr.args().get(1)) + || isComplexOperator(expr.args().get(1)); + visitMaybeNested(expr.args().get(1), nested); + + stringBuilder.append(SPACE).append(COLON).append(SPACE); + + nested = + isOperatorSamePrecedence(Operator.CONDITIONAL.getFunction(), expr.args().get(2)) + || isComplexOperator(expr.args().get(2)); + visitMaybeNested(expr.args().get(2), nested); + } + + private void visitIndex(CelCall expr, String op) { + if (expr.args().size() != 2) { + throw new IllegalArgumentException(String.format("unexpected index call: %s", expr)); + } + boolean nested = isBinaryOrTernaryOperator(expr.args().get(0)); + visitMaybeNested(expr.args().get(0), nested); + stringBuilder.append(op); + visit(expr.args().get(1)); + stringBuilder.append(RIGHT_BRACKET); + } + + protected void visitMaybeNested(CelExpr expr, boolean nested) { + if (nested) { + stringBuilder.append(LEFT_PAREN); + } + visit(expr); + if (nested) { + stringBuilder.append(RIGHT_PAREN); + } + } + + protected boolean isBinaryOrTernaryOperator(CelExpr expr) { + if (!isComplexOperator(expr)) { + return false; + } + return Operator.lookupBinaryOperator(expr.call().function()).isPresent() + || isOperatorSamePrecedence(Operator.CONDITIONAL.getFunction(), expr); + } + + private boolean isComplexOperator(CelExpr expr) { + // If the arg is a call with more than one arg, return true + return expr.exprKind().getKind().equals(Kind.CALL) && expr.call().args().size() >= 2; + } + + private boolean isOperatorSamePrecedence(String op, CelExpr expr) { + if (!expr.exprKind().getKind().equals(Kind.CALL)) { + return false; + } + return Operator.lookupPrecedence(op) == Operator.lookupPrecedence(expr.call().function()); + } + + private boolean isComplexOperatorWithRespectTo(CelExpr expr, String op) { + // If the arg is not a call with more than one arg, return false. + if (!expr.exprKind().getKind().equals(Kind.CALL) || expr.call().args().size() < 2) { + return false; + } + // Otherwise, return whether the given op has lower precedence than expr + return isOperatorLowerPrecedence(op, expr); + } + + // bytesToOctets converts byte sequences to a string using a three digit octal encoded value + // per byte. + private String bytesToOctets(CelByteString bytes) { + StringBuilder sb = new StringBuilder(); + for (byte b : bytes.toByteArray()) { + sb.append(String.format("\\%03o", b)); + } + return sb.toString(); + } + + @VisibleForTesting + static boolean isOperatorLeftRecursive(String op) { + return !op.equals(LOGICAL_AND.getFunction()) && !op.equals(LOGICAL_OR.getFunction()); + } + + @VisibleForTesting + static boolean isOperatorLowerPrecedence(String op, CelExpr expr) { + if (!expr.exprKind().getKind().equals(CelExpr.ExprKind.Kind.CALL)) { + return false; + } + return Operator.lookupPrecedence(op) < Operator.lookupPrecedence(expr.call().function()); + } +} diff --git a/parser/src/main/java/dev/cel/parser/ExpressionBalancer.java b/parser/src/main/java/dev/cel/parser/ExpressionBalancer.java new file mode 100644 index 000000000..bdf812b11 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/ExpressionBalancer.java @@ -0,0 +1,84 @@ +// Copyright 2022 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.parser; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; +import static com.google.common.base.Strings.isNullOrEmpty; + +import dev.cel.common.ast.CelExpr; +import java.util.ArrayList; + +/** + * Package-private balancer that performs tree balancing on operators whose arguments are of equal + * precedence. + * + *

The purpose of the balancer is to ensure a compact serialization format for the logical &&, || + * operators which have a tendency to create long DAGs which are skewed in one direction. Since the + * operators are commutative re-ordering the terms *must not* affect the evaluation result. + * + *

Based on code from //third_party/cel/go/parser/helper.go and + * //third_party/cel/cpp/parser/parser.cc + */ +final class ExpressionBalancer { + + private final String function; + private final ArrayList terms; + private final ArrayList ids; + + ExpressionBalancer(String function, CelExpr expr) { + checkArgument(!isNullOrEmpty(function)); + this.function = function; + terms = new ArrayList<>(); + terms.add(checkNotNull(expr)); + ids = new ArrayList<>(); + } + + void add(long operationId, CelExpr expr) { + checkNotNull(expr); + checkArgument(operationId > 0L); + terms.add(expr); + ids.add(operationId); + } + + CelExpr balance() { + // add(long, Expr) should have been called at least once, as the visitor should have terminated + // early. The following check ensures that is the case. + checkState(terms.size() > 1); + return balance(0, ids.size() - 1); + } + + private CelExpr balance(int lo, int hi) { + int mid = (lo + hi + 1) / 2; + CelExpr left; + if (mid == lo) { + left = terms.get(mid); + } else { + left = balance(lo, mid - 1); + } + CelExpr right; + if (mid == hi) { + right = terms.get(mid + 1); + } else { + right = balance(mid + 1, hi); + } + return CelExpr.newBuilder() + .setId(ids.get(mid)) + .setCall( + CelExpr.CelCall.newBuilder().setFunction(function).addArgs(left).addArgs(right).build()) + .build(); + } +} diff --git a/parser/src/main/java/dev/cel/parser/Parser.java b/parser/src/main/java/dev/cel/parser/Parser.java new file mode 100644 index 000000000..af860e936 --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/Parser.java @@ -0,0 +1,1381 @@ +// Copyright 2022 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.parser; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; +import static com.google.common.primitives.Ints.min; + +import cel.parser.internal.CELBaseVisitor; +import cel.parser.internal.CELLexer; +import cel.parser.internal.CELParser; +import cel.parser.internal.CELParser.BoolFalseContext; +import cel.parser.internal.CELParser.BoolTrueContext; +import cel.parser.internal.CELParser.BytesContext; +import cel.parser.internal.CELParser.CalcContext; +import cel.parser.internal.CELParser.ConditionalAndContext; +import cel.parser.internal.CELParser.ConditionalOrContext; +import cel.parser.internal.CELParser.ConstantLiteralContext; +import cel.parser.internal.CELParser.CreateListContext; +import cel.parser.internal.CELParser.CreateMapContext; +import cel.parser.internal.CELParser.CreateMessageContext; +import cel.parser.internal.CELParser.DoubleContext; +import cel.parser.internal.CELParser.EscapeIdentContext; +import cel.parser.internal.CELParser.EscapedIdentifierContext; +import cel.parser.internal.CELParser.ExprContext; +import cel.parser.internal.CELParser.ExprListContext; +import cel.parser.internal.CELParser.FieldInitializerListContext; +import cel.parser.internal.CELParser.GlobalCallContext; +import cel.parser.internal.CELParser.IdentContext; +import cel.parser.internal.CELParser.IndexContext; +import cel.parser.internal.CELParser.IntContext; +import cel.parser.internal.CELParser.ListInitContext; +import cel.parser.internal.CELParser.LogicalNotContext; +import cel.parser.internal.CELParser.MapInitializerListContext; +import cel.parser.internal.CELParser.MemberCallContext; +import cel.parser.internal.CELParser.MemberExprContext; +import cel.parser.internal.CELParser.NegateContext; +import cel.parser.internal.CELParser.NestedContext; +import cel.parser.internal.CELParser.NullContext; +import cel.parser.internal.CELParser.OptExprContext; +import cel.parser.internal.CELParser.OptFieldContext; +import cel.parser.internal.CELParser.PrimaryExprContext; +import cel.parser.internal.CELParser.RelationContext; +import cel.parser.internal.CELParser.SelectContext; +import cel.parser.internal.CELParser.SimpleIdentifierContext; +import cel.parser.internal.CELParser.StartContext; +import cel.parser.internal.CELParser.StringContext; +import cel.parser.internal.CELParser.UintContext; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.FormatMethod; +import com.google.errorprone.annotations.FormatString; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelIssue; +import dev.cel.common.CelOptions; +import dev.cel.common.CelSource; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.CelValidationResult; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.internal.CodePointStream; +import dev.cel.common.internal.Constants; +import java.text.ParseException; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.BitSet; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Supplier; +import org.antlr.v4.runtime.ANTLRErrorListener; +import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.DefaultErrorStrategy; +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.Recognizer; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.atn.ATNConfigSet; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.ParseCancellationException; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.ParseTree; +import org.antlr.v4.runtime.tree.ParseTreeListener; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * Parses a CEL expression and returns an abstraction syntax tree in the form of + * google.api.expr.ParsedExpr. Currently this uses ANTLRv4 for lexing and parsing. + */ +final class Parser extends CELBaseVisitor { + + private static final CelExpr ERROR = CelExpr.newBuilder().setConstant(Constants.ERROR).build(); + private static final ImmutableSet RESERVED_IDS = + ImmutableSet.of( + "as", + "break", + "const", + "continue", + "else", + "false", + "for", + "function", + "if", + "import", + "in", + "let", + "loop", + "package", + "namespace", + "null", + "return", + "true", + "var", + "void", + "while"); + private static final String ACCUMULATOR_NAME = "__result__"; + private static final String HIDDEN_ACCUMULATOR_NAME = "@result"; + + static CelValidationResult parse(CelParserImpl parser, CelSource source, CelOptions options) { + if (source.getContent().size() > options.maxExpressionCodePointSize()) { + return new CelValidationResult( + source, + ImmutableList.of( + CelIssue.formatError( + CelSourceLocation.NONE, + String.format( + "expression code point size exceeds limit: size: %d, limit %d", + source.getContent().size(), options.maxExpressionCodePointSize())))); + } + CELLexer antlrLexer = + new CELLexer(new CodePointStream(source.getDescription(), source.getContent())); + CELParser antlrParser = new CELParser(new CommonTokenStream(antlrLexer)); + CelSource.Builder sourceInfo = source.toBuilder(); + sourceInfo.setDescription(source.getDescription()); + ExprFactory exprFactory = + new ExprFactory( + antlrParser, + sourceInfo, + options.enableHiddenAccumulatorVar() ? HIDDEN_ACCUMULATOR_NAME : ACCUMULATOR_NAME); + Parser parserImpl = new Parser(parser, options, sourceInfo, exprFactory); + ErrorListener errorListener = new ErrorListener(exprFactory); + antlrLexer.removeErrorListeners(); + antlrParser.removeErrorListeners(); + antlrLexer.addErrorListener(errorListener); + antlrParser.addErrorListener(errorListener); + antlrParser.addParseListener( + new PerRuleRecursionListener(exprFactory, options.maxParseRecursionDepth())); + antlrParser.setErrorHandler( + new RecoveryLimitErrorStrategy(options.maxParseErrorRecoveryLimit())); + CelExpr expr; + try { + StartContext context = checkNotNull(antlrParser.start()); + expr = checkNotNull(parserImpl.visit(context)); + } catch (ParseCancellationException parseFailure) { + return new CelValidationResult( + sourceInfo.build(), parseFailure, ImmutableList.copyOf(exprFactory.getIssuesList())); + } + return new CelValidationResult( + CelAbstractSyntaxTree.newParsedAst(expr, sourceInfo.build()), + ImmutableList.copyOf(exprFactory.getIssuesList())); + } + + private final CelParserImpl parser; + private final CelOptions options; + private final CelSource.Builder sourceInfo; + private final ExprFactory exprFactory; + + private int recursionDepth; + + private Parser( + CelParserImpl parser, + CelOptions options, + CelSource.Builder sourceInfo, + ExprFactory exprFactory) { + this.parser = parser; + this.options = options; + this.sourceInfo = sourceInfo; + this.exprFactory = exprFactory; + } + + @Override + public CelExpr visit(ParseTree tree) { + ParseTree unnestedNode = unnest(tree); + boolean isLeftRecursiveNode = isLeftRecursiveForCountingDepths(unnestedNode); + if (isLeftRecursiveNode) { + checkAndIncrementRecursionDepth(); + CelExpr expr = super.visit(unnestedNode); + decrementRecursionDepth(); + return expr; + } + + return super.visit(unnestedNode); + } + + @Override + public CelExpr visitStart(StartContext context) { + checkNotNull(context); + if (context.e == null) { + return exprFactory.ensureErrorsExist(context); + } + return visit(context.e); + } + + @Override + public CelExpr visitExpr(ExprContext context) { + checkNotNull(context); + if (context.e == null) { + return exprFactory.ensureErrorsExist(context); + } + CelExpr condition = visit(context.e); + if (context.op != null) { + if (context.e1 == null || context.e2 == null) { + return exprFactory.ensureErrorsExist(context); + } + condition = + exprFactory + .newExprBuilder(context.op) + .setCall( + CelExpr.CelCall.newBuilder() + .setFunction(Operator.CONDITIONAL.getFunction()) + .addArgs(condition) + .addArgs(visit(context.e1)) + .addArgs(visit(context.e2)) + .build()) + .build(); + } + + return condition; + } + + @Override + public CelExpr visitConditionalOr(ConditionalOrContext context) { + checkNotNull(context); + if (context.e == null) { + return exprFactory.ensureErrorsExist(context); + } + CelExpr conditionalOr = visit(context.e); + if (context.ops == null || context.ops.isEmpty()) { + return conditionalOr; + } + ExpressionBalancer balancer = + new ExpressionBalancer(Operator.LOGICAL_OR.getFunction(), conditionalOr); + int index = 0; + for (Token token : context.ops) { + if (context.e1 == null || index >= context.e1.size()) { + return exprFactory.reportError(context, "unexpected character, wanted '||'"); + } + long operationId = exprFactory.newExprId(exprFactory.getPosition(token)); + CelExpr term = visit(context.e1.get(index)); + balancer.add(operationId, term); + index++; + } + return balancer.balance(); + } + + @Override + public CelExpr visitConditionalAnd(ConditionalAndContext context) { + checkNotNull(context); + if (context.e == null) { + return exprFactory.ensureErrorsExist(context); + } + CelExpr conditionalAnd = visit(context.e); + if (context.ops == null || context.ops.isEmpty()) { + return conditionalAnd; + } + ExpressionBalancer balancer = + new ExpressionBalancer(Operator.LOGICAL_AND.getFunction(), conditionalAnd); + int index = 0; + for (Token token : context.ops) { + if (context.e1 == null || index >= context.e1.size()) { + return exprFactory.reportError(context, "unexpected character, wanted '&&'"); + } + long operationId = exprFactory.newExprId(exprFactory.getPosition(token)); + CelExpr term = visit(context.e1.get(index)); + balancer.add(operationId, term); + index++; + } + return balancer.balance(); + } + + @Override + public CelExpr visitRelation(RelationContext context) { + checkNotNull(context); + if (context.calc() != null) { + return visit(context.calc()); + } + if (context.relation() == null || context.relation().isEmpty() || context.op == null) { + return exprFactory.ensureErrorsExist(context); + } + Optional operator = Operator.find(context.op.getText()); + if (!operator.isPresent()) { + return exprFactory.reportError(context, "operator not found"); + } + CelExpr left = visit(context.relation(0)); + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.op); + CelExpr right = visit(context.relation(1)); + return exprBuilder + .setCall( + CelExpr.CelCall.newBuilder() + .setFunction(operator.get().getFunction()) + .addArgs(left) + .addArgs(right) + .build()) + .build(); + } + + @Override + public CelExpr visitCalc(CalcContext context) { + checkNotNull(context); + if (context.unary() != null) { + return visit(context.unary()); + } + if (context.calc() == null || context.calc().isEmpty() || context.op == null) { + return exprFactory.ensureErrorsExist(context); + } + Optional operator = Operator.find(context.op.getText()); + if (!operator.isPresent()) { + return exprFactory.reportError(context, "operator not found"); + } + CelExpr left = visit(context.calc(0)); + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.op); + CelExpr right = visit(context.calc(1)); + return exprBuilder + .setCall( + CelExpr.CelCall.newBuilder() + .setFunction(operator.get().getFunction()) + .addArgs(left) + .addArgs(right) + .build()) + .build(); + } + + @Override + public CelExpr visitMemberExpr(MemberExprContext context) { + checkNotNull(context); + if (context.member() == null) { + return exprFactory.ensureErrorsExist(context); + } + return visit(context.member()); + } + + @Override + public CelExpr visitLogicalNot(LogicalNotContext context) { + checkNotNull(context); + if (context.member() == null) { + return exprFactory.ensureErrorsExist(context); + } + if (context.ops != null && options.retainRepeatedUnaryOperators()) { + CelExpr expr = visit(context.member()); + for (int index = context.ops.size(); index > 0; --index) { + expr = + exprFactory + .newExprBuilder(context.ops.get(index - 1)) + .setCall( + CelExpr.CelCall.newBuilder() + .setFunction(Operator.LOGICAL_NOT.getFunction()) + .addArgs(expr) + .build()) + .build(); + } + return expr; + } else if (context.ops == null || context.ops.size() % 2 == 0) { + return visit(context.member()); + } + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.ops.get(0)); + CelExpr member = visit(context.member()); + return exprBuilder + .setCall( + CelExpr.CelCall.newBuilder() + .setFunction(Operator.LOGICAL_NOT.getFunction()) + .addArgs(member) + .build()) + .build(); + } + + @Override + public CelExpr visitNegate(NegateContext context) { + checkNotNull(context); + if (context.member() == null) { + return exprFactory.ensureErrorsExist(context); + } + if (context.ops != null && options.retainRepeatedUnaryOperators()) { + CelExpr expr = visit(context.member()); + for (int index = context.ops.size(); index > 0; --index) { + expr = + exprFactory + .newExprBuilder(context.ops.get(index - 1)) + .setCall( + CelExpr.CelCall.newBuilder() + .setFunction(Operator.NEGATE.getFunction()) + .addArgs(expr) + .build()) + .build(); + } + return expr; + } else if (context.ops == null || context.ops.size() % 2 == 0) { + return visit(context.member()); + } + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.ops.get(0)); + CelExpr member = visit(context.member()); + return exprBuilder + .setCall( + CelExpr.CelCall.newBuilder() + .setFunction(Operator.NEGATE.getFunction()) + .addArgs(member) + .build()) + .build(); + } + + @Override + public CelExpr visitPrimaryExpr(PrimaryExprContext context) { + checkNotNull(context); + if (context.primary() == null) { + return exprFactory.ensureErrorsExist(context); + } + return visit(context.primary()); + } + + @Override + public CelExpr visitSelect(SelectContext context) { + checkNotNull(context); + if (context.member() == null) { + return exprFactory.ensureErrorsExist(context); + } + CelExpr member = visit(context.member()); + if (context.id == null) { + return exprFactory.newExprBuilder(context).build(); + } + String id = normalizeEscapedIdent(context.id); + + if (context.opt != null && context.opt.getText().equals("?")) { + if (!options.enableOptionalSyntax()) { + return exprFactory.reportError(context.op, "unsupported syntax '.?'"); + } + + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(exprFactory.getPosition(context.op)); + CelExpr.CelCall callExpr = + CelExpr.CelCall.newBuilder() + .setFunction(Operator.OPTIONAL_SELECT.getFunction()) + .addArgs( + Arrays.asList( + member, + exprFactory + .newExprBuilder(context) + .setConstant(CelConstant.ofValue(id)) + .build())) + .build(); + + return exprBuilder.setCall(callExpr).build(); + } + + return exprFactory + .newExprBuilder(context.op) + .setSelect(CelExpr.CelSelect.newBuilder().setOperand(member).setField(id).build()) + .build(); + } + + @Override + public CelExpr visitMemberCall(MemberCallContext context) { + checkNotNull(context); + if (context.member() == null) { + return exprFactory.ensureErrorsExist(context); + } + CelExpr member = visit(context.member()); + if (context.id == null) { + return exprFactory.newExprBuilder(context).build(); + } + String id = context.id.getText(); + return receiverCallOrMacro(context, id, member); + } + + @Override + public CelExpr visitIndex(IndexContext context) { + checkNotNull(context); + if (context.member() == null || context.index == null) { + return exprFactory.ensureErrorsExist(context); + } + CelExpr member = visit(context.member()); + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.op); + CelExpr index = visit(context.index); + Operator indexOperator = Operator.INDEX; + + if (context.opt != null && context.opt.getText().equals("?")) { + if (!options.enableOptionalSyntax()) { + return exprFactory.reportError(context.op, "unsupported syntax '[?'"); + } + indexOperator = Operator.OPTIONAL_INDEX; + } + + return exprBuilder + .setCall( + CelExpr.CelCall.newBuilder() + .setFunction(indexOperator.getFunction()) + .addArgs(member) + .addArgs(index) + .build()) + .build(); + } + + @Override + public CelExpr visitCreateMessage(CreateMessageContext context) { + checkNotNull(context); + StringBuilder msgNameBuilder = new StringBuilder(); + for (Token token : context.ids) { + if (msgNameBuilder.length() > 0) { + msgNameBuilder.append("."); + } + msgNameBuilder.append(token.getText()); + } + + if (context.leadingDot != null) { + msgNameBuilder.insert(0, "."); + } + + String messageName = msgNameBuilder.toString(); + if (messageName.isEmpty()) { + return exprFactory.ensureErrorsExist(context); + } + + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.op); + CelExpr.CelStruct.Builder structExpr = visitStructFields(context.entries); + return exprBuilder.setStruct(structExpr.setMessageName(messageName).build()).build(); + } + + @Override + public CelExpr visitIdent(IdentContext context) { + checkNotNull(context); + if (context.id == null) { + return exprFactory.newExprBuilder(context).build(); + } + String id = context.id.getText(); + if (options.enableReservedIds() && RESERVED_IDS.contains(id)) { + return exprFactory.reportError(context, "reserved identifier: %s", id); + } + if (context.leadingDot != null) { + id = "." + id; + } + + return exprFactory + .newExprBuilder(context.id) + .setIdent(CelExpr.CelIdent.newBuilder().setName(id).build()) + .build(); + } + + @Override + public CelExpr visitGlobalCall(GlobalCallContext context) { + checkNotNull(context); + if (context.id == null) { + return exprFactory.newExprBuilder(context).build(); + } + String id = context.id.getText(); + if (options.enableReservedIds() && RESERVED_IDS.contains(id)) { + return exprFactory.reportError(context, "reserved identifier: %s", id); + } + if (context.leadingDot != null) { + id = "." + id; + } + + return globalCallOrMacro(context, id); + } + + @Override + public CelExpr visitNested(NestedContext context) { + checkNotNull(context); + if (context.e == null) { + return exprFactory.ensureErrorsExist(context); + } + return visit(context.e); + } + + @Override + public CelExpr visitCreateList(CreateListContext context) { + checkNotNull(context); + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.op); + CelExpr.CelList createListExpr = visitListInitElements(context.listInit()); + + return exprBuilder.setList(createListExpr).build(); + } + + private CelExpr.CelList visitListInitElements(ListInitContext context) { + CelExpr.CelList.Builder listExpr = CelExpr.CelList.newBuilder(); + if (context == null) { + return listExpr.build(); + } + + for (int index = 0; index < context.elems.size(); index++) { + OptExprContext elem = context.elems.get(index); + listExpr.addElements(visit(elem.e)); + + if (elem.opt != null) { + if (!options.enableOptionalSyntax()) { + exprFactory.reportError(elem.opt, "unsupported syntax '?'"); + continue; + } + listExpr.addOptionalIndices(index); + } + } + + return listExpr.build(); + } + + @Override + public CelExpr visitCreateMap(CreateMapContext context) { + checkNotNull(context); + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.op); + CelExpr.CelMap.Builder createMapExpr = visitMapEntries(context.entries); + return exprBuilder.setMap(createMapExpr.build()).build(); + } + + private CelExpr buildMacroCallArgs(CelExpr expr) { + CelExpr.Builder resultExpr = CelExpr.newBuilder().setId(expr.id()); + if (sourceInfo.containsMacroCalls(expr.id())) { + return resultExpr.build(); + } + // Call expression could have args or sub-args that are also macros found in macro calls + if (expr.exprKind().getKind() == CelExpr.ExprKind.Kind.CALL) { + CelExpr.CelCall.Builder callExpr = + CelExpr.CelCall.newBuilder().setFunction(expr.call().function()); + // Iterate the AST from `expr` recursively looking for macros. Because we are at most + // starting from the top level macro, this recursion is bounded by the size of the AST. This + // means that the depth check on the AST during parsing will catch recursion overflows + // before we get to here. + expr.call().args().forEach(arg -> callExpr.addArgs(buildMacroCallArgs(arg))); + expr.call().target().ifPresent(target -> callExpr.setTarget(buildMacroCallArgs(target))); + return resultExpr.setCall(callExpr.build()).build(); + } + return expr; + } + + /** + * Returns the expanded AST after visiting a macro. Optional.empty is returned instead if the + * implementation decides that an expansion should not be performed, in which case we should just + * default to call. + */ + private Optional visitMacro( + CelExpr.Builder expr, + String id, + ImmutableList args, + Optional target, + CelMacro macro) { + + Optional expandedMacro = + expandMacro( + exprFactory.getPosition(expr.id()), + macro, + target.orElse(CelExpr.newBuilder().build()), + args); + if (!expandedMacro.isPresent()) { + return Optional.empty(); + } + CelExpr.CelCall.Builder callExpr = CelExpr.CelCall.newBuilder().setFunction(id); + if (target.isPresent()) { + if (sourceInfo.containsMacroCalls(target.get().id())) { + callExpr.setTarget(CelExpr.newBuilder().setId(target.get().id()).build()); + } else { + callExpr.setTarget(target.get()); + } + } + for (CelExpr arg : args) { + callExpr.addArgs(buildMacroCallArgs(arg)); + } + + if (options.populateMacroCalls()) { + sourceInfo.addMacroCalls( + expandedMacro.get().id(), + // Note: A macro id MUST NOT be assigned to the call expr placed into the macro calls map. + // This can cause an infinite loop in some of the call chains that try to figure out + // whether the current expression is expanded to a macro. + CelExpr.newBuilder().setCall(callExpr.build()).build()); + } + + sourceInfo.removePositions(expr.id()); + return expandedMacro; + } + + private String normalizeEscapedIdent(EscapeIdentContext context) { + String identifier = context.getText(); + if (context instanceof SimpleIdentifierContext) { + return identifier; + } else if (context instanceof EscapedIdentifierContext) { + if (!options.enableQuotedIdentifierSyntax()) { + exprFactory.reportError(context, "unsupported syntax '`'"); + return identifier; + } + return identifier.substring(1, identifier.length() - 1); + } + + // This is normally unreachable, but might happen if the parser is in an error state or if the + // grammar is updated and not handled here. + exprFactory.reportError(context, "unsupported identifier"); + return identifier; + } + + private CelExpr.CelStruct.Builder visitStructFields(FieldInitializerListContext context) { + if (context == null + || context.cols == null + || context.fields == null + || context.values == null) { + return CelExpr.CelStruct.newBuilder(); + } + int entryCount = min(context.cols.size(), context.fields.size(), context.values.size()); + CelExpr.CelStruct.Builder structExpr = CelExpr.CelStruct.newBuilder(); + for (int index = 0; index < entryCount; index++) { + OptFieldContext fieldContext = context.fields.get(index); + boolean isOptionalEntry = false; + if (fieldContext.opt != null) { + if (!options.enableOptionalSyntax()) { + exprFactory.reportError(fieldContext.opt, "unsupported syntax '?'"); + } else { + isOptionalEntry = true; + } + } + + // The field may be empty due to a prior error. + if (fieldContext.escapeIdent() == null) { + return CelExpr.CelStruct.newBuilder(); + } + String fieldName = normalizeEscapedIdent(fieldContext.escapeIdent()); + + CelExpr.CelStruct.Entry.Builder exprBuilder = + CelExpr.CelStruct.Entry.newBuilder() + .setId(exprFactory.newExprId(exprFactory.getPosition(context.cols.get(index)))); + structExpr.addEntries( + exprBuilder + .setFieldKey(fieldName) + .setValue(visit(context.values.get(index))) + .setOptionalEntry(isOptionalEntry) + .build()); + } + return structExpr; + } + + private CelExpr.CelMap.Builder visitMapEntries(MapInitializerListContext context) { + if (context == null || context.cols == null || context.keys == null || context.values == null) { + return CelExpr.CelMap.newBuilder(); + } + int entryCount = min(context.cols.size(), context.keys.size(), context.values.size()); + CelExpr.CelMap.Builder mapExpr = CelExpr.CelMap.newBuilder(); + for (int index = 0; index < entryCount; index++) { + OptExprContext keyContext = context.keys.get(index); + boolean isOptionalEntry = false; + if (keyContext.opt != null) { + if (!options.enableOptionalSyntax()) { + exprFactory.reportError(keyContext.opt, "unsupported syntax '?'"); + } else { + isOptionalEntry = true; + } + } + CelExpr.CelMap.Entry.Builder exprBuilder = + CelExpr.CelMap.Entry.newBuilder() + .setId(exprFactory.newExprId(exprFactory.getPosition(context.cols.get(index)))); + mapExpr.addEntries( + exprBuilder + .setKey(visit(keyContext.e)) + .setValue(visit(context.values.get(index))) + .setOptionalEntry(isOptionalEntry) + .build()); + } + return mapExpr; + } + + @Override + protected CelExpr defaultResult() { + // visitTerminalNode and visitErrorNode call this method. + return exprFactory.ensureErrorsExist( + () -> "Abstract syntax tree in an unexpected state, this is likely a bug."); + } + + @Override + public CelExpr visitConstantLiteral(ConstantLiteralContext context) { + checkNotNull(context); + if (context.literal() == null) { + return exprFactory.ensureErrorsExist(context); + } + return visit(context.literal()); + } + + @Override + public CelExpr visitExprList(ExprListContext context) { + // We should never get here, as we do not directly visit expression lists. + return exprFactory.ensureErrorsExist(context); + } + + @Override + public CelExpr visitFieldInitializerList(FieldInitializerListContext context) { + // We should never get here, as we do not directly visit field initializer lists. + return exprFactory.ensureErrorsExist(context); + } + + @Override + public CelExpr visitMapInitializerList(MapInitializerListContext context) { + // We should never get here, as we do not directly visit map initializer lists. + return exprFactory.ensureErrorsExist(context); + } + + @Override + public CelExpr visitListInit(ListInitContext context) { + // We should never get here, as we do not directly visit list initializer. + return exprFactory.ensureErrorsExist(context); + } + + @Override + public CelExpr visitInt(IntContext context) { + checkNotNull(context); + CelConstant constExpr; + try { + constExpr = Constants.parseInt(context.getText()); + } catch (ParseException e) { + return exprFactory.reportError(context, e.getMessage()); + } + + return exprFactory.newExprBuilder(context.tok).setConstant(constExpr).build(); + } + + @Override + public CelExpr visitUint(UintContext context) { + checkNotNull(context); + CelConstant constExpr; + try { + constExpr = Constants.parseUint(context.getText()); + } catch (ParseException e) { + return exprFactory.reportError(context, e.getMessage()); + } + return exprFactory.newExprBuilder(context).setConstant(constExpr).build(); + } + + @Override + public CelExpr visitDouble(DoubleContext context) { + checkNotNull(context); + CelConstant constExpr; + try { + constExpr = Constants.parseDouble(context.getText()); + } catch (ParseException e) { + return exprFactory.reportError(context, e.getMessage()); + } + return exprFactory.newExprBuilder(context.tok).setConstant(constExpr).build(); + } + + @Override + public CelExpr visitString(StringContext context) { + checkNotNull(context); + CelConstant constExpr; + try { + constExpr = Constants.parseString(context.getText()); + } catch (ParseException e) { + return exprFactory.reportError(context, e.getMessage()); + } + return exprFactory.newExprBuilder(context).setConstant(constExpr).build(); + } + + @Override + public CelExpr visitBytes(BytesContext context) { + checkNotNull(context); + CelConstant constExpr; + try { + constExpr = Constants.parseBytes(context.getText()); + } catch (ParseException e) { + return exprFactory.reportError(context, e.getMessage()); + } + return exprFactory.newExprBuilder(context).setConstant(constExpr).build(); + } + + @Override + public CelExpr visitBoolTrue(BoolTrueContext context) { + checkNotNull(context); + return exprFactory.newExprBuilder(context).setConstant(Constants.TRUE).build(); + } + + @Override + public CelExpr visitBoolFalse(BoolFalseContext context) { + checkNotNull(context); + return exprFactory.newExprBuilder(context).setConstant(Constants.FALSE).build(); + } + + @Override + public CelExpr visitNull(NullContext context) { + checkNotNull(context); + return exprFactory.newExprBuilder(context).setConstant(Constants.NULL).build(); + } + + private Optional expandMacro( + int position, CelMacro macro, CelExpr target, ImmutableList arguments) { + exprFactory.pushPosition(position); + try { + return macro.getExpander().expandMacro(exprFactory, target, arguments); + } finally { + exprFactory.popPosition(); + } + } + + private CelExpr receiverCallOrMacro(MemberCallContext context, String id, CelExpr member) { + return macroOrCall(context.args, context.open, id, Optional.of(member), true); + } + + private CelExpr globalCallOrMacro(GlobalCallContext context, String id) { + return macroOrCall(context.args, context.op, id, Optional.empty(), false); + } + + private ImmutableList visitExprListContext(ExprListContext args) { + int argCount = args != null && args.e != null ? args.e.size() : 0; + if (argCount == 0) { + return ImmutableList.of(); + } + + ImmutableList.Builder argumentsBuilder = + ImmutableList.builderWithExpectedSize(argCount); + for (ExprContext argExprCtx : args.e) { + argumentsBuilder.add(visit(argExprCtx)); + } + return argumentsBuilder.build(); + } + + private CelExpr macroOrCall( + ExprListContext args, + Token open, + String id, + Optional member, + boolean isReceiverStyle) { + int argCount = args != null && args.e != null ? args.e.size() : 0; + Optional macro = lookupMacro(id, argCount, isReceiverStyle); + CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(open); + + ImmutableList arguments = visitExprListContext(args); + Optional errorArg = arguments.stream().filter(ERROR::equals).findAny(); + if (errorArg.isPresent()) { + sourceInfo.removePositions(exprBuilder.id()); + // Any arguments passed in to the macro may fail parsing. + // Stop the macro expansion in this case as the result of the macro will be a parse failure. + return ERROR; + } + + if (macro.isPresent()) { + Optional expandedMacro = visitMacro(exprBuilder, id, arguments, member, macro.get()); + if (expandedMacro.isPresent()) { + return expandedMacro.get(); + } + } + + CelExpr.CelCall.Builder callExpr = + CelExpr.CelCall.newBuilder().setFunction(id).addArgs(arguments); + member.ifPresent(callExpr::setTarget); + + return exprBuilder.setCall(callExpr.build()).build(); + } + + private Optional lookupMacro(String id, int argCount, boolean receiverStlye) { + String key = CelMacro.formatKey(id, argCount, receiverStlye); + Optional macro = parser.findMacro(key); + if (macro.isPresent()) { + return macro; + } + key = CelMacro.formatVarArgKey(id, receiverStlye); + return parser.findMacro(key); + } + + /** + * Checks whether a given parse tree node is left recursive for the purposes of counting recursion + * depths. + */ + private boolean isLeftRecursiveForCountingDepths(ParseTree node) { + // There are certainly more left recursive nodes than what's shown below. + // We try to catch the specific node types that explodes the number of recursive visit calls and + // of those that cannot be caught by PerRuleRecursionListener. + return node instanceof ExprContext + || node instanceof CalcContext + || node instanceof RelationContext + || node instanceof SelectContext + || node instanceof MemberCallContext + || node instanceof IndexContext; + } + + private void checkAndIncrementRecursionDepth() { + recursionDepth++; + if (recursionDepth > options.maxParseRecursionDepth()) { + String errorMessage = + String.format( + "Expression recursion limit exceeded. limit: %d", options.maxParseRecursionDepth()); + exprFactory.reportError(CelIssue.formatError(CelSourceLocation.of(1, 0), errorMessage)); + throw new ParseCancellationException(errorMessage); + } + } + + private void decrementRecursionDepth() { + recursionDepth--; + } + + /** + * unnest traverses down the left-hand side of the parse graph until it encounters the first + * compound parse node or the first leaf in the parse graph. + */ + private ParseTree unnest(ParseTree tree) { + while (tree != null) { + if (tree instanceof ExprContext) { + // conditionalOr op='?' conditionalOr : expr + ExprContext context = (ExprContext) tree; + if (context.op != null) { + return tree; + } + // conditionalOr + tree = context.e; + } else if (tree instanceof ConditionalOrContext) { + // conditionalAnd (ops=|| conditionalAnd)* + ConditionalOrContext context = (ConditionalOrContext) tree; + if (context.ops != null && !context.ops.isEmpty()) { + return tree; + } + // conditionalAnd + tree = context.e; + } else if (tree instanceof ConditionalAndContext) { + // relation (ops=&& relation)* + ConditionalAndContext context = (ConditionalAndContext) tree; + if (context.ops != null && !context.ops.isEmpty()) { + return tree; + } + + // relation + tree = context.e; + } else if (tree instanceof RelationContext) { + // relation op relation + RelationContext context = (RelationContext) tree; + if (context.op != null) { + return tree; + } + // calc + tree = context.calc(); + } else if (tree instanceof CalcContext) { + // calc op calc + CalcContext context = (CalcContext) tree; + if (context.op != null) { + return tree; + } + + // unary + tree = context.unary(); + } else if (tree instanceof MemberExprContext) { + // member expands to one of: primary, select, index, or create message + tree = ((MemberExprContext) tree).member(); + } else if (tree instanceof PrimaryExprContext) { + // primary expands to one of identifier, nested, create list, create struct, literal + tree = ((PrimaryExprContext) tree).primary(); + } else if (tree instanceof NestedContext) { + // contains a nested 'expr' + tree = ((NestedContext) tree).e; + } else if (tree instanceof ConstantLiteralContext) { + // expands to a primitive literal + tree = ((ConstantLiteralContext) tree).literal(); + } else { + return tree; + } + } + + return tree; + } + + /** Implementation of {@link CelMacroExprFactory}. */ + private static final class ExprFactory extends CelMacroExprFactory { + + private final org.antlr.v4.runtime.Parser recognizer; + private final CelSource.Builder sourceInfo; + private final ArrayList issues; + private final ArrayDeque positions; + private final String accumulatorVarName; + + private ExprFactory( + org.antlr.v4.runtime.Parser recognizer, + CelSource.Builder sourceInfo, + String accumulatorVarName) { + this.recognizer = recognizer; + this.sourceInfo = sourceInfo; + this.issues = new ArrayList<>(); + this.positions = new ArrayDeque<>(1); // Currently this usually contains at most 1 position. + this.accumulatorVarName = accumulatorVarName; + } + + // Implementation of CelExprFactory. + + @Override + protected CelSourceLocation getSourceLocation(long exprId) { + checkArgument(exprId > 0L); + return getLocation(getPosition(exprId)); + } + + @CanIgnoreReturnValue + @Override + public CelExpr reportError(CelIssue error) { + checkNotNull(error); + issues.add(error); + if (!CelSourceLocation.NONE.equals(error.getSourceLocation())) { + Optional offset = sourceInfo.getLocationOffset(error.getSourceLocation()); + checkState(offset.isPresent()); // A valid location should always return a valid offset. + return newExpr(offset.get()); + } + return ERROR; + } + + @Override + public String getAccumulatorVarName() { + return accumulatorVarName; + } + + // Internal methods used by the parser but not part of the public API. + @FormatMethod + @CanIgnoreReturnValue + private CelExpr reportError( + ParserRuleContext context, @FormatString String format, Object... args) { + return reportError(context, String.format(format, args)); + } + + @CanIgnoreReturnValue + private CelExpr reportError(ParserRuleContext context, String message) { + return reportError(CelIssue.formatError(getLocation(context), message)); + } + + @CanIgnoreReturnValue + private CelExpr reportError(Token token, String message) { + return reportError(CelIssue.formatError(getLocation(token), message)); + } + + // Implementation of CelExprFactory. + + @Override + protected CelSourceLocation currentSourceLocationForMacro() { + checkState(!positions.isEmpty()); // Should only be called while expanding macros. + return getLocation(peekPosition()); + } + + // Internal methods used by the parser but not part of the public API. + + private void pushPosition(int position) { + positions.addLast(position); + } + + private void popPosition() { + checkState(!positions.isEmpty()); + positions.removeLast(); + } + + private int peekPosition() { + checkState(!positions.isEmpty()); + return positions.peekLast(); + } + + private long nextExprId(int position) { + long exprId = super.nextExprId(); + if (position != -1) { + sourceInfo.addPositions(exprId, position); + } + return exprId; + } + + @Override + public long copyExprId(long id) { + return nextExprId(getPosition(id)); + } + + @Override + public long nextExprId() { + checkState(!positions.isEmpty()); // Should only be called while expanding macros. + // Do not call this method directly from within the parser, use nextExprId(int). + return nextExprId(peekPosition()); + } + + private List getIssuesList() { + return issues; + } + + private int getPosition(long exprId) { + return Optional.ofNullable(sourceInfo.getPositionsMap().get(exprId)).orElse(-1); + } + + private int getPosition(Token token) { + return sourceInfo + .getLocationOffset(token.getLine(), token.getCharPositionInLine()) + .orElse(-1); + } + + private int getPosition(ParserRuleContext context) { + return getPosition(context.getStart()); + } + + private CelSourceLocation getLocation(int position) { + return sourceInfo.getOffsetLocation(position).orElse(CelSourceLocation.NONE); + } + + private CelSourceLocation getLocation(Token token) { + return CelSourceLocation.of(token.getLine(), token.getCharPositionInLine()); + } + + private CelSourceLocation getLocation(ParserRuleContext context) { + return getLocation(context.getStart()); + } + + @CanIgnoreReturnValue + private long newExprId(int position) { + return nextExprId(position); + } + + private CelExpr.Builder newExprBuilder(int position) { + return CelExpr.newBuilder().setId(newExprId(position)); + } + + private CelExpr.Builder newExprBuilder(Token token) { + return newExprBuilder(getPosition(token)); + } + + private CelExpr.Builder newExprBuilder(ParserRuleContext context) { + return newExprBuilder(getPosition(context)); + } + + private CelExpr newExpr(int position) { + return newExprBuilder(position).build(); + } + + private CelExpr ensureErrorsExist(Supplier message) { + // Because we do not treat syntax errors as fatal during parsing, the parse tree is often in + // an abnormal state. We call this function to ensure we have recorded syntax errors. If we + // have we return the special error node otherwise we bail and mention that this is likely a + // bug. + if (issues.isEmpty()) { + // If we reach here, this is an unexpected error and highly likely to be a bug. At least one + // syntax error or another error should have occurred because the parse tree is in an + // unexpected state. + throw new ParseCancellationException( + String.format( + "Abstract syntax tree in an unexpected state, this is likely a bug: %s", + message.get())); + } + return ERROR; + } + + private CelExpr ensureErrorsExist(ParserRuleContext context) { + return ensureErrorsExist(() -> context.toInfoString(recognizer)); + } + } + + /** + * Listener that enforces a maximum recursion depth, to avoid accidental stack overflow issues + * when parsing large expressions. + */ + private static final class PerRuleRecursionListener implements ParseTreeListener { + + private final ExprFactory exprFactory; + private final int maxRecursionDepth; + private final Map ruleTypeDepth; + + private PerRuleRecursionListener(ExprFactory exprFactory, int maxRecursionDepth) { + this.exprFactory = exprFactory; + this.maxRecursionDepth = maxRecursionDepth; + this.ruleTypeDepth = new HashMap<>(); + } + + @Override + public void enterEveryRule(ParserRuleContext context) { + int ruleDepth = ruleTypeDepth.getOrDefault(context.getRuleIndex(), 0) + 1; + ruleTypeDepth.put(context.getRuleIndex(), ruleDepth); + if (ruleDepth > maxRecursionDepth) { + String errorMessage = + String.format("Expression recursion limit exceeded. limit: %d", maxRecursionDepth); + exprFactory.reportError(CelIssue.formatError(CelSourceLocation.of(1, 0), errorMessage)); + throw new ParseCancellationException(errorMessage); + } + } + + @Override + public void exitEveryRule(ParserRuleContext context) { + int ruleDepth = ruleTypeDepth.get(context.getRuleIndex()) - 1; + ruleTypeDepth.put(context.getRuleIndex(), ruleDepth); + } + + @Override + public void visitErrorNode(ErrorNode node) {} + + @Override + public void visitTerminal(TerminalNode node) {} + } + + /** Error strategy that limits the number of recovery attempts. */ + private static final class RecoveryLimitErrorStrategy extends DefaultErrorStrategy { + + private final int recoveryLimit; + private int recoveryAttempts; + + private RecoveryLimitErrorStrategy(int recoveryLimit) { + this.recoveryLimit = recoveryLimit; + recoveryAttempts = 0; + } + + @Override + public void recover(org.antlr.v4.runtime.Parser recognizer, RecognitionException e) { + checkRecoveryLimit(recognizer); + super.recover(recognizer, e); + } + + @Override + public Token recoverInline(org.antlr.v4.runtime.Parser recognizer) { + checkRecoveryLimit(recognizer); + return super.recoverInline(recognizer); + } + + private void checkRecoveryLimit(org.antlr.v4.runtime.Parser recognizer) { + if (recoveryAttempts++ >= recoveryLimit) { + String tooManyErrors = String.format("More than %d parse errors.", recoveryLimit); + recognizer.notifyErrorListeners(tooManyErrors); + throw new ParseCancellationException(tooManyErrors); + } + } + } + + private static final class ErrorListener implements ANTLRErrorListener { + + private final ExprFactory exprFactory; + + private ErrorListener(ExprFactory exprFactory) { + this.exprFactory = exprFactory; + } + + @Override + public void reportAmbiguity( + org.antlr.v4.runtime.Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + boolean exact, + BitSet ambigAlts, + ATNConfigSet configs) { + // Intentional. + } + + @Override + public void reportAttemptingFullContext( + org.antlr.v4.runtime.Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + BitSet ambigAlts, + ATNConfigSet configs) { + // Intentional. + } + + @Override + public void reportContextSensitivity( + org.antlr.v4.runtime.Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + int prediction, + ATNConfigSet configs) { + // Intentional. + } + + @Override + public void syntaxError( + Recognizer recognizer, + Object offendingSymbol, + int line, + int charPositionInLine, + String msg, + RecognitionException e) { + msg = msg.replace("%", "%%"); + exprFactory.reportError( + CelIssue.formatError(CelSourceLocation.of(line, charPositionInLine), msg)); + } + } +} diff --git a/parser/src/main/java/dev/cel/parser/gen/BUILD.bazel b/parser/src/main/java/dev/cel/parser/gen/BUILD.bazel new file mode 100644 index 000000000..d4365e34d --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/gen/BUILD.bazel @@ -0,0 +1,31 @@ +""" +The generated parser is kept seperate from //parser/src/main/java/dev/cel/parser +to avoid a path conflict with parser/src/main/java/dev/cel/parser/CelParser.java +that causes build failures on filesystems with case-insensitive paths (e.g. macOS). +""" + +load("@rules_java//java:defs.bzl", "java_library") +load("//:antlr.bzl", "antlr4_java_combined") + +package(default_applicable_licenses = ["//:license"]) + +antlr4_java_combined( + name = "cel_g4", + src = "CEL.g4", + listener = False, + package = "cel.parser.internal", + visitor = True, +) + +java_library( + name = "cel_g4_visitors", + srcs = [":cel_g4"], + tags = [ + ], + visibility = [ + "//parser:__pkg__", + ], + deps = [ + "@maven//:org_antlr_antlr4_runtime", + ], +) diff --git a/parser/src/main/java/dev/cel/parser/gen/CEL.g4 b/parser/src/main/java/dev/cel/parser/gen/CEL.g4 new file mode 100644 index 000000000..65f4b830d --- /dev/null +++ b/parser/src/main/java/dev/cel/parser/gen/CEL.g4 @@ -0,0 +1,207 @@ +// Copyright 2023 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. + +grammar CEL; + +// Grammar Rules +// ============= + +start + : e=expr EOF + ; + +expr + : e=conditionalOr (op='?' e1=conditionalOr ':' e2=expr)? + ; + +conditionalOr + : e=conditionalAnd (ops+='||' e1+=conditionalAnd)* + ; + +conditionalAnd + : e=relation (ops+='&&' e1+=relation)* + ; + +relation + : calc + | relation op=('<'|'<='|'>='|'>'|'=='|'!='|'in') relation + ; + +calc + : unary + | calc op=('*'|'/'|'%') calc + | calc op=('+'|'-') calc + ; + +unary + : member # MemberExpr + | (ops+='!')+ member # LogicalNot + | (ops+='-')+ member # Negate + ; + +member + : primary # PrimaryExpr + | member op='.' (opt='?')? id=escapeIdent # Select + | member op='.' id=IDENTIFIER open='(' args=exprList? ')' # MemberCall + | member op='[' (opt='?')? index=expr ']' # Index + ; + +primary + : leadingDot='.'? id=IDENTIFIER # Ident + | leadingDot='.'? id=IDENTIFIER (op='(' args=exprList? ')') # GlobalCall + | '(' e=expr ')' # Nested + | op='[' elems=listInit? ','? ']' # CreateList + | op='{' entries=mapInitializerList? ','? '}' # CreateMap + | leadingDot='.'? ids+=IDENTIFIER (ops+='.' ids+=IDENTIFIER)* + op='{' entries=fieldInitializerList? ','? '}' # CreateMessage + | literal # ConstantLiteral + ; + +exprList + : e+=expr (',' e+=expr)* + ; + +listInit + : elems+=optExpr (',' elems+=optExpr)* + ; + +fieldInitializerList + : fields+=optField cols+=':' values+=expr (',' fields+=optField cols+=':' values+=expr)* + ; + +optField + : (opt='?')? escapeIdent + ; + +mapInitializerList + : keys+=optExpr cols+=':' values+=expr (',' keys+=optExpr cols+=':' values+=expr)* + ; + +escapeIdent + : id=IDENTIFIER # SimpleIdentifier + | id=ESC_IDENTIFIER # EscapedIdentifier + ; + +optExpr + : (opt='?')? e=expr + ; + +literal + : sign=MINUS? tok=NUM_INT # Int + | tok=NUM_UINT # Uint + | sign=MINUS? tok=NUM_FLOAT # Double + | tok=STRING # String + | tok=BYTES # Bytes + | tok=CEL_TRUE # BoolTrue + | tok=CEL_FALSE # BoolFalse + | tok=NUL # Null + ; + +// Lexer Rules +// =========== + +EQUALS : '=='; +NOT_EQUALS : '!='; +IN: 'in'; +LESS : '<'; +LESS_EQUALS : '<='; +GREATER_EQUALS : '>='; +GREATER : '>'; +LOGICAL_AND : '&&'; +LOGICAL_OR : '||'; + +LBRACKET : '['; +RPRACKET : ']'; +LBRACE : '{'; +RBRACE : '}'; +LPAREN : '('; +RPAREN : ')'; +DOT : '.'; +COMMA : ','; +MINUS : '-'; +EXCLAM : '!'; +QUESTIONMARK : '?'; +COLON : ':'; +PLUS : '+'; +STAR : '*'; +SLASH : '/'; +PERCENT : '%'; +CEL_TRUE : 'true'; +CEL_FALSE : 'false'; +NUL : 'null'; + +fragment BACKSLASH : '\\'; +fragment LETTER : 'A'..'Z' | 'a'..'z' ; +fragment DIGIT : '0'..'9' ; +fragment EXPONENT : ('e' | 'E') ( '+' | '-' )? DIGIT+ ; +fragment HEXDIGIT : ('0'..'9'|'a'..'f'|'A'..'F') ; +fragment RAW : 'r' | 'R'; + +fragment ESC_SEQ + : ESC_CHAR_SEQ + | ESC_BYTE_SEQ + | ESC_UNI_SEQ + | ESC_OCT_SEQ + ; + +fragment ESC_CHAR_SEQ + : BACKSLASH ('a'|'b'|'f'|'n'|'r'|'t'|'v'|'"'|'\''|'\\'|'?'|'`') + ; + +fragment ESC_OCT_SEQ + : BACKSLASH ('0'..'3') ('0'..'7') ('0'..'7') + ; + +fragment ESC_BYTE_SEQ + : BACKSLASH ( 'x' | 'X' ) HEXDIGIT HEXDIGIT + ; + +fragment ESC_UNI_SEQ + : BACKSLASH 'u' HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT + | BACKSLASH 'U' HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT + ; + +WHITESPACE : ( '\t' | ' ' | '\r' | '\n'| '\u000C' )+ -> channel(HIDDEN) ; +COMMENT : '//' (~'\n')* -> channel(HIDDEN) ; + +NUM_FLOAT + : ( DIGIT+ ('.' DIGIT+) EXPONENT? + | DIGIT+ EXPONENT + | '.' DIGIT+ EXPONENT? + ) + ; + +NUM_INT + : ( DIGIT+ | '0x' HEXDIGIT+ ); + +NUM_UINT + : DIGIT+ ( 'u' | 'U' ) + | '0x' HEXDIGIT+ ( 'u' | 'U' ) + ; + +STRING + : '"' (ESC_SEQ | ~('\\'|'"'|'\n'|'\r'))* '"' + | '\'' (ESC_SEQ | ~('\\'|'\''|'\n'|'\r'))* '\'' + | '"""' (ESC_SEQ | ~('\\'))*? '"""' + | '\'\'\'' (ESC_SEQ | ~('\\'))*? '\'\'\'' + | RAW '"' ~('"'|'\n'|'\r')* '"' + | RAW '\'' ~('\''|'\n'|'\r')* '\'' + | RAW '"""' .*? '"""' + | RAW '\'\'\'' .*? '\'\'\'' + ; + +BYTES : ('b' | 'B') STRING; + +IDENTIFIER : (LETTER | '_') ( LETTER | DIGIT | '_')*; +ESC_IDENTIFIER : '`' (LETTER | DIGIT | '_' | '.' | '-' | '/' | ' ')+ '`'; diff --git a/parser/src/test/java/dev/cel/parser/BUILD.bazel b/parser/src/test/java/dev/cel/parser/BUILD.bazel new file mode 100644 index 000000000..1ade0181d --- /dev/null +++ b/parser/src/test/java/dev/cel/parser/BUILD.bazel @@ -0,0 +1,54 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = [ + "//:license", + ], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*Test.java"]), + resources = ["//parser/src/test/resources:baselines"], + deps = [ + "//:auto_value", + "//:java_truth", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:operator", + "//common:options", + "//common:proto_ast", + "//common:source_location", + "//common/ast", + "//common/internal", + "//common/values:cel_byte_string", + "//extensions:optional_library", + "//parser", + "//parser:macro", + "//parser:parser_builder", + "//parser:parser_factory", + "//parser:unparser", + "//parser:unparser_visitor", + "//testing:adorner", + "//testing:baseline_test_case", + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_guava_guava_testlib", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/parser/src/test/java/dev/cel/parser/CelMacroExprFactoryTest.java b/parser/src/test/java/dev/cel/parser/CelMacroExprFactoryTest.java new file mode 100644 index 000000000..72abf81a4 --- /dev/null +++ b/parser/src/test/java/dev/cel/parser/CelMacroExprFactoryTest.java @@ -0,0 +1,298 @@ +// Copyright 2022 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.parser; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.primitives.UnsignedLong; +import dev.cel.common.CelIssue; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelStruct.Entry; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.internal.Constants; +import dev.cel.common.values.CelByteString; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelMacroExprFactoryTest { + + private static final class TestCelExprFactory extends CelMacroExprFactory { + + private long exprId; + + private TestCelExprFactory() { + exprId = 0L; + } + + @Override + public long copyExprId(long unused) { + return nextExprId(); + } + + @Override + public long nextExprId() { + return ++exprId; + } + + @Override + protected CelSourceLocation currentSourceLocationForMacro() { + return CelSourceLocation.NONE; + } + + @Override + public CelExpr reportError(CelIssue issue) { + return CelExpr.newBuilder().setId(nextExprId()).setConstant(Constants.ERROR).build(); + } + + @Override + public String getAccumulatorVarName() { + return "__result__"; + } + + @Override + protected CelSourceLocation getSourceLocation(long exprId) { + return CelSourceLocation.NONE; + } + + public void reset() { + exprId = 0L; + } + } + + @Test + public void newBoolLiteral_true_returnsBoolConstant() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr expr = exprFactory.newBoolLiteral(true); + assertThat(expr.id()).isEqualTo(1L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CONSTANT); + assertThat(expr.constant().getKind()).isEqualTo(CelConstant.Kind.BOOLEAN_VALUE); + assertThat(expr.constant().booleanValue()).isTrue(); + } + + @Test + public void newBoolLiteral_false_returnsBoolConstant() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr expr = exprFactory.newBoolLiteral(false); + assertThat(expr.id()).isEqualTo(1L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CONSTANT); + assertThat(expr.constant().getKind()).isEqualTo(CelConstant.Kind.BOOLEAN_VALUE); + assertThat(expr.constant().booleanValue()).isFalse(); + } + + @Test + public void newBytesLiteral_returnsBytesConstant() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr expr = exprFactory.newBytesLiteral("foo"); + assertThat(expr.id()).isEqualTo(1L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CONSTANT); + assertThat(expr.constant().getKind()).isEqualTo(CelConstant.Kind.BYTES_VALUE); + assertThat(expr.constant().bytesValue()).isEqualTo(CelByteString.copyFromUtf8("foo")); + } + + @Test + public void newBytesLiteral_overloadsAreEquivalent() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr want = exprFactory.newBytesLiteral("foo"); + exprFactory.reset(); + assertThat(exprFactory.newBytesLiteral(new byte[] {'f', 'o', 'o'})).isEqualTo(want); + } + + @Test + public void newDoubleLiteral_returnsDoubleConstant() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr expr = exprFactory.newDoubleLiteral(1.0); + assertThat(expr.id()).isEqualTo(1L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CONSTANT); + assertThat(expr.constant().getKind()).isEqualTo(CelConstant.Kind.DOUBLE_VALUE); + assertThat(expr.constant().doubleValue()).isEqualTo(1.0); + } + + @Test + public void newIntLiteral_returnsInt64Constant() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr expr = exprFactory.newIntLiteral(2L); + assertThat(expr.id()).isEqualTo(1L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CONSTANT); + assertThat(expr.constant().getKind()).isEqualTo(CelConstant.Kind.INT64_VALUE); + assertThat(expr.constant().int64Value()).isEqualTo(2L); + } + + @Test + public void newStringLiteral_returnsStringConstant() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr expr = exprFactory.newStringLiteral("foo"); + assertThat(expr.id()).isEqualTo(1L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CONSTANT); + assertThat(expr.constant().getKind()).isEqualTo(CelConstant.Kind.STRING_VALUE); + assertThat(expr.constant().stringValue()).isEqualTo("foo"); + } + + @Test + public void newUintLiteral_returnsUint64Constant() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr expr = exprFactory.newUintLiteral(2L); + assertThat(expr.id()).isEqualTo(1L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CONSTANT); + assertThat(expr.constant().getKind()).isEqualTo(CelConstant.Kind.UINT64_VALUE); + assertThat(expr.constant().uint64Value()).isEqualTo(UnsignedLong.valueOf(2L)); + } + + @Test + public void newList_returnsList() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr element = exprFactory.newStringLiteral("foo"); + CelExpr expr = exprFactory.newList(element); + assertThat(expr.id()).isEqualTo(2L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.LIST); + assertThat(expr.list().elements()).hasSize(1); + assertThat(expr.list().elements()).containsExactly(element); + } + + @Test + public void newMap_returnsMap() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelMap.Entry entry = + exprFactory.newMapEntry( + exprFactory.newStringLiteral("foo"), exprFactory.newStringLiteral("bar")); + CelExpr expr = exprFactory.newMap(entry); + assertThat(expr.id()).isEqualTo(4L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.MAP); + assertThat(expr.map().entries()).containsExactly(entry); + } + + @Test + public void newMapEntry_returnsMapEntry() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr key = exprFactory.newStringLiteral("foo"); + CelExpr value = exprFactory.newStringLiteral("bar"); + CelMap.Entry entry = exprFactory.newMapEntry(key, value); + assertThat(entry.id()).isEqualTo(3L); + assertThat(entry.value()).isEqualTo(value); + } + + @Test + public void newMessage_returnsMessage() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + Entry field = exprFactory.newMessageField("foo", exprFactory.newStringLiteral("bar")); + CelExpr expr = exprFactory.newMessage("google.example.Baz", field); + assertThat(expr.id()).isEqualTo(3L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.STRUCT); + assertThat(expr.struct().messageName()).isEqualTo("google.example.Baz"); + assertThat(expr.struct().entries()).containsExactly(field); + } + + @Test + public void newMessageField_returnsMessageField() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr value = exprFactory.newStringLiteral("bar"); + Entry field = exprFactory.newMessageField("foo", value); + assertThat(field.id()).isEqualTo(2L); + assertThat(field.value()).isEqualTo(value); + } + + @Test + public void fold_returnsComprehension() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr iterRange = exprFactory.newList(); + CelExpr accuInit = exprFactory.newIntLiteral(0L); + CelExpr loopCondition = exprFactory.newBoolLiteral(true); + CelExpr loopStep = exprFactory.newIntLiteral(1L); + CelExpr result = exprFactory.newIdentifier("foo"); + CelExpr expr = exprFactory.fold("i", iterRange, "a", accuInit, loopCondition, loopStep, result); + assertThat(expr.id()).isEqualTo(6L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.COMPREHENSION); + assertThat(expr.comprehension().iterVar()).isEqualTo("i"); + assertThat(expr.comprehension().iterVar2()).isEmpty(); + assertThat(expr.comprehension().iterRange()).isEqualTo(iterRange); + assertThat(expr.comprehension().accuVar()).isEqualTo("a"); + assertThat(expr.comprehension().accuInit()).isEqualTo(accuInit); + assertThat(expr.comprehension().loopCondition()).isEqualTo(loopCondition); + assertThat(expr.comprehension().loopStep()).isEqualTo(loopStep); + assertThat(expr.comprehension().result()).isEqualTo(result); + } + + @Test + public void fold_returnsTwoVariableComprehension() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr iterRange = exprFactory.newList(); + CelExpr accuInit = exprFactory.newIntLiteral(0L); + CelExpr loopCondition = exprFactory.newBoolLiteral(true); + CelExpr loopStep = exprFactory.newIntLiteral(1L); + CelExpr result = exprFactory.newIdentifier("foo"); + CelExpr expr = + exprFactory.fold("i", "j", iterRange, "a", accuInit, loopCondition, loopStep, result); + assertThat(expr.id()).isEqualTo(6L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.COMPREHENSION); + assertThat(expr.comprehension().iterVar()).isEqualTo("i"); + assertThat(expr.comprehension().iterVar2()).isEqualTo("j"); + assertThat(expr.comprehension().iterRange()).isEqualTo(iterRange); + assertThat(expr.comprehension().accuVar()).isEqualTo("a"); + assertThat(expr.comprehension().accuInit()).isEqualTo(accuInit); + assertThat(expr.comprehension().loopCondition()).isEqualTo(loopCondition); + assertThat(expr.comprehension().loopStep()).isEqualTo(loopStep); + assertThat(expr.comprehension().result()).isEqualTo(result); + } + + @Test + public void newIdentifier_returnsIdentifier() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr expr = exprFactory.newIdentifier("foo"); + assertThat(expr.id()).isEqualTo(1L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.IDENT); + assertThat(expr.ident().name()).isEqualTo("foo"); + } + + @Test + public void newGlobalCall_returnsGlobalCall() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr argument = exprFactory.newStringLiteral("bar"); + CelExpr expr = exprFactory.newGlobalCall("foo", argument); + assertThat(expr.id()).isEqualTo(2L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CALL); + assertThat(expr.call().target()).isEmpty(); + assertThat(expr.call().function()).isEqualTo("foo"); + assertThat(expr.call().args()).containsExactly(argument); + } + + @Test + public void newReceiverCall_returnsReceiverCall() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr target = exprFactory.newIdentifier("baz"); + CelExpr argument = exprFactory.newStringLiteral("bar"); + CelExpr expr = exprFactory.newReceiverCall("foo", target, argument); + assertThat(expr.id()).isEqualTo(3L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CALL); + assertThat(expr.call().target()).hasValue(target); + assertThat(expr.call().function()).isEqualTo("foo"); + assertThat(expr.call().args()).containsExactly(argument); + } + + @Test + public void newSelect_returnsSelect() { + TestCelExprFactory exprFactory = new TestCelExprFactory(); + CelExpr operand = exprFactory.newIdentifier("foo"); + CelExpr expr = exprFactory.newSelect(operand, "bar", false); + assertThat(expr.id()).isEqualTo(2L); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.SELECT); + assertThat(expr.select().operand()).isEqualTo(operand); + assertThat(expr.select().field()).isEqualTo("bar"); + assertThat(expr.select().testOnly()).isFalse(); + } +} diff --git a/parser/src/test/java/dev/cel/parser/CelMacroTest.java b/parser/src/test/java/dev/cel/parser/CelMacroTest.java new file mode 100644 index 000000000..585b01578 --- /dev/null +++ b/parser/src/test/java/dev/cel/parser/CelMacroTest.java @@ -0,0 +1,57 @@ +// Copyright 2022 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.parser; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.common.ast.CelExpr; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelMacroTest { + + @Test + public void testGlobalVarArgMacro() { + CelMacro macro = + CelMacro.newGlobalVarArgMacro( + "foo", (sourceFactory, target, arguments) -> Optional.of(CelExpr.newBuilder().build())); + assertThat(macro.getFunction()).isEqualTo("foo"); + assertThat(macro.getArgumentCount()).isEqualTo(0); + assertThat(macro.isReceiverStyle()).isFalse(); + assertThat(macro.getKey()).isEqualTo("foo:*:false"); + assertThat(macro.isVariadic()).isTrue(); + assertThat(macro.toString()).isEqualTo(macro.getKey()); + assertThat(macro.hashCode()).isEqualTo(macro.getKey().hashCode()); + assertThat(macro).isEquivalentAccordingToCompareTo(macro); + } + + @Test + public void testReceiverVarArgMacro() { + CelMacro macro = + CelMacro.newReceiverVarArgMacro( + "foo", (sourceFactory, target, arguments) -> Optional.of(CelExpr.newBuilder().build())); + assertThat(macro.getFunction()).isEqualTo("foo"); + assertThat(macro.getArgumentCount()).isEqualTo(0); + assertThat(macro.isReceiverStyle()).isTrue(); + assertThat(macro.getKey()).isEqualTo("foo:*:true"); + assertThat(macro.isVariadic()).isTrue(); + assertThat(macro.toString()).isEqualTo(macro.getKey()); + assertThat(macro.hashCode()).isEqualTo(macro.getKey().hashCode()); + assertThat(macro).isEquivalentAccordingToCompareTo(macro); + } +} diff --git a/parser/src/test/java/dev/cel/parser/CelParserFactoryTest.java b/parser/src/test/java/dev/cel/parser/CelParserFactoryTest.java new file mode 100644 index 000000000..f6efaa68a --- /dev/null +++ b/parser/src/test/java/dev/cel/parser/CelParserFactoryTest.java @@ -0,0 +1,30 @@ +// Copyright 2022 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.parser; + +import static com.google.common.truth.Truth.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelParserFactoryTest { + + @Test + public void standardCelParserBuilder() { + assertThat(CelParserFactory.standardCelParserBuilder().build()).isNotNull(); + } +} diff --git a/parser/src/test/java/dev/cel/parser/CelParserImplTest.java b/parser/src/test/java/dev/cel/parser/CelParserImplTest.java new file mode 100644 index 000000000..1e7b44fab --- /dev/null +++ b/parser/src/test/java/dev/cel/parser/CelParserImplTest.java @@ -0,0 +1,322 @@ +// Copyright 2022 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.parser; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableSet; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelIssue; +import dev.cel.common.CelOptions; +import dev.cel.common.CelSource; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.ast.CelExpr; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelParserImplTest { + + // This file exercises non-parsing related methods in CelParser. See CelParserParameterizedTest + // for parsing related tests. + + @Test + public void build_withMacros_containsAllMacros() { + CelParserImpl parser = + (CelParserImpl) + CelParserImpl.newBuilder().setStandardMacros(CelStandardMacro.STANDARD_MACROS).build(); + assertThat(parser.findMacro("has:1:false")).hasValue(CelStandardMacro.HAS.getDefinition()); + assertThat(parser.findMacro("all:2:true")).hasValue(CelStandardMacro.ALL.getDefinition()); + assertThat(parser.findMacro("exists:2:true")).hasValue(CelStandardMacro.EXISTS.getDefinition()); + assertThat(parser.findMacro("exists_one:2:true")) + .hasValue(CelStandardMacro.EXISTS_ONE.getDefinition()); + assertThat(parser.findMacro("map:2:true")).hasValue(CelStandardMacro.MAP.getDefinition()); + assertThat(parser.findMacro("map:3:true")) + .hasValue(CelStandardMacro.MAP_FILTER.getDefinition()); + assertThat(parser.findMacro("filter:2:true")).hasValue(CelStandardMacro.FILTER.getDefinition()); + } + + @Test + public void build_withStandardMacros_containsAllMacros() { + CelParserImpl parser = + (CelParserImpl) + CelParserImpl.newBuilder().setStandardMacros(CelStandardMacro.STANDARD_MACROS).build(); + assertThat(parser.findMacro("has:1:false")).hasValue(CelStandardMacro.HAS.getDefinition()); + assertThat(parser.findMacro("all:2:true")).hasValue(CelStandardMacro.ALL.getDefinition()); + assertThat(parser.findMacro("exists:2:true")).hasValue(CelStandardMacro.EXISTS.getDefinition()); + assertThat(parser.findMacro("exists_one:2:true")) + .hasValue(CelStandardMacro.EXISTS_ONE.getDefinition()); + assertThat(parser.findMacro("map:2:true")).hasValue(CelStandardMacro.MAP.getDefinition()); + assertThat(parser.findMacro("map:3:true")) + .hasValue(CelStandardMacro.MAP_FILTER.getDefinition()); + assertThat(parser.findMacro("filter:2:true")).hasValue(CelStandardMacro.FILTER.getDefinition()); + } + + @Test + public void build_withStandardMacrosAndCustomMacros_containsAllMacros() { + CelMacro customMacro = + CelMacro.newReceiverMacro( + "customMacro", 1, (a, b, c) -> Optional.of(CelExpr.newBuilder().build())); + CelParserImpl parser = + (CelParserImpl) + CelParserImpl.newBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addMacros(customMacro) + .build(); + + assertThat(parser.findMacro("has:1:false")).hasValue(CelStandardMacro.HAS.getDefinition()); + assertThat(parser.findMacro("all:2:true")).hasValue(CelStandardMacro.ALL.getDefinition()); + assertThat(parser.findMacro("exists:2:true")).hasValue(CelStandardMacro.EXISTS.getDefinition()); + assertThat(parser.findMacro("exists_one:2:true")) + .hasValue(CelStandardMacro.EXISTS_ONE.getDefinition()); + assertThat(parser.findMacro("map:2:true")).hasValue(CelStandardMacro.MAP.getDefinition()); + assertThat(parser.findMacro("map:3:true")) + .hasValue(CelStandardMacro.MAP_FILTER.getDefinition()); + assertThat(parser.findMacro("filter:2:true")).hasValue(CelStandardMacro.FILTER.getDefinition()); + assertThat(parser.findMacro("customMacro:1:true")).hasValue(customMacro); + } + + @Test + public void build_withMacro_containsMacro() { + CelParserImpl parser = + (CelParserImpl) CelParserImpl.newBuilder().setStandardMacros(CelStandardMacro.HAS).build(); + assertThat(parser.findMacro("has:1:false")).hasValue(CelStandardMacro.HAS.getDefinition()); + } + + @Test + public void build_withStandardMacro_containsMacro() { + CelParserImpl parser = + (CelParserImpl) CelParserImpl.newBuilder().setStandardMacros(CelStandardMacro.HAS).build(); + assertThat(parser.findMacro("has:1:false")).hasValue(CelStandardMacro.HAS.getDefinition()); + } + + @Test + public void build_withStandardMacro_secondCallReplaces() { + CelParserImpl parser = + (CelParserImpl) + CelParserImpl.newBuilder() + .setStandardMacros(CelStandardMacro.HAS, CelStandardMacro.ALL) + .setStandardMacros(CelStandardMacro.HAS) + .build(); + + assertThat(parser.findMacro("has:1:false")).hasValue(CelStandardMacro.HAS.getDefinition()); + assertThat(parser.findMacro("all:2:true")).isEmpty(); + } + + @Test + public void build_standardMacroKeyConflictsWithCustomMacro_throws() { + CelMacro customMacro = + CelMacro.newGlobalMacro("has", 1, (a, b, c) -> Optional.of(CelExpr.newBuilder().build())); + + assertThrows( + IllegalArgumentException.class, + () -> + CelParserImpl.newBuilder() + .setStandardMacros(CelStandardMacro.HAS) + .addMacros(customMacro) + .build()); + } + + @Test + public void build_containsNoMacros() { + CelParserImpl parser = (CelParserImpl) CelParserImpl.newBuilder().build(); + assertThat(parser.findMacro("has:1:false")).isEmpty(); + } + + @Test + public void setParserLibrary_success() { + CelParserImpl parser = + (CelParserImpl) + CelParserImpl.newBuilder() + .addLibraries( + new CelParserLibrary() { + @Override + public void setParserOptions(CelParserBuilder parserBuilder) { + parserBuilder.addMacros( + CelMacro.newReceiverVarArgMacro( + "dummyMacro", + (a, b, c) -> Optional.of(CelExpr.newBuilder().build()))); + } + }) + .build(); + + assertThat(parser.findMacro("dummyMacro:*:true")).isPresent(); + } + + @Test + public void parse_throwsWhenExpressionSizeCodePointLimitExceeded() { + CelParserImpl parser = + (CelParserImpl) + CelParserImpl.newBuilder() + .setOptions(CelOptions.newBuilder().maxExpressionCodePointSize(2).build()) + .build(); + CelValidationResult parseResult = parser.parse(CelSource.newBuilder("foo").build()); + CelValidationException exception = + assertThrows(CelValidationException.class, parseResult::getAst); + assertThat(exception.getErrors()).hasSize(1); + assertThat(exception.getErrors().get(0).getMessage()) + .isEqualTo("expression code point size exceeds limit: size: 3, limit 2"); + } + + private enum MaxParseRecursionDepthTestCase { + LARGE_CALC( + "1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 +" + + " 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34"), + NESTED_PARENS("((((((((((((((((((((((((((((((((7))))))))))))))))))))))))))))))))"), + NESTED_PARENS_WITH_CALC( + "((((((((((((((((((((((((((((((((7)))))))))))))))))))))))))))))))) +" + + "(((((((((((((((((((((((((((((((7)))))))))))))))))))))))))))))))"), + FIELD_SELECTIONS("a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.A.B.C.D.E.F.G.H"), + INDEX_OPERATIONS( + "a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20][21][22][23][24][25][26][27][28][29][30][31][32][33]"), + RELATION_OPERATORS( + "a < 1 < 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < 11 < 12 < 13 < 14 < 15 < 16 < 17 < 18 < 19 <" + + " 20 < 21 < 22 < 23 < 24 < 25 < 26 < 27 < 28 < 29 < 30 < 31 < 32 < 33"), + // More than 32 index / relation operators. Note, the recursion count is the + // maximum recursion level on the left or right side index expression (20) plus + // the number of relation operators (13) + INDEX_RELATION_OPERATORS( + "a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20] !=" + + " a[1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20]"); + + static final int MAX_RECURSION_LIMIT = 32; + final String source; + + MaxParseRecursionDepthTestCase(String source) { + this.source = source; + } + } + + @Test + public void parse_largeExprHitsMaxRecursionLimit_throws( + @TestParameter MaxParseRecursionDepthTestCase testCase) { + int maxParseRecursionLimit = MaxParseRecursionDepthTestCase.MAX_RECURSION_LIMIT; + CelParser parser = + CelParserImpl.newBuilder() + .setOptions( + CelOptions.newBuilder().maxParseRecursionDepth(maxParseRecursionLimit).build()) + .build(); + + CelValidationResult parseResult = parser.parse(CelSource.newBuilder(testCase.source).build()); + + CelValidationException exception = + assertThrows(CelValidationException.class, parseResult::getAst); + assertThat(exception) + .hasMessageThat() + .contains("Expression recursion limit exceeded. limit: " + maxParseRecursionLimit); + assertThat(exception.getErrors()).hasSize(1); + CelIssue issue = exception.getErrors().get(0); + assertThat(issue.getMessage()) + .contains("Expression recursion limit exceeded. limit: " + maxParseRecursionLimit); + assertThat(issue.getSourceLocation().getLine()).isEqualTo(1); + assertThat(issue.getSourceLocation().getColumn()).isEqualTo(0); + } + + @Test + public void parse_exprUnderMaxRecursionLimit_doesNotThrow( + @TestParameter MaxParseRecursionDepthTestCase testCase) throws CelValidationException { + int maxParseRecursionLimit = MaxParseRecursionDepthTestCase.MAX_RECURSION_LIMIT + 1; + + CelParser parser = + CelParserImpl.newBuilder() + .setOptions( + CelOptions.newBuilder().maxParseRecursionDepth(maxParseRecursionLimit).build()) + .build(); + CelValidationResult parseResult = parser.parse(CelSource.newBuilder(testCase.source).build()); + assertThat(parseResult.hasError()).isFalse(); + assertThat(parseResult.getAst()).isNotNull(); + } + + @Test + @TestParameters("{expression: 'A.map(a?b, c)'}") + @TestParameters("{expression: 'A.all(a?b, c)'}") + @TestParameters("{expression: 'A.exists(a?b, c)'}") + @TestParameters("{expression: 'A.exists_one(a?b, c)'}") + @TestParameters("{expression: 'A.existsOne(a?b, c)'}") + @TestParameters("{expression: 'A.filter(a?b, c)'}") + public void parse_macroArgumentContainsSyntaxError_throws(String expression) { + CelParser parser = + CelParserImpl.newBuilder() + .setStandardMacros( + ImmutableSet.builder() + .addAll(CelStandardMacro.STANDARD_MACROS) + .add(CelStandardMacro.EXISTS_ONE_NEW) + .build()) + .build(); + + CelValidationResult parseResult = parser.parse(expression); + + assertThat(parseResult.hasError()).isTrue(); + assertThat(parseResult.getErrorString()).containsMatch("ERROR: .*mismatched input ','"); + assertThrows(CelValidationException.class, parseResult::getAst); + } + + @Test + public void toParserBuilder_isNewInstance() { + CelParserBuilder celParserBuilder = CelParserFactory.standardCelParserBuilder(); + CelParserImpl celParser = (CelParserImpl) celParserBuilder.build(); + + CelParserImpl.Builder newParserBuilder = (CelParserImpl.Builder) celParser.toParserBuilder(); + + assertThat(newParserBuilder).isNotEqualTo(celParserBuilder); + } + + @Test + public void toParserBuilder_isImmutable() { + CelParserBuilder originalParserBuilder = CelParserFactory.standardCelParserBuilder(); + CelParserImpl celParser = (CelParserImpl) originalParserBuilder.build(); + originalParserBuilder.addLibraries(new CelParserLibrary() {}); + + CelParserImpl.Builder newParserBuilder = (CelParserImpl.Builder) celParser.toParserBuilder(); + + assertThat(newParserBuilder.getParserLibraries().build()).isEmpty(); + } + + @Test + public void toParserBuilder_collectionProperties_copied() { + CelParserBuilder celParserBuilder = + CelParserFactory.standardCelParserBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addMacros( + CelMacro.newGlobalMacro( + "test", 1, (a, b, c) -> Optional.of(CelExpr.newBuilder().build()))) + .addLibraries(new CelParserLibrary() {}); + CelParserImpl celParser = (CelParserImpl) celParserBuilder.build(); + + CelParserImpl.Builder newParserBuilder = (CelParserImpl.Builder) celParser.toParserBuilder(); + + assertThat(newParserBuilder.getStandardMacros()) + .hasSize(CelStandardMacro.STANDARD_MACROS.size()); + assertThat(newParserBuilder.getMacros()).hasSize(1); + assertThat(newParserBuilder.getParserLibraries().build()).hasSize(1); + } +} diff --git a/parser/src/test/java/dev/cel/parser/CelParserParameterizedTest.java b/parser/src/test/java/dev/cel/parser/CelParserParameterizedTest.java new file mode 100644 index 000000000..019cea520 --- /dev/null +++ b/parser/src/test/java/dev/cel/parser/CelParserParameterizedTest.java @@ -0,0 +1,528 @@ +// Copyright 2022 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.parser; + +import static java.util.Collections.reverseOrder; +import static java.util.Map.Entry.comparingByKey; +import static java.util.stream.Collectors.joining; + +import dev.cel.expr.Constant; +import dev.cel.expr.Expr; +import dev.cel.expr.ExprOrBuilder; +import dev.cel.expr.ParsedExpr; +import dev.cel.expr.SourceInfo; +import com.google.auto.value.AutoValue; +import com.google.common.base.Ascii; +import com.google.common.base.Joiner; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.EnumDescriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Descriptors.OneofDescriptor; +import com.google.protobuf.TextFormat; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.common.CelSource; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.testing.BaselineTestCase; +import dev.cel.testing.CelAdorner; +import dev.cel.testing.CelDebug; +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.Map; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** Invokes parser tests and compares their output against baseline files. */ +@RunWith(TestParameterInjector.class) +public final class CelParserParameterizedTest extends BaselineTestCase { + private static final CelParser PARSER = + CelParserFactory.standardCelParserBuilder() + .setStandardMacros( + ImmutableSet.builder() + .addAll(CelStandardMacro.STANDARD_MACROS) + .add(CelStandardMacro.EXISTS_ONE_NEW) + .build()) + .addLibraries(CelOptionalLibrary.INSTANCE) + .addMacros( + CelMacro.newGlobalVarArgMacro("noop_macro", (a, b, c) -> Optional.empty()), + CelMacro.newGlobalMacro( + "get_constant_macro", + 0, + (a, b, c) -> + Optional.of( + CelExpr.newBuilder() + .setId(1) + .setConstant(CelConstant.ofValue(10L)) + .build()))) + .setOptions( + CelOptions.current() + .populateMacroCalls(true) + .enableHiddenAccumulatorVar(true) + .build()) + .build(); + + private static final CelParser PARSER_WITH_OLD_ACCU_VAR = + PARSER + .toParserBuilder() + .setOptions( + CelOptions.current() + .populateMacroCalls(true) + .enableHiddenAccumulatorVar(false) + .build()) + .build(); + + @Test + public void parser() { + runTest(PARSER, "x * 2"); + runTest(PARSER, "x * 2u"); + runTest(PARSER, "x * 2.0"); + runTest(PARSER, "\"\\u2764\""); + runTest(PARSER, "\"\u2764\""); + runTest(PARSER, "! false"); + runTest(PARSER, "-a"); + runTest(PARSER, "a.b(5)"); + runTest(PARSER, "a[3]"); + runTest(PARSER, "SomeMessage{foo: 5, bar: \"xyz\"}"); + runTest(PARSER, "[3, 4, 5]"); + runTest(PARSER, "{foo: 5, bar: \"xyz\"}"); + runTest(PARSER, "a > 5 && a < 10"); + runTest(PARSER, "a < 5 || a > 10"); + runTest(PARSER, "\"abc\" + \"def\""); + runTest(PARSER, "\"A\""); + runTest(PARSER, "true"); + runTest(PARSER, "false"); + runTest(PARSER, "0"); + runTest(PARSER, "42"); + runTest(PARSER, "0u"); + runTest(PARSER, "23u"); + runTest(PARSER, "24u"); + runTest(PARSER, "0xAu"); + runTest(PARSER, "-0xA"); + runTest(PARSER, "0xA"); + runTest(PARSER, "-1"); + runTest(PARSER, "4--4"); + runTest(PARSER, "4--4.1"); + runTest(PARSER, "b\"abc\""); + runTest(PARSER, "23.39"); + runTest(PARSER, "!a"); + runTest(PARSER, "null"); + runTest(PARSER, "a"); + runTest(PARSER, "a?b:c"); + runTest(PARSER, "a || b"); + runTest(PARSER, "a || b || c || d || e || f"); + runTest(PARSER, "a && b"); + runTest(PARSER, "a && b && c && d && e && f && g"); + runTest(PARSER, "a && b && c && d || e && f && g && h"); + runTest(PARSER, "a + b"); + runTest(PARSER, "a - b"); + runTest(PARSER, "a * b"); + runTest(PARSER, "a / b"); + runTest(PARSER, "a % b"); + runTest(PARSER, "a in b"); + runTest(PARSER, "a == b"); + runTest(PARSER, "a != b"); + runTest(PARSER, "a > b"); + runTest(PARSER, "a >= b"); + runTest(PARSER, "a < b"); + runTest(PARSER, "a <= b"); + runTest(PARSER, "a.b"); + runTest(PARSER, "a.b.c"); + runTest(PARSER, "a[b]"); + runTest(PARSER, "foo{ }"); + runTest(PARSER, "foo{ a:b }"); + runTest(PARSER, "foo{ a:b, c:d }"); + runTest(PARSER, "{}"); + runTest(PARSER, "{a:b, c:d}"); + runTest(PARSER, "[]"); + runTest(PARSER, "[a]"); + runTest(PARSER, "[a, b, c]"); + runTest(PARSER, "(a)"); + runTest(PARSER, "((a))"); + runTest(PARSER, "a()"); + runTest(PARSER, "a(b)"); + runTest(PARSER, "a(b, c)"); + runTest(PARSER, "a.b()"); + runTest(PARSER, "a.b(c)"); + runTest(PARSER, "aaa.bbb(ccc)"); + runTest(PARSER, "has(m.f)"); + runTest(PARSER, "m.exists_one(v, f)"); + runTest(PARSER, "m.existsOne(v, f)"); + runTest(PARSER, "m.map(v, f)"); + runTest(PARSER, "m.map(v, p, f)"); + runTest(PARSER, "m.filter(v, p)"); + runTest(PARSER, "[] + [1,2,3,] + [4]"); + runTest(PARSER, "{1:2u, 2:3u}"); + runTest(PARSER, "TestAllTypes{single_int32: 1, single_int64: 2}"); + runTest(PARSER, "size(x) == x.size()"); + runTest(PARSER, "\"\\\"\""); + runTest(PARSER, "[1,3,4][0]"); + runTest(PARSER, "x[\"a\"].single_int32 == 23"); + runTest(PARSER, "x.single_nested_message != null"); + runTest(PARSER, "false && !true || false ? 2 : 3"); + runTest(PARSER, "b\"abc\" + B\"def\""); + runTest(PARSER, "1 + 2 * 3 - 1 / 2 == 6 % 1"); + runTest(PARSER, "---a"); + runTest(PARSER, "\"\\xC3\\XBF\""); + runTest(PARSER, "\"\\303\\277\""); + runTest(PARSER, "\"hi\\u263A \\u263Athere\""); + runTest(PARSER, "\"\\U000003A8\\?\""); + runTest(PARSER, "\"\\a\\b\\f\\n\\r\\t\\v'\\\"\\\\\\? Legal escapes\""); + runTest(PARSER, "'😁' in ['😁', 'πŸ˜‘', '😦']"); + runTest( + PARSER, + // Note, the ANTLR parse stack may recurse much more deeply and permit + // more detailed expressions than the visitor can recurse over in + // practice. + "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[['just fine'],[1],[2],[3],[4],[5]]]]]]]" + + "]]]]]]]]]]]]]]]]]]]]]]]]", + false); // parse output not validated as it is too large. + runTest(PARSER, "x.filter(y, y.filter(z, z > 0))"); + runTest(PARSER, "has(a.b).filter(c, c)"); + runTest(PARSER, "x.filter(y, y.exists(z, has(z.a)) && y.exists(z, has(z.b)))"); + runTest(PARSER, "noop_macro(123)"); + runTest(PARSER, "get_constant_macro()"); + runTest(PARSER, "a.?b[?0] && a[?c]"); + runTest(PARSER, "{?'key': value}"); + runTest(PARSER, "Msg{?field: value}"); + runTest(PARSER, "[?a, ?b]"); + runTest(PARSER, "[?a[?b]]"); + runTest( + CelParserImpl.newBuilder() + .setOptions(CelOptions.current().enableReservedIds(false).build()) + .build(), + "while"); + CelParser parserWithQuotedFields = + CelParserImpl.newBuilder() + .setOptions(CelOptions.current().enableQuotedIdentifierSyntax(true).build()) + .build(); + runTest(parserWithQuotedFields, "foo.`bar`"); + runTest(parserWithQuotedFields, "foo.`bar-baz`"); + runTest(parserWithQuotedFields, "foo.`bar baz`"); + runTest(parserWithQuotedFields, "foo.`bar.baz`"); + runTest(parserWithQuotedFields, "foo.`bar/baz`"); + runTest(parserWithQuotedFields, "foo.`bar_baz`"); + runTest(parserWithQuotedFields, "foo.`in`"); + runTest(parserWithQuotedFields, "Struct{`in`: false}"); + } + + @Test + public void parser_legacyAccuVar() { + runTest(PARSER_WITH_OLD_ACCU_VAR, "x * 2"); + runTest(PARSER_WITH_OLD_ACCU_VAR, "has(m.f)"); + runTest(PARSER_WITH_OLD_ACCU_VAR, "m.exists_one(v, f)"); + runTest(PARSER_WITH_OLD_ACCU_VAR, "m.all(v, f)"); + runTest(PARSER_WITH_OLD_ACCU_VAR, "m.map(v, f)"); + runTest(PARSER_WITH_OLD_ACCU_VAR, "m.map(v, p, f)"); + runTest(PARSER_WITH_OLD_ACCU_VAR, "m.filter(v, p)"); + } + + @Test + public void parser_errors() { + runTest(PARSER, "*@a | b"); + runTest(PARSER, "a | b"); + runTest(PARSER, "?"); + runTest(PARSER, "1 + $"); + runTest(PARSER, "1.all(2, 3)"); + runTest(PARSER, "1.exists(2, 3)"); + runTest(PARSER, "[].all(__result__, x)"); + runTest(PARSER, "[].exists(__result__, x)"); + runTest(PARSER, "[].exists_one(__result__, x)"); + runTest(PARSER, "[].map(__result__, x, x)"); + runTest(PARSER, "[].filter(__result__, x)"); + runTest(PARSER, "[].all(.x, x)"); + runTest(PARSER, "[].exists(.x, x)"); + runTest(PARSER, "[].exists_one(.x, x)"); + runTest(PARSER, "[].map(.x, x, x)"); + runTest(PARSER, "[].filter(.x, x)"); + runTest(PARSER, "1 + +"); + runTest(PARSER, "\"\\xFh\""); + runTest(PARSER, "\"\\a\\b\\f\\n\\r\\t\\v\\'\\\"\\\\\\? Illegal escape \\>\""); + runTest(PARSER, "'\uD800'"); + runTest(PARSER, "'\uDFFF'"); + runTest(PARSER, "r\"\\\uD800\""); + + runTest(PARSER, "as"); + runTest(PARSER, "break"); + runTest(PARSER, "const"); + runTest(PARSER, "continue"); + runTest(PARSER, "else"); + runTest(PARSER, "for"); + runTest(PARSER, "function"); + runTest(PARSER, "if"); + runTest(PARSER, "import"); + runTest(PARSER, "in"); + runTest(PARSER, "let"); + runTest(PARSER, "loop"); + runTest(PARSER, "package"); + runTest(PARSER, "namespace"); + runTest(PARSER, "return"); + runTest(PARSER, "var"); + runTest(PARSER, "void"); + runTest(PARSER, "while"); + runTest(PARSER, "[1, 2, 3].map(var, var * var)"); + runTest(PARSER, "'😁' in ['😁', 'πŸ˜‘', '😦']\n" + " && in.😁"); + runTest( + PARSER, + "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[" + + "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[" + + "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[" + + "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[['too many']]]]]]]]]]]]]]]]]]]]]]]]]]]]" + + "]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]" + + "]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]" + + "]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]" + + "]]]]]]"); + runTest(PARSER, "{\"a\": 1}.\"a\""); + runTest(PARSER, "1 + 2\n3 +"); + runTest(PARSER, "TestAllTypes(){single_int32: 1, single_int64: 2}"); + runTest(PARSER, "{"); + runTest(PARSER, "t{>C}"); + runTest(PARSER, "has([(has(("); + + CelParser parserWithoutOptionalSupport = + CelParserImpl.newBuilder() + .setOptions(CelOptions.current().enableOptionalSyntax(false).build()) + .build(); + runTest(parserWithoutOptionalSupport, "a.?b && a[?b]"); + runTest(parserWithoutOptionalSupport, "Msg{?field: value} && {?'key': value}"); + runTest(parserWithoutOptionalSupport, "[?a, ?b]"); + + CelParser parserWithQuotedFields = + CelParserImpl.newBuilder() + .setOptions(CelOptions.current().enableQuotedIdentifierSyntax(true).build()) + .build(); + runTest(parserWithQuotedFields, "`bar`"); + runTest(parserWithQuotedFields, "foo.``"); + runTest(parserWithQuotedFields, "foo.`$bar`"); + + CelParser parserWithoutQuotedFields = + CelParserImpl.newBuilder() + .setStandardMacros(CelStandardMacro.HAS) + .setOptions(CelOptions.current().enableQuotedIdentifierSyntax(false).build()) + .build(); + runTest(parserWithoutQuotedFields, "foo.`bar`"); + runTest(parserWithoutQuotedFields, "Struct{`bar`: false}"); + runTest(parserWithoutQuotedFields, "has(.`.`"); + } + + @Test + public void source_info() throws Exception { + runSourceInfoTest("[{}, {'field': true}].exists(i, has(i.field))"); + } + + private void runTest(CelParser parser, String expression) { + runTest(parser, expression, true); + } + + private void runTest(CelParser parser, String expression, boolean validateParseOutput) { + testOutput().println("I: " + expression); + testOutput().println("=====>"); + + CelSource source = CelSource.newBuilder(expression).setDescription("").build(); + CelValidationResult parseResult = parser.parse(source); + + try { + CelProtoAbstractSyntaxTree protoAst = + CelProtoAbstractSyntaxTree.fromCelAst(parseResult.getAst()); + ParsedExpr parsedExpr = protoAst.toParsedExpr(); + if (validateParseOutput) { + testOutput() + .println( + "P: " + + CelDebug.toAdornedDebugString(parsedExpr.getExpr(), new KindAndIdAdorner())); + String locationOutput = + CelDebug.toAdornedDebugString( + parsedExpr.getExpr(), new LocationAdorner(parsedExpr.getSourceInfo())); + if (!locationOutput.isEmpty()) { + testOutput().println("L: " + locationOutput); + } + } + + String macroOutput = convertMacroCallsToString(parsedExpr.getSourceInfo()); + if (!macroOutput.isEmpty()) { + testOutput().println("M: " + macroOutput); + } + } catch (CelValidationException e) { + testOutput().println("E: " + e.getMessage()); + } + + testOutput().println(); + } + + private void runSourceInfoTest(String expression) throws Exception { + CelAbstractSyntaxTree ast = PARSER.parse(expression).getAst(); + SourceInfo sourceInfo = + CelProtoAbstractSyntaxTree.fromCelAst(ast).toParsedExpr().getSourceInfo(); + testOutput().println("I: " + expression); + testOutput().println("=====>"); + testOutput().println("S: " + TextFormat.printer().printToString(sourceInfo)); + } + + private String convertMacroCallsToString(SourceInfo sourceInfo) { + KindAndIdAdorner macroCallsAdorner = new KindAndIdAdorner(sourceInfo); + // Sort in ascending order so that nested macro calls are always in the same order for tests + // output debug string. Ascending order keeps the macro calls map in order from outermost/first + // macro to the innermost/last macro for readability. + return sourceInfo.getMacroCallsMap().entrySet().stream() + .sorted(reverseOrder(comparingByKey())) + .map((entry) -> CelDebug.toAdornedDebugString(entry.getValue(), macroCallsAdorner)) + .collect(joining(",\n")); + } + + private static final class KindAndIdAdorner implements CelAdorner { + + private final SourceInfo sourceInfo; + + KindAndIdAdorner() { + this(SourceInfo.getDefaultInstance()); + } + + KindAndIdAdorner(SourceInfo sourceInfo) { + this.sourceInfo = sourceInfo; + } + + @Override + public String adorn(ExprOrBuilder expr) { + if (this.sourceInfo != null && this.sourceInfo.containsMacroCalls(expr.getId())) { + return String.format( + "^#%d:%s#", + expr.getId(), + this.sourceInfo.getMacroCallsOrThrow(expr.getId()).getCallExpr().getFunction()); + } + + if (expr.hasConstExpr()) { + Constant constExpr = expr.getConstExpr(); + Descriptor descriptor = Constant.getDescriptor(); + OneofDescriptor oneof = findOneofByName(descriptor, "constant_kind"); + FieldDescriptor field = constExpr.getOneofFieldDescriptor(oneof); + if (field.getType() == FieldDescriptor.Type.ENUM) { + return String.format("^#%d:%s#", expr.getId(), getContainedName(field.getEnumType())); + } else { + return String.format( + "^#%d:%s#", expr.getId(), Ascii.toLowerCase(field.getType().toString())); + } + } + Descriptor descriptor = Expr.getDescriptor(); + OneofDescriptor oneof = findOneofByName(descriptor, "expr_kind"); + FieldDescriptor field = expr.getOneofFieldDescriptor(oneof); + return String.format("^#%d:%s#", expr.getId(), getContainedName(field.getMessageType())); + } + + @Override + public String adorn(Expr.CreateStruct.EntryOrBuilder entry) { + return String.format("^#%d:Expr.CreateStruct.Entry#", entry.getId()); + } + } + + @AutoValue + @Immutable + abstract static class LineAndColumn { + + public abstract int getLine(); + + public abstract int getColumn(); + } + + private static final class LocationAdorner implements CelAdorner { + + private final SourceInfo sourceInfo; + + LocationAdorner(SourceInfo sourceInfo) { + this.sourceInfo = sourceInfo; + } + + @Override + public String adorn(ExprOrBuilder expr) { + return getLocation(expr.getId()) + .map( + location -> + String.format( + "^#%d[%d,%d]#", expr.getId(), location.getLine(), location.getColumn())) + .orElseGet(() -> String.format("^#%d[NO_POS]#", expr.getId())); + } + + @Override + public String adorn(Expr.CreateStruct.EntryOrBuilder entry) { + return getLocation(entry.getId()) + .map( + location -> + String.format( + "^#%d[%d,%d]#", entry.getId(), location.getLine(), location.getColumn())) + .orElseGet(() -> String.format("^#%d[NO_POS]#", entry.getId())); + } + + private Optional getLocation(long exprId) { + Map positions = sourceInfo.getPositionsMap(); + Integer position = positions.get(exprId); + if (position == null) { + return Optional.empty(); + } + int line = 1; + for (int index = 0; index < sourceInfo.getLineOffsetsCount(); index++) { + if (sourceInfo.getLineOffsets(index) > position) { + break; + } else { + line++; + } + } + int column = position; + if (line > 1) { + column = position - sourceInfo.getLineOffsets(line - 2); + } + return Optional.of(new AutoValue_CelParserParameterizedTest_LineAndColumn(line, column)); + } + } + + private static OneofDescriptor findOneofByName(Descriptor descriptor, String name) { + for (OneofDescriptor oneof : descriptor.getOneofs()) { + if (oneof.getName().equals(name)) { + return oneof; + } + } + return null; + } + + private static final Joiner JOINER = Joiner.on('.'); + + private static String getContainedName(Descriptor descriptor) { + Deque parts = new ArrayDeque<>(); + parts.addFirst(descriptor.getName()); + Descriptor containing = descriptor.getContainingType(); + while (containing != null) { + parts.addFirst(containing.getName()); + containing = containing.getContainingType(); + } + return JOINER.join(parts); + } + + private static String getContainedName(EnumDescriptor descriptor) { + Deque parts = new ArrayDeque<>(); + parts.addFirst(descriptor.getName()); + Descriptor containing = descriptor.getContainingType(); + while (containing != null) { + parts.addFirst(containing.getName()); + containing = containing.getContainingType(); + } + return JOINER.join(parts); + } +} diff --git a/parser/src/test/java/dev/cel/parser/CelStandardMacroTest.java b/parser/src/test/java/dev/cel/parser/CelStandardMacroTest.java new file mode 100644 index 000000000..7ab96180c --- /dev/null +++ b/parser/src/test/java/dev/cel/parser/CelStandardMacroTest.java @@ -0,0 +1,161 @@ +// Copyright 2022 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.parser; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.testing.EqualsTester; +import dev.cel.common.Operator; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelStandardMacroTest { + + @Test + public void getFunction() { + assertThat(CelStandardMacro.HAS.getFunction()).isEqualTo(Operator.HAS.getFunction()); + assertThat(CelStandardMacro.ALL.getFunction()).isEqualTo(Operator.ALL.getFunction()); + assertThat(CelStandardMacro.EXISTS.getFunction()).isEqualTo(Operator.EXISTS.getFunction()); + assertThat(CelStandardMacro.EXISTS_ONE.getFunction()) + .isEqualTo(Operator.EXISTS_ONE.getFunction()); + assertThat(CelStandardMacro.EXISTS_ONE_NEW.getFunction()) + .isEqualTo(Operator.EXISTS_ONE_NEW.getFunction()); + assertThat(CelStandardMacro.FILTER.getFunction()).isEqualTo(Operator.FILTER.getFunction()); + assertThat(CelStandardMacro.MAP.getFunction()).isEqualTo(Operator.MAP.getFunction()); + assertThat(CelStandardMacro.MAP_FILTER.getFunction()).isEqualTo(Operator.MAP.getFunction()); + } + + @Test + public void testHas() { + assertThat(CelStandardMacro.HAS.getFunction()).isEqualTo(Operator.HAS.getFunction()); + assertThat(CelStandardMacro.HAS.getDefinition().getArgumentCount()).isEqualTo(1); + assertThat(CelStandardMacro.HAS.getDefinition().isReceiverStyle()).isFalse(); + assertThat(CelStandardMacro.HAS.getDefinition().getKey()).isEqualTo("has:1:false"); + assertThat(CelStandardMacro.HAS.getDefinition().isVariadic()).isFalse(); + assertThat(CelStandardMacro.HAS.getDefinition().toString()) + .isEqualTo(CelStandardMacro.HAS.getDefinition().getKey()); + assertThat(CelStandardMacro.HAS.getDefinition().hashCode()) + .isEqualTo(CelStandardMacro.HAS.getDefinition().getKey().hashCode()); + } + + @Test + public void testAll() { + assertThat(CelStandardMacro.ALL.getFunction()).isEqualTo(Operator.ALL.getFunction()); + assertThat(CelStandardMacro.ALL.getDefinition().getArgumentCount()).isEqualTo(2); + assertThat(CelStandardMacro.ALL.getDefinition().isReceiverStyle()).isTrue(); + assertThat(CelStandardMacro.ALL.getDefinition().getKey()).isEqualTo("all:2:true"); + assertThat(CelStandardMacro.ALL.getDefinition().isVariadic()).isFalse(); + assertThat(CelStandardMacro.ALL.getDefinition().toString()) + .isEqualTo(CelStandardMacro.ALL.getDefinition().getKey()); + assertThat(CelStandardMacro.ALL.getDefinition().hashCode()) + .isEqualTo(CelStandardMacro.ALL.getDefinition().getKey().hashCode()); + } + + @Test + public void testExists() { + assertThat(CelStandardMacro.EXISTS.getFunction()).isEqualTo(Operator.EXISTS.getFunction()); + assertThat(CelStandardMacro.EXISTS.getDefinition().getArgumentCount()).isEqualTo(2); + assertThat(CelStandardMacro.EXISTS.getDefinition().isReceiverStyle()).isTrue(); + assertThat(CelStandardMacro.EXISTS.getDefinition().getKey()).isEqualTo("exists:2:true"); + assertThat(CelStandardMacro.EXISTS.getDefinition().isVariadic()).isFalse(); + assertThat(CelStandardMacro.EXISTS.getDefinition().toString()) + .isEqualTo(CelStandardMacro.EXISTS.getDefinition().getKey()); + assertThat(CelStandardMacro.EXISTS.getDefinition().hashCode()) + .isEqualTo(CelStandardMacro.EXISTS.getDefinition().getKey().hashCode()); + } + + @Test + public void testExistsOne() { + assertThat(CelStandardMacro.EXISTS_ONE.getFunction()) + .isEqualTo(Operator.EXISTS_ONE.getFunction()); + assertThat(CelStandardMacro.EXISTS_ONE.getDefinition().getArgumentCount()).isEqualTo(2); + assertThat(CelStandardMacro.EXISTS_ONE.getDefinition().isReceiverStyle()).isTrue(); + assertThat(CelStandardMacro.EXISTS_ONE.getDefinition().getKey()).isEqualTo("exists_one:2:true"); + assertThat(CelStandardMacro.EXISTS_ONE.getDefinition().isVariadic()).isFalse(); + assertThat(CelStandardMacro.EXISTS_ONE.getDefinition().toString()) + .isEqualTo(CelStandardMacro.EXISTS_ONE.getDefinition().getKey()); + assertThat(CelStandardMacro.EXISTS_ONE.getDefinition().hashCode()) + .isEqualTo(CelStandardMacro.EXISTS_ONE.getDefinition().getKey().hashCode()); + } + + @Test + public void testExistsOneNew() { + assertThat(CelStandardMacro.EXISTS_ONE_NEW.getFunction()) + .isEqualTo(Operator.EXISTS_ONE_NEW.getFunction()); + assertThat(CelStandardMacro.EXISTS_ONE_NEW.getDefinition().getArgumentCount()).isEqualTo(2); + assertThat(CelStandardMacro.EXISTS_ONE_NEW.getDefinition().isReceiverStyle()).isTrue(); + assertThat(CelStandardMacro.EXISTS_ONE_NEW.getDefinition().getKey()) + .isEqualTo("existsOne:2:true"); + assertThat(CelStandardMacro.EXISTS_ONE_NEW.getDefinition().isVariadic()).isFalse(); + assertThat(CelStandardMacro.EXISTS_ONE_NEW.getDefinition().toString()) + .isEqualTo(CelStandardMacro.EXISTS_ONE_NEW.getDefinition().getKey()); + assertThat(CelStandardMacro.EXISTS_ONE_NEW.getDefinition().hashCode()) + .isEqualTo(CelStandardMacro.EXISTS_ONE_NEW.getDefinition().getKey().hashCode()); + } + + @Test + public void testMap2() { + assertThat(CelStandardMacro.MAP.getFunction()).isEqualTo(Operator.MAP.getFunction()); + assertThat(CelStandardMacro.MAP.getDefinition().getArgumentCount()).isEqualTo(2); + assertThat(CelStandardMacro.MAP.getDefinition().isReceiverStyle()).isTrue(); + assertThat(CelStandardMacro.MAP.getDefinition().getKey()).isEqualTo("map:2:true"); + assertThat(CelStandardMacro.MAP.getDefinition().isVariadic()).isFalse(); + assertThat(CelStandardMacro.MAP.getDefinition().toString()) + .isEqualTo(CelStandardMacro.MAP.getDefinition().getKey()); + assertThat(CelStandardMacro.MAP.getDefinition().hashCode()) + .isEqualTo(CelStandardMacro.MAP.getDefinition().getKey().hashCode()); + } + + @Test + public void testMap3() { + assertThat(CelStandardMacro.MAP_FILTER.getFunction()).isEqualTo(Operator.MAP.getFunction()); + assertThat(CelStandardMacro.MAP_FILTER.getDefinition().getArgumentCount()).isEqualTo(3); + assertThat(CelStandardMacro.MAP_FILTER.getDefinition().isReceiverStyle()).isTrue(); + assertThat(CelStandardMacro.MAP_FILTER.getDefinition().getKey()).isEqualTo("map:3:true"); + assertThat(CelStandardMacro.MAP_FILTER.getDefinition().isVariadic()).isFalse(); + assertThat(CelStandardMacro.MAP_FILTER.getDefinition().toString()) + .isEqualTo(CelStandardMacro.MAP_FILTER.getDefinition().getKey()); + assertThat(CelStandardMacro.MAP_FILTER.getDefinition().hashCode()) + .isEqualTo(CelStandardMacro.MAP_FILTER.getDefinition().getKey().hashCode()); + } + + @Test + public void testFilter() { + assertThat(CelStandardMacro.FILTER.getFunction()).isEqualTo(Operator.FILTER.getFunction()); + assertThat(CelStandardMacro.FILTER.getDefinition().getArgumentCount()).isEqualTo(2); + assertThat(CelStandardMacro.FILTER.getDefinition().isReceiverStyle()).isTrue(); + assertThat(CelStandardMacro.FILTER.getDefinition().getKey()).isEqualTo("filter:2:true"); + assertThat(CelStandardMacro.FILTER.getDefinition().isVariadic()).isFalse(); + assertThat(CelStandardMacro.FILTER.getDefinition().toString()) + .isEqualTo(CelStandardMacro.FILTER.getDefinition().getKey()); + assertThat(CelStandardMacro.FILTER.getDefinition().hashCode()) + .isEqualTo(CelStandardMacro.FILTER.getDefinition().getKey().hashCode()); + } + + @Test + public void testEquals() { + new EqualsTester() + .addEqualityGroup(CelStandardMacro.HAS) + .addEqualityGroup(CelStandardMacro.ALL) + .addEqualityGroup(CelStandardMacro.EXISTS) + .addEqualityGroup(CelStandardMacro.EXISTS_ONE) + .addEqualityGroup(CelStandardMacro.MAP) + .addEqualityGroup(CelStandardMacro.MAP_FILTER) + .addEqualityGroup(CelStandardMacro.FILTER) + .testEquals(); + } +} diff --git a/parser/src/test/java/dev/cel/parser/CelUnparserImplTest.java b/parser/src/test/java/dev/cel/parser/CelUnparserImplTest.java new file mode 100644 index 000000000..6789b5621 --- /dev/null +++ b/parser/src/test/java/dev/cel/parser/CelUnparserImplTest.java @@ -0,0 +1,375 @@ +// Copyright 2023 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.parser; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.parser.CelUnparserVisitor.isOperatorLeftRecursive; +import static dev.cel.parser.CelUnparserVisitor.isOperatorLowerPrecedence; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; + +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameterValuesProvider; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.common.CelSource; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.extensions.CelOptionalLibrary; +import java.util.Arrays; +import java.util.List; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelUnparserImplTest { + + private final CelParser parser = + CelParserImpl.newBuilder() + .setOptions( + CelOptions.newBuilder() + .enableQuotedIdentifierSyntax(true) + .populateMacroCalls(true) + .build()) + .addLibraries(CelOptionalLibrary.INSTANCE) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + + private final CelUnparserImpl unparser = new CelUnparserImpl(); + + private static final class ValidExprDataProvider extends TestParameterValuesProvider { + @Override + public List provideValues(Context context) { + return Arrays.asList( + "a + b - c", + "a && b && c && d && e", + "a || b && (c || d) && e", + "a ? b : c", + "a[1][\"b\"]", + "x[\"a\"].single_int32 == 23", + "a * (b / c) % 0", + "a + b * c", + "(a + b) * c / (d - e)", + "a * b / c % 0", + "!true", + "-num", + "a || b || c || d || e", + "-(1 * 2)", + "-(1 + 2)", + "(x > 5) ? (x - 5) : 0", + "size(a ? (b ? c : d) : e)", + "a.hello(\"world\")", + "zero()", + "one(\"a\")", + "and(d, 32u)", + "max(a, b, 100)", + "x != \"a\"", + "[]", + "[1]", + "[\"hello, world\", \"goodbye, world\", \"sure, why not?\"]", + "-42.101", + "false", + "-405069", + "null", + "\"hello:\t'world'\"", + "true", + "42u", + "my_ident", + "has(hello.world)", + "{}", + "{\"a\": a.b.c, b\"\\142\": bytes(a.b.c)}", + "{a: a, b: a.b, c: a.b.c, a ? b : c: false, a || b: true}", + "v1alpha1.Expr{}", + "v1alpha1.Expr{id: 1, call_expr: v1alpha1.Call_Expr{function: \"name\"}}", + "a.b.c", + "a[b][c].name", + "(a + b).name", + "(a ? b : c).name", + "(a ? b : c)[0]", + "(a1 && a2) ? b : c", + "a ? (b1 || b2) : (c1 && c2)", + "(a ? b : c).method(d)", + "a + b + c + d", + "foo.`a.b`", + "foo.`a/b`", + "foo.`a-b`", + "foo.`a b`", + "foo.`in`", + "Foo{`a.b`: foo}", + "Foo{`a/b`: foo}", + "Foo{`a-b`: foo}", + "Foo{`a b`: foo}", + + // Constants + "true", + "4", + "4u", + + // Sequences + "[1, 2u]", + "{1: 2u, 2: 3u}", + + // Messages + "TestAllTypes{single_int32: 1, single_int64: 2}", + + // Conditionals + "false && !true || false", + "false && (!true || false)", + "(false && !true || false) ? 2 : 3", + "(x < 5) ? x : 5", + "(x > 5) ? (x - 5) : 0", + "(x > 5) ? ((x > 10) ? (x - 10) : 5) : 0", + "a in b", + + // Calculations + "(1 + 2) * 3", + "1 + 2 * 3", + "-(1 * 2)", + + // Comprehensions + "[1, 2, 3].all(x, x > 0)", + "[1, 2, 3].exists(x, x > 0)", + "[1, 2, 3].map(x, x >= 2, x * 4)", + "[1, 2, 3].exists_one(x, x >= 2)", + "[[1], [2], [3]].all(x, x.all(y, y >= 2))", + "(has(x.y) ? x.y : []).filter(z, z == \"zed\")", + "[[1], [2], [3]].map(x, x.filter(y, y > 1))", + "[1, 2, 3].map(x, x >= 2, x * 4).filter(x, x <= 10)", + "{a: has(b.c)}.exists(k, k != \"\")", + "{a: [1, 2].all(i > 0)}.exists(k, k != \"\")", + + // Macros + "has(x[\"a\"].single_int32)", + "has(x.`foo-bar`.single_int32)", + + // This is a filter expression but is decompiled back to + // map(x, filter_function, x) for which the evaluation is + // equal to filter(x, filter_function). + "[1, 2, 3].map(x, x >= 2, x)", + + // Index + "x[\"a\"].single_int32 == 23", + "a[1][\"b\"]", + + // Functions + "x != \"a\"", + "size(x) == x.size()", + + // Long string + "Loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong", + + // Optionals + "a.?b", + "a[?b]", + "[?a, ?b, c]", + "{?a: b, c: d}", + "v1alpha1.Expr{?id: id, call_expr: v1alpha1.Call_Expr{function: \"name\"}}"); + } + } + + @Test + public void unparse_succeeds( + @TestParameter(valuesProvider = ValidExprDataProvider.class) String originalExpr) + throws Exception { + CelAbstractSyntaxTree astOne = parser.parse(originalExpr, "unparser").getAst(); + + String unparsedResult = unparser.unparse(astOne); + + assertThat(originalExpr).isEqualTo(unparsedResult); + // parse again, confirm it's the same result + CelAbstractSyntaxTree astTwo = parser.parse(unparsedResult, "unparser").getAst(); + + assertThat(CelProtoAbstractSyntaxTree.fromCelAst(astTwo).toParsedExpr()) + .isEqualTo(CelProtoAbstractSyntaxTree.fromCelAst(astOne).toParsedExpr()); + } + + private static final class InvalidExprDataProvider extends TestParameterValuesProvider { + @Override + public List provideValues(Context context) { + return Arrays.asList( + CelExpr.newBuilder().build(), // empty expr + CelExpr.newBuilder() + .setCall( + CelCall.newBuilder() + .setFunction("_&&_") + .addArgs(CelExpr.newBuilder().build()) + .addArgs(CelExpr.newBuilder().build()) + .build()) + .build(), // bad args + CelExpr.newBuilder() + .setStruct( + CelStruct.newBuilder() + .setMessageName("Msg") + .addEntries( + CelStruct.Entry.newBuilder() + .setId(0) + .setValue(CelExpr.newBuilder().build()) + .setFieldKey("field") + .build()) + .build()) + .build(), // bad struct + CelExpr.newBuilder() + .setMap( + CelMap.newBuilder() + .addEntries( + CelMap.Entry.newBuilder() + .setId(0) + .setValue(CelExpr.newBuilder().build()) + .setKey(CelExpr.newBuilder().build()) + .build()) + .build()) + .build(), // bad map + CelExpr.newBuilder() + .setCall( + CelCall.newBuilder() + .setFunction("_[_]") + .addArgs(CelExpr.newBuilder().build()) + .build()) + .build() // bad index + ); + } + } + + @Test + public void unparse_fails( + @TestParameter(valuesProvider = InvalidExprDataProvider.class) CelExpr invalidExpr) { + Throwable thrown = + assertThrows( + Throwable.class, + () -> + unparser.unparse( + CelAbstractSyntaxTree.newParsedAst( + invalidExpr, CelSource.newBuilder().build()))); + + assertThat(thrown).hasMessageThat().contains("unexpected"); + } + + @Test + public void unparse_comprehensionWithoutMacroCallTracking_presenceTestSucceeds() + throws Exception { + CelParser parser = + CelParserImpl.newBuilder() + .setOptions(CelOptions.newBuilder().populateMacroCalls(false).build()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + CelAbstractSyntaxTree ast = parser.parse("has(hello.world)").getAst(); + + assertThat(unparser.unparse(ast)).isEqualTo("has(hello.world)"); + } + + @Test + public void unparse_comprehensionWithoutMacroCallTracking_throwsException() throws Exception { + CelParser parser = + CelParserImpl.newBuilder() + .setOptions(CelOptions.newBuilder().populateMacroCalls(false).build()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + CelAbstractSyntaxTree ast = parser.parse("[1, 2, 3].all(x, x > 0)").getAst(); + + UnsupportedOperationException e = + assertThrows(UnsupportedOperationException.class, () -> unparser.unparse(ast)); + assertThat(e) + .hasMessageThat() + .contains( + "Comprehension unparsing requires macro calls to be populated. Ensure the option is" + + " enabled."); + } + + @Test + public void unparse_macroWithReceiverStyleArg() throws Exception { + CelParser parser = + CelParserImpl.newBuilder() + .setOptions(CelOptions.newBuilder().populateMacroCalls(true).build()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + CelAbstractSyntaxTree ast = + parser.parse("[\"a\"].all(x, x.trim().lowerAscii().contains(\"b\"))").getAst(); + + assertThat(unparser.unparse(ast)) + .isEqualTo("[\"a\"].all(x, x.trim().lowerAscii().contains(\"b\"))"); + } + + @Test + @TestParameters({ + "{operator: '_[_]'}", + "{operator: '!_'}", + "{operator: '_==_'}", + "{operator: '_?_:_'}", + "{operator: '_!=_'}", + "{operator: '_<_'}", + "{operator: '_<=_'}", + "{operator: '_>_'}", + "{operator: '_>=_'}", + "{operator: '_+_'}", + "{operator: '_-_'}", + "{operator: '_*_'}", + "{operator: '_/_'}", + "{operator: '_%_'}", + "{operator: '-_'}", + "{operator: 'has'}", + "{operator: '_[?_]'}", + "{operator: '@not_strictly_false'}", + }) + public void operatorLeftRecursive(String operator) { + assertTrue(isOperatorLeftRecursive(operator)); + } + + @Test + @TestParameters({ + "{operator: '_&&_'}", + "{operator: '_||_'}", + }) + public void operatorNotLeftRecursive(String operator) { + assertFalse(isOperatorLeftRecursive(operator)); + } + + @Test + @TestParameters({ + "{operator1: '_[_]', operator2: '_&&_'}", + "{operator1: '_&&_', operator2: '_||_'}", + "{operator1: '_||_', operator2: '_?_:_'}", + "{operator1: '!_', operator2: '_*_'}", + "{operator1: '_==_', operator2: '_&&_'}", + "{operator1: '_!=_', operator2: '_?_:_'}", + }) + public void operatorLowerPrecedence(String operator1, String operator2) { + CelExpr expr = + CelExpr.newBuilder().setCall(CelCall.newBuilder().setFunction(operator2).build()).build(); + + assertTrue(isOperatorLowerPrecedence(operator1, expr)); + } + + @Test + @TestParameters({ + "{operator1: '_?_:_', operator2: '_&&_'}", + "{operator1: '_&&_', operator2: '_[_]'}", + "{operator1: '_||_', operator2: '!_'}", + "{operator1: '!_', operator2: '-_'}", + "{operator1: '_==_', operator2: '_!=_'}", + "{operator1: '_!=_', operator2: '_-_'}", + }) + public void operatorNotLowerPrecedence(String operator1, String operator2) { + CelExpr expr = + CelExpr.newBuilder().setCall(CelCall.newBuilder().setFunction(operator2).build()).build(); + + assertFalse(isOperatorLowerPrecedence(operator1, expr)); + } +} diff --git a/parser/src/test/resources/BUILD.bazel b/parser/src/test/resources/BUILD.bazel new file mode 100644 index 000000000..21444c84c --- /dev/null +++ b/parser/src/test/resources/BUILD.bazel @@ -0,0 +1,15 @@ +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//parser:__subpackages__", + ], +) + +filegroup( + name = "baselines", + testonly = True, + srcs = glob(["*.baseline"]), +) diff --git a/parser/src/test/resources/parser.baseline b/parser/src/test/resources/parser.baseline new file mode 100644 index 000000000..37b8ef3cc --- /dev/null +++ b/parser/src/test/resources/parser.baseline @@ -0,0 +1,1726 @@ +I: x * 2 +=====> +P: _*_( + x^#1:Expr.Ident#, + 2^#3:int64# +)^#2:Expr.Call# +L: _*_( + x^#1[1,0]#, + 2^#3[1,4]# +)^#2[1,2]# + +I: x * 2u +=====> +P: _*_( + x^#1:Expr.Ident#, + 2u^#3:uint64# +)^#2:Expr.Call# +L: _*_( + x^#1[1,0]#, + 2u^#3[1,4]# +)^#2[1,2]# + +I: x * 2.0 +=====> +P: _*_( + x^#1:Expr.Ident#, + 2.0^#3:double# +)^#2:Expr.Call# +L: _*_( + x^#1[1,0]#, + 2.0^#3[1,4]# +)^#2[1,2]# + +I: "\u2764" +=====> +P: "❀"^#1:string# +L: "❀"^#1[1,0]# + +I: "❀" +=====> +P: "❀"^#1:string# +L: "❀"^#1[1,0]# + +I: ! false +=====> +P: !_( + false^#2:bool# +)^#1:Expr.Call# +L: !_( + false^#2[1,2]# +)^#1[1,0]# + +I: -a +=====> +P: -_( + a^#2:Expr.Ident# +)^#1:Expr.Call# +L: -_( + a^#2[1,1]# +)^#1[1,0]# + +I: a.b(5) +=====> +P: a^#1:Expr.Ident#.b( + 5^#3:int64# +)^#2:Expr.Call# +L: a^#1[1,0]#.b( + 5^#3[1,4]# +)^#2[1,3]# + +I: a[3] +=====> +P: _[_]( + a^#1:Expr.Ident#, + 3^#3:int64# +)^#2:Expr.Call# +L: _[_]( + a^#1[1,0]#, + 3^#3[1,2]# +)^#2[1,1]# + +I: SomeMessage{foo: 5, bar: "xyz"} +=====> +P: SomeMessage{ + foo:5^#3:int64#^#2:Expr.CreateStruct.Entry#, + bar:"xyz"^#5:string#^#4:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: SomeMessage{ + foo:5^#3[1,17]#^#2[1,15]#, + bar:"xyz"^#5[1,25]#^#4[1,23]# +}^#1[1,11]# + +I: [3, 4, 5] +=====> +P: [ + 3^#2:int64#, + 4^#3:int64#, + 5^#4:int64# +]^#1:Expr.CreateList# +L: [ + 3^#2[1,1]#, + 4^#3[1,4]#, + 5^#4[1,7]# +]^#1[1,0]# + +I: {foo: 5, bar: "xyz"} +=====> +P: { + foo^#3:Expr.Ident#:5^#4:int64#^#2:Expr.CreateStruct.Entry#, + bar^#6:Expr.Ident#:"xyz"^#7:string#^#5:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: { + foo^#3[1,1]#:5^#4[1,6]#^#2[1,4]#, + bar^#6[1,9]#:"xyz"^#7[1,14]#^#5[1,12]# +}^#1[1,0]# + +I: a > 5 && a < 10 +=====> +P: _&&_( + _>_( + a^#1:Expr.Ident#, + 5^#3:int64# + )^#2:Expr.Call#, + _<_( + a^#5:Expr.Ident#, + 10^#7:int64# + )^#6:Expr.Call# +)^#4:Expr.Call# +L: _&&_( + _>_( + a^#1[1,0]#, + 5^#3[1,4]# + )^#2[1,2]#, + _<_( + a^#5[1,9]#, + 10^#7[1,13]# + )^#6[1,11]# +)^#4[1,6]# + +I: a < 5 || a > 10 +=====> +P: _||_( + _<_( + a^#1:Expr.Ident#, + 5^#3:int64# + )^#2:Expr.Call#, + _>_( + a^#5:Expr.Ident#, + 10^#7:int64# + )^#6:Expr.Call# +)^#4:Expr.Call# +L: _||_( + _<_( + a^#1[1,0]#, + 5^#3[1,4]# + )^#2[1,2]#, + _>_( + a^#5[1,9]#, + 10^#7[1,13]# + )^#6[1,11]# +)^#4[1,6]# + +I: "abc" + "def" +=====> +P: _+_( + "abc"^#1:string#, + "def"^#3:string# +)^#2:Expr.Call# +L: _+_( + "abc"^#1[1,0]#, + "def"^#3[1,8]# +)^#2[1,6]# + +I: "A" +=====> +P: "A"^#1:string# +L: "A"^#1[1,0]# + +I: true +=====> +P: true^#1:bool# +L: true^#1[1,0]# + +I: false +=====> +P: false^#1:bool# +L: false^#1[1,0]# + +I: 0 +=====> +P: 0^#1:int64# +L: 0^#1[1,0]# + +I: 42 +=====> +P: 42^#1:int64# +L: 42^#1[1,0]# + +I: 0u +=====> +P: 0u^#1:uint64# +L: 0u^#1[1,0]# + +I: 23u +=====> +P: 23u^#1:uint64# +L: 23u^#1[1,0]# + +I: 24u +=====> +P: 24u^#1:uint64# +L: 24u^#1[1,0]# + +I: 0xAu +=====> +P: 10u^#1:uint64# +L: 10u^#1[1,0]# + +I: -0xA +=====> +P: -10^#1:int64# +L: -10^#1[1,1]# + +I: 0xA +=====> +P: 10^#1:int64# +L: 10^#1[1,0]# + +I: -1 +=====> +P: -1^#1:int64# +L: -1^#1[1,1]# + +I: 4--4 +=====> +P: _-_( + 4^#1:int64#, + -4^#3:int64# +)^#2:Expr.Call# +L: _-_( + 4^#1[1,0]#, + -4^#3[1,3]# +)^#2[1,1]# + +I: 4--4.1 +=====> +P: _-_( + 4^#1:int64#, + -4.1^#3:double# +)^#2:Expr.Call# +L: _-_( + 4^#1[1,0]#, + -4.1^#3[1,3]# +)^#2[1,1]# + +I: b"abc" +=====> +P: b"abc"^#1:bytes# +L: b"abc"^#1[1,0]# + +I: 23.39 +=====> +P: 23.39^#1:double# +L: 23.39^#1[1,0]# + +I: !a +=====> +P: !_( + a^#2:Expr.Ident# +)^#1:Expr.Call# +L: !_( + a^#2[1,1]# +)^#1[1,0]# + +I: null +=====> +P: null^#1:NullValue# +L: null^#1[1,0]# + +I: a +=====> +P: a^#1:Expr.Ident# +L: a^#1[1,0]# + +I: a?b:c +=====> +P: _?_:_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident#, + c^#4:Expr.Ident# +)^#2:Expr.Call# +L: _?_:_( + a^#1[1,0]#, + b^#3[1,2]#, + c^#4[1,4]# +)^#2[1,1]# + +I: a || b +=====> +P: _||_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _||_( + a^#1[1,0]#, + b^#3[1,5]# +)^#2[1,2]# + +I: a || b || c || d || e || f +=====> +P: _||_( + _||_( + _||_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# + )^#2:Expr.Call#, + c^#5:Expr.Ident# + )^#4:Expr.Call#, + _||_( + _||_( + d^#7:Expr.Ident#, + e^#9:Expr.Ident# + )^#8:Expr.Call#, + f^#11:Expr.Ident# + )^#10:Expr.Call# +)^#6:Expr.Call# +L: _||_( + _||_( + _||_( + a^#1[1,0]#, + b^#3[1,5]# + )^#2[1,2]#, + c^#5[1,10]# + )^#4[1,7]#, + _||_( + _||_( + d^#7[1,15]#, + e^#9[1,20]# + )^#8[1,17]#, + f^#11[1,25]# + )^#10[1,22]# +)^#6[1,12]# + +I: a && b +=====> +P: _&&_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _&&_( + a^#1[1,0]#, + b^#3[1,5]# +)^#2[1,2]# + +I: a && b && c && d && e && f && g +=====> +P: _&&_( + _&&_( + _&&_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# + )^#2:Expr.Call#, + _&&_( + c^#5:Expr.Ident#, + d^#7:Expr.Ident# + )^#6:Expr.Call# + )^#4:Expr.Call#, + _&&_( + _&&_( + e^#9:Expr.Ident#, + f^#11:Expr.Ident# + )^#10:Expr.Call#, + g^#13:Expr.Ident# + )^#12:Expr.Call# +)^#8:Expr.Call# +L: _&&_( + _&&_( + _&&_( + a^#1[1,0]#, + b^#3[1,5]# + )^#2[1,2]#, + _&&_( + c^#5[1,10]#, + d^#7[1,15]# + )^#6[1,12]# + )^#4[1,7]#, + _&&_( + _&&_( + e^#9[1,20]#, + f^#11[1,25]# + )^#10[1,22]#, + g^#13[1,30]# + )^#12[1,27]# +)^#8[1,17]# + +I: a && b && c && d || e && f && g && h +=====> +P: _||_( + _&&_( + _&&_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# + )^#2:Expr.Call#, + _&&_( + c^#5:Expr.Ident#, + d^#7:Expr.Ident# + )^#6:Expr.Call# + )^#4:Expr.Call#, + _&&_( + _&&_( + e^#9:Expr.Ident#, + f^#11:Expr.Ident# + )^#10:Expr.Call#, + _&&_( + g^#13:Expr.Ident#, + h^#15:Expr.Ident# + )^#14:Expr.Call# + )^#12:Expr.Call# +)^#8:Expr.Call# +L: _||_( + _&&_( + _&&_( + a^#1[1,0]#, + b^#3[1,5]# + )^#2[1,2]#, + _&&_( + c^#5[1,10]#, + d^#7[1,15]# + )^#6[1,12]# + )^#4[1,7]#, + _&&_( + _&&_( + e^#9[1,20]#, + f^#11[1,25]# + )^#10[1,22]#, + _&&_( + g^#13[1,30]#, + h^#15[1,35]# + )^#14[1,32]# + )^#12[1,27]# +)^#8[1,17]# + +I: a + b +=====> +P: _+_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _+_( + a^#1[1,0]#, + b^#3[1,4]# +)^#2[1,2]# + +I: a - b +=====> +P: _-_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _-_( + a^#1[1,0]#, + b^#3[1,4]# +)^#2[1,2]# + +I: a * b +=====> +P: _*_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _*_( + a^#1[1,0]#, + b^#3[1,4]# +)^#2[1,2]# + +I: a / b +=====> +P: _/_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _/_( + a^#1[1,0]#, + b^#3[1,4]# +)^#2[1,2]# + +I: a % b +=====> +P: _%_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _%_( + a^#1[1,0]#, + b^#3[1,4]# +)^#2[1,2]# + +I: a in b +=====> +P: @in( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: @in( + a^#1[1,0]#, + b^#3[1,5]# +)^#2[1,2]# + +I: a == b +=====> +P: _==_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _==_( + a^#1[1,0]#, + b^#3[1,5]# +)^#2[1,2]# + +I: a != b +=====> +P: _!=_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _!=_( + a^#1[1,0]#, + b^#3[1,5]# +)^#2[1,2]# + +I: a > b +=====> +P: _>_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _>_( + a^#1[1,0]#, + b^#3[1,4]# +)^#2[1,2]# + +I: a >= b +=====> +P: _>=_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _>=_( + a^#1[1,0]#, + b^#3[1,5]# +)^#2[1,2]# + +I: a < b +=====> +P: _<_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _<_( + a^#1[1,0]#, + b^#3[1,4]# +)^#2[1,2]# + +I: a <= b +=====> +P: _<=_( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _<=_( + a^#1[1,0]#, + b^#3[1,5]# +)^#2[1,2]# + +I: a.b +=====> +P: a^#1:Expr.Ident#.b^#2:Expr.Select# +L: a^#1[1,0]#.b^#2[1,1]# + +I: a.b.c +=====> +P: a^#1:Expr.Ident#.b^#2:Expr.Select#.c^#3:Expr.Select# +L: a^#1[1,0]#.b^#2[1,1]#.c^#3[1,3]# + +I: a[b] +=====> +P: _[_]( + a^#1:Expr.Ident#, + b^#3:Expr.Ident# +)^#2:Expr.Call# +L: _[_]( + a^#1[1,0]#, + b^#3[1,2]# +)^#2[1,1]# + +I: foo{ } +=====> +P: foo{}^#1:Expr.CreateStruct# +L: foo{}^#1[1,3]# + +I: foo{ a:b } +=====> +P: foo{ + a:b^#3:Expr.Ident#^#2:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: foo{ + a:b^#3[1,7]#^#2[1,6]# +}^#1[1,3]# + +I: foo{ a:b, c:d } +=====> +P: foo{ + a:b^#3:Expr.Ident#^#2:Expr.CreateStruct.Entry#, + c:d^#5:Expr.Ident#^#4:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: foo{ + a:b^#3[1,7]#^#2[1,6]#, + c:d^#5[1,12]#^#4[1,11]# +}^#1[1,3]# + +I: {} +=====> +P: {}^#1:Expr.CreateStruct# +L: {}^#1[1,0]# + +I: {a:b, c:d} +=====> +P: { + a^#3:Expr.Ident#:b^#4:Expr.Ident#^#2:Expr.CreateStruct.Entry#, + c^#6:Expr.Ident#:d^#7:Expr.Ident#^#5:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: { + a^#3[1,1]#:b^#4[1,3]#^#2[1,2]#, + c^#6[1,6]#:d^#7[1,8]#^#5[1,7]# +}^#1[1,0]# + +I: [] +=====> +P: []^#1:Expr.CreateList# +L: []^#1[1,0]# + +I: [a] +=====> +P: [ + a^#2:Expr.Ident# +]^#1:Expr.CreateList# +L: [ + a^#2[1,1]# +]^#1[1,0]# + +I: [a, b, c] +=====> +P: [ + a^#2:Expr.Ident#, + b^#3:Expr.Ident#, + c^#4:Expr.Ident# +]^#1:Expr.CreateList# +L: [ + a^#2[1,1]#, + b^#3[1,4]#, + c^#4[1,7]# +]^#1[1,0]# + +I: (a) +=====> +P: a^#1:Expr.Ident# +L: a^#1[1,1]# + +I: ((a)) +=====> +P: a^#1:Expr.Ident# +L: a^#1[1,2]# + +I: a() +=====> +P: a()^#1:Expr.Call# +L: a()^#1[1,1]# + +I: a(b) +=====> +P: a( + b^#2:Expr.Ident# +)^#1:Expr.Call# +L: a( + b^#2[1,2]# +)^#1[1,1]# + +I: a(b, c) +=====> +P: a( + b^#2:Expr.Ident#, + c^#3:Expr.Ident# +)^#1:Expr.Call# +L: a( + b^#2[1,2]#, + c^#3[1,5]# +)^#1[1,1]# + +I: a.b() +=====> +P: a^#1:Expr.Ident#.b()^#2:Expr.Call# +L: a^#1[1,0]#.b()^#2[1,3]# + +I: a.b(c) +=====> +P: a^#1:Expr.Ident#.b( + c^#3:Expr.Ident# +)^#2:Expr.Call# +L: a^#1[1,0]#.b( + c^#3[1,4]# +)^#2[1,3]# + +I: aaa.bbb(ccc) +=====> +P: aaa^#1:Expr.Ident#.bbb( + ccc^#3:Expr.Ident# +)^#2:Expr.Call# +L: aaa^#1[1,0]#.bbb( + ccc^#3[1,8]# +)^#2[1,7]# + +I: has(m.f) +=====> +P: m^#2:Expr.Ident#.f~test-only~^#4:Expr.Select# +L: m^#2[1,4]#.f~test-only~^#4[1,3]# +M: has( + m^#2:Expr.Ident#.f^#3:Expr.Select# +)^#0:Expr.Call# + +I: m.exists_one(v, f) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + @result, + // Init + 0^#5:int64#, + // LoopCondition + true^#6:bool#, + // LoopStep + _?_:_( + f^#4:Expr.Ident#, + _+_( + @result^#7:Expr.Ident#, + 1^#8:int64# + )^#9:Expr.Call#, + @result^#10:Expr.Ident# + )^#11:Expr.Call#, + // Result + _==_( + @result^#12:Expr.Ident#, + 1^#13:int64# + )^#14:Expr.Call#)^#15:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + @result, + // Init + 0^#5[1,12]#, + // LoopCondition + true^#6[1,12]#, + // LoopStep + _?_:_( + f^#4[1,16]#, + _+_( + @result^#7[1,12]#, + 1^#8[1,12]# + )^#9[1,12]#, + @result^#10[1,12]# + )^#11[1,12]#, + // Result + _==_( + @result^#12[1,12]#, + 1^#13[1,12]# + )^#14[1,12]#)^#15[1,12]# +M: m^#1:Expr.Ident#.exists_one( + v^#3:Expr.Ident#, + f^#4:Expr.Ident# +)^#0:Expr.Call# + +I: m.existsOne(v, f) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + @result, + // Init + 0^#5:int64#, + // LoopCondition + true^#6:bool#, + // LoopStep + _?_:_( + f^#4:Expr.Ident#, + _+_( + @result^#7:Expr.Ident#, + 1^#8:int64# + )^#9:Expr.Call#, + @result^#10:Expr.Ident# + )^#11:Expr.Call#, + // Result + _==_( + @result^#12:Expr.Ident#, + 1^#13:int64# + )^#14:Expr.Call#)^#15:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + @result, + // Init + 0^#5[1,11]#, + // LoopCondition + true^#6[1,11]#, + // LoopStep + _?_:_( + f^#4[1,15]#, + _+_( + @result^#7[1,11]#, + 1^#8[1,11]# + )^#9[1,11]#, + @result^#10[1,11]# + )^#11[1,11]#, + // Result + _==_( + @result^#12[1,11]#, + 1^#13[1,11]# + )^#14[1,11]#)^#15[1,11]# +M: m^#1:Expr.Ident#.existsOne( + v^#3:Expr.Ident#, + f^#4:Expr.Ident# +)^#0:Expr.Call# + +I: m.map(v, f) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + @result, + // Init + []^#5:Expr.CreateList#, + // LoopCondition + true^#6:bool#, + // LoopStep + _+_( + @result^#7:Expr.Ident#, + [ + f^#4:Expr.Ident# + ]^#8:Expr.CreateList# + )^#9:Expr.Call#, + // Result + @result^#10:Expr.Ident#)^#11:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + @result, + // Init + []^#5[1,5]#, + // LoopCondition + true^#6[1,5]#, + // LoopStep + _+_( + @result^#7[1,5]#, + [ + f^#4[1,9]# + ]^#8[1,5]# + )^#9[1,5]#, + // Result + @result^#10[1,5]#)^#11[1,5]# +M: m^#1:Expr.Ident#.map( + v^#3:Expr.Ident#, + f^#4:Expr.Ident# +)^#0:Expr.Call# + +I: m.map(v, p, f) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + @result, + // Init + []^#6:Expr.CreateList#, + // LoopCondition + true^#7:bool#, + // LoopStep + _?_:_( + p^#4:Expr.Ident#, + _+_( + @result^#8:Expr.Ident#, + [ + f^#5:Expr.Ident# + ]^#9:Expr.CreateList# + )^#10:Expr.Call#, + @result^#11:Expr.Ident# + )^#12:Expr.Call#, + // Result + @result^#13:Expr.Ident#)^#14:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + @result, + // Init + []^#6[1,5]#, + // LoopCondition + true^#7[1,5]#, + // LoopStep + _?_:_( + p^#4[1,9]#, + _+_( + @result^#8[1,5]#, + [ + f^#5[1,12]# + ]^#9[1,5]# + )^#10[1,5]#, + @result^#11[1,5]# + )^#12[1,5]#, + // Result + @result^#13[1,5]#)^#14[1,5]# +M: m^#1:Expr.Ident#.map( + v^#3:Expr.Ident#, + p^#4:Expr.Ident#, + f^#5:Expr.Ident# +)^#0:Expr.Call# + +I: m.filter(v, p) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + @result, + // Init + []^#5:Expr.CreateList#, + // LoopCondition + true^#6:bool#, + // LoopStep + _?_:_( + p^#4:Expr.Ident#, + _+_( + @result^#7:Expr.Ident#, + [ + v^#3:Expr.Ident# + ]^#8:Expr.CreateList# + )^#9:Expr.Call#, + @result^#10:Expr.Ident# + )^#11:Expr.Call#, + // Result + @result^#12:Expr.Ident#)^#13:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + @result, + // Init + []^#5[1,8]#, + // LoopCondition + true^#6[1,8]#, + // LoopStep + _?_:_( + p^#4[1,12]#, + _+_( + @result^#7[1,8]#, + [ + v^#3[1,9]# + ]^#8[1,8]# + )^#9[1,8]#, + @result^#10[1,8]# + )^#11[1,8]#, + // Result + @result^#12[1,8]#)^#13[1,8]# +M: m^#1:Expr.Ident#.filter( + v^#3:Expr.Ident#, + p^#4:Expr.Ident# +)^#0:Expr.Call# + +I: [] + [1,2,3,] + [4] +=====> +P: _+_( + _+_( + []^#1:Expr.CreateList#, + [ + 1^#4:int64#, + 2^#5:int64#, + 3^#6:int64# + ]^#3:Expr.CreateList# + )^#2:Expr.Call#, + [ + 4^#9:int64# + ]^#8:Expr.CreateList# +)^#7:Expr.Call# +L: _+_( + _+_( + []^#1[1,0]#, + [ + 1^#4[1,6]#, + 2^#5[1,8]#, + 3^#6[1,10]# + ]^#3[1,5]# + )^#2[1,3]#, + [ + 4^#9[1,17]# + ]^#8[1,16]# +)^#7[1,14]# + +I: {1:2u, 2:3u} +=====> +P: { + 1^#3:int64#:2u^#4:uint64#^#2:Expr.CreateStruct.Entry#, + 2^#6:int64#:3u^#7:uint64#^#5:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: { + 1^#3[1,1]#:2u^#4[1,3]#^#2[1,2]#, + 2^#6[1,7]#:3u^#7[1,9]#^#5[1,8]# +}^#1[1,0]# + +I: TestAllTypes{single_int32: 1, single_int64: 2} +=====> +P: TestAllTypes{ + single_int32:1^#3:int64#^#2:Expr.CreateStruct.Entry#, + single_int64:2^#5:int64#^#4:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: TestAllTypes{ + single_int32:1^#3[1,27]#^#2[1,25]#, + single_int64:2^#5[1,44]#^#4[1,42]# +}^#1[1,12]# + +I: size(x) == x.size() +=====> +P: _==_( + size( + x^#2:Expr.Ident# + )^#1:Expr.Call#, + x^#4:Expr.Ident#.size()^#5:Expr.Call# +)^#3:Expr.Call# +L: _==_( + size( + x^#2[1,5]# + )^#1[1,4]#, + x^#4[1,11]#.size()^#5[1,17]# +)^#3[1,8]# + +I: "\"" +=====> +P: "\""^#1:string# +L: "\""^#1[1,0]# + +I: [1,3,4][0] +=====> +P: _[_]( + [ + 1^#2:int64#, + 3^#3:int64#, + 4^#4:int64# + ]^#1:Expr.CreateList#, + 0^#6:int64# +)^#5:Expr.Call# +L: _[_]( + [ + 1^#2[1,1]#, + 3^#3[1,3]#, + 4^#4[1,5]# + ]^#1[1,0]#, + 0^#6[1,8]# +)^#5[1,7]# + +I: x["a"].single_int32 == 23 +=====> +P: _==_( + _[_]( + x^#1:Expr.Ident#, + "a"^#3:string# + )^#2:Expr.Call#.single_int32^#4:Expr.Select#, + 23^#6:int64# +)^#5:Expr.Call# +L: _==_( + _[_]( + x^#1[1,0]#, + "a"^#3[1,2]# + )^#2[1,1]#.single_int32^#4[1,6]#, + 23^#6[1,23]# +)^#5[1,20]# + +I: x.single_nested_message != null +=====> +P: _!=_( + x^#1:Expr.Ident#.single_nested_message^#2:Expr.Select#, + null^#4:NullValue# +)^#3:Expr.Call# +L: _!=_( + x^#1[1,0]#.single_nested_message^#2[1,1]#, + null^#4[1,27]# +)^#3[1,24]# + +I: false && !true || false ? 2 : 3 +=====> +P: _?_:_( + _||_( + _&&_( + false^#1:bool#, + !_( + true^#4:bool# + )^#3:Expr.Call# + )^#2:Expr.Call#, + false^#6:bool# + )^#5:Expr.Call#, + 2^#8:int64#, + 3^#9:int64# +)^#7:Expr.Call# +L: _?_:_( + _||_( + _&&_( + false^#1[1,0]#, + !_( + true^#4[1,10]# + )^#3[1,9]# + )^#2[1,6]#, + false^#6[1,18]# + )^#5[1,15]#, + 2^#8[1,26]#, + 3^#9[1,30]# +)^#7[1,24]# + +I: b"abc" + B"def" +=====> +P: _+_( + b"abc"^#1:bytes#, + b"def"^#3:bytes# +)^#2:Expr.Call# +L: _+_( + b"abc"^#1[1,0]#, + b"def"^#3[1,9]# +)^#2[1,7]# + +I: 1 + 2 * 3 - 1 / 2 == 6 % 1 +=====> +P: _==_( + _-_( + _+_( + 1^#1:int64#, + _*_( + 2^#3:int64#, + 3^#5:int64# + )^#4:Expr.Call# + )^#2:Expr.Call#, + _/_( + 1^#7:int64#, + 2^#9:int64# + )^#8:Expr.Call# + )^#6:Expr.Call#, + _%_( + 6^#11:int64#, + 1^#13:int64# + )^#12:Expr.Call# +)^#10:Expr.Call# +L: _==_( + _-_( + _+_( + 1^#1[1,0]#, + _*_( + 2^#3[1,4]#, + 3^#5[1,8]# + )^#4[1,6]# + )^#2[1,2]#, + _/_( + 1^#7[1,12]#, + 2^#9[1,16]# + )^#8[1,14]# + )^#6[1,10]#, + _%_( + 6^#11[1,21]#, + 1^#13[1,25]# + )^#12[1,23]# +)^#10[1,18]# + +I: ---a +=====> +P: -_( + a^#2:Expr.Ident# +)^#1:Expr.Call# +L: -_( + a^#2[1,3]# +)^#1[1,0]# + +I: "\xC3\XBF" +=====> +P: "ÿ"^#1:string# +L: "ÿ"^#1[1,0]# + +I: "\303\277" +=====> +P: "ÿ"^#1:string# +L: "ÿ"^#1[1,0]# + +I: "hi\u263A \u263Athere" +=====> +P: "hi☺ ☺there"^#1:string# +L: "hi☺ ☺there"^#1[1,0]# + +I: "\U000003A8\?" +=====> +P: "Ξ¨?"^#1:string# +L: "Ξ¨?"^#1[1,0]# + +I: "\a\b\f\n\r\t\v'\"\\\? Legal escapes" +=====> +P: "\a\b\f\n\r\t\v'\"\? Legal escapes"^#1:string# +L: "\a\b\f\n\r\t\v'\"\? Legal escapes"^#1[1,0]# + +I: '😁' in ['😁', 'πŸ˜‘', '😦'] +=====> +P: @in( + "😁"^#1:string#, + [ + "😁"^#4:string#, + "πŸ˜‘"^#5:string#, + "😦"^#6:string# + ]^#3:Expr.CreateList# +)^#2:Expr.Call# +L: @in( + "😁"^#1[1,0]#, + [ + "😁"^#4[1,8]#, + "πŸ˜‘"^#5[1,13]#, + "😦"^#6[1,18]# + ]^#3[1,7]# +)^#2[1,4]# + +I: [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[['just fine'],[1],[2],[3],[4],[5]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] +=====> + +I: x.filter(y, y.filter(z, z > 0)) +=====> +P: __comprehension__( + // Variable + y, + // Target + x^#1:Expr.Ident#, + // Accumulator + @result, + // Init + []^#19:Expr.CreateList#, + // LoopCondition + true^#20:bool#, + // LoopStep + _?_:_( + __comprehension__( + // Variable + z, + // Target + y^#4:Expr.Ident#, + // Accumulator + @result, + // Init + []^#10:Expr.CreateList#, + // LoopCondition + true^#11:bool#, + // LoopStep + _?_:_( + _>_( + z^#7:Expr.Ident#, + 0^#9:int64# + )^#8:Expr.Call#, + _+_( + @result^#12:Expr.Ident#, + [ + z^#6:Expr.Ident# + ]^#13:Expr.CreateList# + )^#14:Expr.Call#, + @result^#15:Expr.Ident# + )^#16:Expr.Call#, + // Result + @result^#17:Expr.Ident#)^#18:Expr.Comprehension#, + _+_( + @result^#21:Expr.Ident#, + [ + y^#3:Expr.Ident# + ]^#22:Expr.CreateList# + )^#23:Expr.Call#, + @result^#24:Expr.Ident# + )^#25:Expr.Call#, + // Result + @result^#26:Expr.Ident#)^#27:Expr.Comprehension# +L: __comprehension__( + // Variable + y, + // Target + x^#1[1,0]#, + // Accumulator + @result, + // Init + []^#19[1,8]#, + // LoopCondition + true^#20[1,8]#, + // LoopStep + _?_:_( + __comprehension__( + // Variable + z, + // Target + y^#4[1,12]#, + // Accumulator + @result, + // Init + []^#10[1,20]#, + // LoopCondition + true^#11[1,20]#, + // LoopStep + _?_:_( + _>_( + z^#7[1,24]#, + 0^#9[1,28]# + )^#8[1,26]#, + _+_( + @result^#12[1,20]#, + [ + z^#6[1,21]# + ]^#13[1,20]# + )^#14[1,20]#, + @result^#15[1,20]# + )^#16[1,20]#, + // Result + @result^#17[1,20]#)^#18[1,20]#, + _+_( + @result^#21[1,8]#, + [ + y^#3[1,9]# + ]^#22[1,8]# + )^#23[1,8]#, + @result^#24[1,8]# + )^#25[1,8]#, + // Result + @result^#26[1,8]#)^#27[1,8]# +M: x^#1:Expr.Ident#.filter( + y^#3:Expr.Ident#, + ^#18:filter# +)^#0:Expr.Call#, +y^#4:Expr.Ident#.filter( + z^#6:Expr.Ident#, + _>_( + z^#7:Expr.Ident#, + 0^#9:int64# + )^#8:Expr.Call# +)^#0:Expr.Call# + +I: has(a.b).filter(c, c) +=====> +P: __comprehension__( + // Variable + c, + // Target + a^#2:Expr.Ident#.b~test-only~^#4:Expr.Select#, + // Accumulator + @result, + // Init + []^#8:Expr.CreateList#, + // LoopCondition + true^#9:bool#, + // LoopStep + _?_:_( + c^#7:Expr.Ident#, + _+_( + @result^#10:Expr.Ident#, + [ + c^#6:Expr.Ident# + ]^#11:Expr.CreateList# + )^#12:Expr.Call#, + @result^#13:Expr.Ident# + )^#14:Expr.Call#, + // Result + @result^#15:Expr.Ident#)^#16:Expr.Comprehension# +L: __comprehension__( + // Variable + c, + // Target + a^#2[1,4]#.b~test-only~^#4[1,3]#, + // Accumulator + @result, + // Init + []^#8[1,15]#, + // LoopCondition + true^#9[1,15]#, + // LoopStep + _?_:_( + c^#7[1,19]#, + _+_( + @result^#10[1,15]#, + [ + c^#6[1,16]# + ]^#11[1,15]# + )^#12[1,15]#, + @result^#13[1,15]# + )^#14[1,15]#, + // Result + @result^#15[1,15]#)^#16[1,15]# +M: ^#4:has#.filter( + c^#6:Expr.Ident#, + c^#7:Expr.Ident# +)^#0:Expr.Call#, +has( + a^#2:Expr.Ident#.b^#3:Expr.Select# +)^#0:Expr.Call# + +I: x.filter(y, y.exists(z, has(z.a)) && y.exists(z, has(z.b))) +=====> +P: __comprehension__( + // Variable + y, + // Target + x^#1:Expr.Ident#, + // Accumulator + @result, + // Init + []^#35:Expr.CreateList#, + // LoopCondition + true^#36:bool#, + // LoopStep + _?_:_( + _&&_( + __comprehension__( + // Variable + z, + // Target + y^#4:Expr.Ident#, + // Accumulator + @result, + // Init + false^#11:bool#, + // LoopCondition + @not_strictly_false( + !_( + @result^#12:Expr.Ident# + )^#13:Expr.Call# + )^#14:Expr.Call#, + // LoopStep + _||_( + @result^#15:Expr.Ident#, + z^#8:Expr.Ident#.a~test-only~^#10:Expr.Select# + )^#16:Expr.Call#, + // Result + @result^#17:Expr.Ident#)^#18:Expr.Comprehension#, + __comprehension__( + // Variable + z, + // Target + y^#20:Expr.Ident#, + // Accumulator + @result, + // Init + false^#27:bool#, + // LoopCondition + @not_strictly_false( + !_( + @result^#28:Expr.Ident# + )^#29:Expr.Call# + )^#30:Expr.Call#, + // LoopStep + _||_( + @result^#31:Expr.Ident#, + z^#24:Expr.Ident#.b~test-only~^#26:Expr.Select# + )^#32:Expr.Call#, + // Result + @result^#33:Expr.Ident#)^#34:Expr.Comprehension# + )^#19:Expr.Call#, + _+_( + @result^#37:Expr.Ident#, + [ + y^#3:Expr.Ident# + ]^#38:Expr.CreateList# + )^#39:Expr.Call#, + @result^#40:Expr.Ident# + )^#41:Expr.Call#, + // Result + @result^#42:Expr.Ident#)^#43:Expr.Comprehension# +L: __comprehension__( + // Variable + y, + // Target + x^#1[1,0]#, + // Accumulator + @result, + // Init + []^#35[1,8]#, + // LoopCondition + true^#36[1,8]#, + // LoopStep + _?_:_( + _&&_( + __comprehension__( + // Variable + z, + // Target + y^#4[1,12]#, + // Accumulator + @result, + // Init + false^#11[1,20]#, + // LoopCondition + @not_strictly_false( + !_( + @result^#12[1,20]# + )^#13[1,20]# + )^#14[1,20]#, + // LoopStep + _||_( + @result^#15[1,20]#, + z^#8[1,28]#.a~test-only~^#10[1,27]# + )^#16[1,20]#, + // Result + @result^#17[1,20]#)^#18[1,20]#, + __comprehension__( + // Variable + z, + // Target + y^#20[1,37]#, + // Accumulator + @result, + // Init + false^#27[1,45]#, + // LoopCondition + @not_strictly_false( + !_( + @result^#28[1,45]# + )^#29[1,45]# + )^#30[1,45]#, + // LoopStep + _||_( + @result^#31[1,45]#, + z^#24[1,53]#.b~test-only~^#26[1,52]# + )^#32[1,45]#, + // Result + @result^#33[1,45]#)^#34[1,45]# + )^#19[1,34]#, + _+_( + @result^#37[1,8]#, + [ + y^#3[1,9]# + ]^#38[1,8]# + )^#39[1,8]#, + @result^#40[1,8]# + )^#41[1,8]#, + // Result + @result^#42[1,8]#)^#43[1,8]# +M: x^#1:Expr.Ident#.filter( + y^#3:Expr.Ident#, + _&&_( + ^#18:exists#, + ^#34:exists# + )^#19:Expr.Call# +)^#0:Expr.Call#, +y^#20:Expr.Ident#.exists( + z^#22:Expr.Ident#, + ^#26:has# +)^#0:Expr.Call#, +has( + z^#24:Expr.Ident#.b^#25:Expr.Select# +)^#0:Expr.Call#, +y^#4:Expr.Ident#.exists( + z^#6:Expr.Ident#, + ^#10:has# +)^#0:Expr.Call#, +has( + z^#8:Expr.Ident#.a^#9:Expr.Select# +)^#0:Expr.Call# + +I: noop_macro(123) +=====> +P: noop_macro( + 123^#2:int64# +)^#1:Expr.Call# +L: noop_macro( + 123^#2[1,11]# +)^#1[1,10]# + +I: get_constant_macro() +=====> +P: 10^#1:int64# +L: 10^#1[NO_POS]# +M: get_constant_macro()^#0:Expr.Call# + +I: a.?b[?0] && a[?c] +=====> +P: _&&_( + _[?_]( + _?._( + a^#1:Expr.Ident#, + "b"^#3:string# + )^#2:Expr.Call#, + 0^#5:int64# + )^#4:Expr.Call#, + _[?_]( + a^#7:Expr.Ident#, + c^#9:Expr.Ident# + )^#8:Expr.Call# +)^#6:Expr.Call# +L: _&&_( + _[?_]( + _?._( + a^#1[1,0]#, + "b"^#3[1,0]# + )^#2[1,1]#, + 0^#5[1,6]# + )^#4[1,4]#, + _[?_]( + a^#7[1,12]#, + c^#9[1,15]# + )^#8[1,13]# +)^#6[1,9]# + +I: {?'key': value} +=====> +P: { + ?"key"^#3:string#:value^#4:Expr.Ident#^#2:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: { + ?"key"^#3[1,2]#:value^#4[1,9]#^#2[1,7]# +}^#1[1,0]# + +I: Msg{?field: value} +=====> +P: Msg{ + ?field:value^#3:Expr.Ident#^#2:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: Msg{ + ?field:value^#3[1,12]#^#2[1,10]# +}^#1[1,3]# + +I: [?a, ?b] +=====> +P: [ + ?a^#2:Expr.Ident#, + ?b^#3:Expr.Ident# +]^#1:Expr.CreateList# +L: [ + ?a^#2[1,2]#, + ?b^#3[1,6]# +]^#1[1,0]# + +I: [?a[?b]] +=====> +P: [ + ?_[?_]( + a^#2:Expr.Ident#, + b^#4:Expr.Ident# + )^#3:Expr.Call# +]^#1:Expr.CreateList# +L: [ + ?_[?_]( + a^#2[1,2]#, + b^#4[1,5]# + )^#3[1,3]# +]^#1[1,0]# + +I: while +=====> +P: while^#1:Expr.Ident# +L: while^#1[1,0]# + +I: foo.`bar` +=====> +P: foo^#1:Expr.Ident#.bar^#2:Expr.Select# +L: foo^#1[1,0]#.bar^#2[1,3]# + +I: foo.`bar-baz` +=====> +P: foo^#1:Expr.Ident#.bar-baz^#2:Expr.Select# +L: foo^#1[1,0]#.bar-baz^#2[1,3]# + +I: foo.`bar baz` +=====> +P: foo^#1:Expr.Ident#.bar baz^#2:Expr.Select# +L: foo^#1[1,0]#.bar baz^#2[1,3]# + +I: foo.`bar.baz` +=====> +P: foo^#1:Expr.Ident#.bar.baz^#2:Expr.Select# +L: foo^#1[1,0]#.bar.baz^#2[1,3]# + +I: foo.`bar/baz` +=====> +P: foo^#1:Expr.Ident#.bar/baz^#2:Expr.Select# +L: foo^#1[1,0]#.bar/baz^#2[1,3]# + +I: foo.`bar_baz` +=====> +P: foo^#1:Expr.Ident#.bar_baz^#2:Expr.Select# +L: foo^#1[1,0]#.bar_baz^#2[1,3]# + +I: foo.`in` +=====> +P: foo^#1:Expr.Ident#.in^#2:Expr.Select# +L: foo^#1[1,0]#.in^#2[1,3]# + +I: Struct{`in`: false} +=====> +P: Struct{ + in:false^#3:bool#^#2:Expr.CreateStruct.Entry# +}^#1:Expr.CreateStruct# +L: Struct{ + in:false^#3[1,13]#^#2[1,11]# +}^#1[1,6]# \ No newline at end of file diff --git a/parser/src/test/resources/parser_errors.baseline b/parser/src/test/resources/parser_errors.baseline new file mode 100644 index 000000000..bb4ab3ed3 --- /dev/null +++ b/parser/src/test/resources/parser_errors.baseline @@ -0,0 +1,425 @@ +I: *@a | b +=====> +E: ERROR: :1:1: extraneous input '*' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | *@a | b + | ^ +ERROR: :1:2: token recognition error at: '@' + | *@a | b + | .^ +ERROR: :1:5: token recognition error at: '| ' + | *@a | b + | ....^ +ERROR: :1:7: extraneous input 'b' expecting + | *@a | b + | ......^ + +I: a | b +=====> +E: ERROR: :1:3: token recognition error at: '| ' + | a | b + | ..^ +ERROR: :1:5: extraneous input 'b' expecting + | a | b + | ....^ + +I: ? +=====> +E: ERROR: :1:1: mismatched input '?' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | ? + | ^ +ERROR: :1:2: mismatched input '' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | ? + | .^ + +I: 1 + $ +=====> +E: ERROR: :1:5: token recognition error at: '$' + | 1 + $ + | ....^ +ERROR: :1:6: mismatched input '' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | 1 + $ + | .....^ + +I: 1.all(2, 3) +=====> +E: ERROR: :1:7: The argument must be a simple name + | 1.all(2, 3) + | ......^ + +I: 1.exists(2, 3) +=====> +E: ERROR: :1:10: The argument must be a simple name + | 1.exists(2, 3) + | .........^ + +I: [].all(__result__, x) +=====> +E: ERROR: :1:8: The iteration variable __result__ overwrites accumulator variable + | [].all(__result__, x) + | .......^ + +I: [].exists(__result__, x) +=====> +E: ERROR: :1:11: The iteration variable __result__ overwrites accumulator variable + | [].exists(__result__, x) + | ..........^ + +I: [].exists_one(__result__, x) +=====> +E: ERROR: :1:15: The iteration variable __result__ overwrites accumulator variable + | [].exists_one(__result__, x) + | ..............^ + +I: [].map(__result__, x, x) +=====> +E: ERROR: :1:8: The iteration variable __result__ overwrites accumulator variable + | [].map(__result__, x, x) + | .......^ + +I: [].filter(__result__, x) +=====> +E: ERROR: :1:11: The iteration variable __result__ overwrites accumulator variable + | [].filter(__result__, x) + | ..........^ + +I: [].all(.x, x) +=====> +E: ERROR: :1:9: The argument must be a simple name + | [].all(.x, x) + | ........^ + +I: [].exists(.x, x) +=====> +E: ERROR: :1:12: The argument must be a simple name + | [].exists(.x, x) + | ...........^ + +I: [].exists_one(.x, x) +=====> +E: ERROR: :1:16: The argument must be a simple name + | [].exists_one(.x, x) + | ...............^ + +I: [].map(.x, x, x) +=====> +E: ERROR: :1:9: The argument must be a simple name + | [].map(.x, x, x) + | ........^ + +I: [].filter(.x, x) +=====> +E: ERROR: :1:12: The argument must be a simple name + | [].filter(.x, x) + | ...........^ + +I: 1 + + +=====> +E: ERROR: :1:5: mismatched input '+' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | 1 + + + | ....^ +ERROR: :1:6: mismatched input '' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | 1 + + + | .....^ + +I: "\xFh" +=====> +E: ERROR: :1:1: token recognition error at: '"\xFh' + | "\xFh" + | ^ +ERROR: :1:6: token recognition error at: '"' + | "\xFh" + | .....^ +ERROR: :1:7: mismatched input '' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | "\xFh" + | ......^ + +I: "\a\b\f\n\r\t\v\'\"\\\? Illegal escape \>" +=====> +E: ERROR: :1:1: token recognition error at: '"\a\b\f\n\r\t\v\'\"\\\? Illegal escape \>' + | "\a\b\f\n\r\t\v\'\"\\\? Illegal escape \>" + | ^ +ERROR: :1:42: token recognition error at: '"' + | "\a\b\f\n\r\t\v\'\"\\\? Illegal escape \>" + | .........................................^ +ERROR: :1:43: mismatched input '' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | "\a\b\f\n\r\t\v\'\"\\\? Illegal escape \>" + | ..........................................^ + +I: '?' +=====> +E: ERROR: :1:1: Invalid unicode code point + | '?' + | ^ + +I: '?' +=====> +E: ERROR: :1:1: Invalid unicode code point + | '?' + | ^ + +I: r"\?" +=====> +E: ERROR: :1:1: Invalid unicode code point + | r"\?" + | ^ + +I: as +=====> +E: ERROR: :1:1: reserved identifier: as + | as + | ^ + +I: break +=====> +E: ERROR: :1:1: reserved identifier: break + | break + | ^ + +I: const +=====> +E: ERROR: :1:1: reserved identifier: const + | const + | ^ + +I: continue +=====> +E: ERROR: :1:1: reserved identifier: continue + | continue + | ^ + +I: else +=====> +E: ERROR: :1:1: reserved identifier: else + | else + | ^ + +I: for +=====> +E: ERROR: :1:1: reserved identifier: for + | for + | ^ + +I: function +=====> +E: ERROR: :1:1: reserved identifier: function + | function + | ^ + +I: if +=====> +E: ERROR: :1:1: reserved identifier: if + | if + | ^ + +I: import +=====> +E: ERROR: :1:1: reserved identifier: import + | import + | ^ + +I: in +=====> +E: ERROR: :1:1: mismatched input 'in' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | in + | ^ +ERROR: :1:3: mismatched input '' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | in + | ..^ + +I: let +=====> +E: ERROR: :1:1: reserved identifier: let + | let + | ^ + +I: loop +=====> +E: ERROR: :1:1: reserved identifier: loop + | loop + | ^ + +I: package +=====> +E: ERROR: :1:1: reserved identifier: package + | package + | ^ + +I: namespace +=====> +E: ERROR: :1:1: reserved identifier: namespace + | namespace + | ^ + +I: return +=====> +E: ERROR: :1:1: reserved identifier: return + | return + | ^ + +I: var +=====> +E: ERROR: :1:1: reserved identifier: var + | var + | ^ + +I: void +=====> +E: ERROR: :1:1: reserved identifier: void + | void + | ^ + +I: while +=====> +E: ERROR: :1:1: reserved identifier: while + | while + | ^ + +I: [1, 2, 3].map(var, var * var) +=====> +E: ERROR: :1:15: reserved identifier: var + | [1, 2, 3].map(var, var * var) + | ..............^ +ERROR: :1:15: The argument must be a simple name + | [1, 2, 3].map(var, var * var) + | ..............^ +ERROR: :1:20: reserved identifier: var + | [1, 2, 3].map(var, var * var) + | ...................^ +ERROR: :1:26: reserved identifier: var + | [1, 2, 3].map(var, var * var) + | .........................^ + +I: '😁' in ['😁', 'πŸ˜‘', '😦'] + && in.😁 +=====> +E: ERROR: :2:7: extraneous input 'in' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | && in.😁 + | ......^ +ERROR: :2:10: token recognition error at: '😁' + | && in.😁 + | .........οΌΎ +ERROR: :2:11: no viable alternative at input '.' + | && in.😁 + | .........．^ + +I: [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[['too many']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] +=====> +E: Expression recursion limit exceeded. limit: 250 + +I: {"a": 1}."a" +=====> +E: ERROR: :1:10: no viable alternative at input '."a"' + | {"a": 1}."a" + | .........^ + +I: 1 + 2 +3 + +=====> +E: ERROR: :2:1: mismatched input '3' expecting {, '==', '!=', 'in', '<', '<=', '>=', '>', '&&', '||', '[', '.', '-', '?', '+', '*', '/', '%%'} + | 3 + + | ^ + +I: TestAllTypes(){single_int32: 1, single_int64: 2} +=====> +E: ERROR: :1:15: mismatched input '{' expecting {, '==', '!=', 'in', '<', '<=', '>=', '>', '&&', '||', '[', '.', '-', '?', '+', '*', '/', '%%'} + | TestAllTypes(){single_int32: 1, single_int64: 2} + | ..............^ + +I: { +=====> +E: ERROR: :1:2: mismatched input '' expecting {'[', '{', '}', '(', '.', ',', '-', '!', '?', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | { + | .^ + +I: t{>C} +=====> +E: ERROR: :1:3: extraneous input '>' expecting {'}', ',', '?', IDENTIFIER, ESC_IDENTIFIER} + | t{>C} + | ..^ +ERROR: :1:5: mismatched input '}' expecting ':' + | t{>C} + | ....^ + +I: has([(has(( +=====> +E: ERROR: :1:4: invalid argument to has() macro + | has([(has(( + | ...^ +ERROR: :1:12: mismatched input '' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | has([(has(( + | ...........^ + +I: a.?b && a[?b] +=====> +E: ERROR: :1:2: unsupported syntax '.?' + | a.?b && a[?b] + | .^ +ERROR: :1:10: unsupported syntax '[?' + | a.?b && a[?b] + | .........^ + +I: Msg{?field: value} && {?'key': value} +=====> +E: ERROR: :1:5: unsupported syntax '?' + | Msg{?field: value} && {?'key': value} + | ....^ +ERROR: :1:24: unsupported syntax '?' + | Msg{?field: value} && {?'key': value} + | .......................^ + +I: [?a, ?b] +=====> +E: ERROR: :1:2: unsupported syntax '?' + | [?a, ?b] + | .^ +ERROR: :1:6: unsupported syntax '?' + | [?a, ?b] + | .....^ + +I: `bar` +=====> +E: ERROR: :1:1: mismatched input '`bar`' expecting {'[', '{', '(', '.', '-', '!', 'true', 'false', 'null', NUM_FLOAT, NUM_INT, NUM_UINT, STRING, BYTES, IDENTIFIER} + | `bar` + | ^ + +I: foo.`` +=====> +E: ERROR: :1:5: token recognition error at: '``' + | foo.`` + | ....^ +ERROR: :1:7: no viable alternative at input '.' + | foo.`` + | ......^ + +I: foo.`$bar` +=====> +E: ERROR: :1:5: token recognition error at: '`$' + | foo.`$bar` + | ....^ +ERROR: :1:10: token recognition error at: '`' + | foo.`$bar` + | .........^ + +I: foo.`bar` +=====> +E: ERROR: :1:5: unsupported syntax '`' + | foo.`bar` + | ....^ + +I: Struct{`bar`: false} +=====> +E: ERROR: :1:8: unsupported syntax '`' + | Struct{`bar`: false} + | .......^ + +I: has(.`.` +=====> +E: ERROR: :1:6: no viable alternative at input '.`.`' + | has(.`.` + | .....^ +ERROR: :1:6: unsupported syntax '`' + | has(.`.` + | .....^ +ERROR: :1:9: missing ')' at '' + | has(.`.` + | ........^ \ No newline at end of file diff --git a/parser/src/test/resources/parser_legacyAccuVar.baseline b/parser/src/test/resources/parser_legacyAccuVar.baseline new file mode 100644 index 000000000..5f9a48b31 --- /dev/null +++ b/parser/src/test/resources/parser_legacyAccuVar.baseline @@ -0,0 +1,280 @@ +I: x * 2 +=====> +P: _*_( + x^#1:Expr.Ident#, + 2^#3:int64# +)^#2:Expr.Call# +L: _*_( + x^#1[1,0]#, + 2^#3[1,4]# +)^#2[1,2]# + +I: has(m.f) +=====> +P: m^#2:Expr.Ident#.f~test-only~^#4:Expr.Select# +L: m^#2[1,4]#.f~test-only~^#4[1,3]# +M: has( + m^#2:Expr.Ident#.f^#3:Expr.Select# +)^#0:Expr.Call# + +I: m.exists_one(v, f) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + __result__, + // Init + 0^#5:int64#, + // LoopCondition + true^#6:bool#, + // LoopStep + _?_:_( + f^#4:Expr.Ident#, + _+_( + __result__^#7:Expr.Ident#, + 1^#8:int64# + )^#9:Expr.Call#, + __result__^#10:Expr.Ident# + )^#11:Expr.Call#, + // Result + _==_( + __result__^#12:Expr.Ident#, + 1^#13:int64# + )^#14:Expr.Call#)^#15:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + __result__, + // Init + 0^#5[1,12]#, + // LoopCondition + true^#6[1,12]#, + // LoopStep + _?_:_( + f^#4[1,16]#, + _+_( + __result__^#7[1,12]#, + 1^#8[1,12]# + )^#9[1,12]#, + __result__^#10[1,12]# + )^#11[1,12]#, + // Result + _==_( + __result__^#12[1,12]#, + 1^#13[1,12]# + )^#14[1,12]#)^#15[1,12]# +M: m^#1:Expr.Ident#.exists_one( + v^#3:Expr.Ident#, + f^#4:Expr.Ident# +)^#0:Expr.Call# + +I: m.all(v, f) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + __result__, + // Init + true^#5:bool#, + // LoopCondition + @not_strictly_false( + __result__^#6:Expr.Ident# + )^#7:Expr.Call#, + // LoopStep + _&&_( + __result__^#8:Expr.Ident#, + f^#4:Expr.Ident# + )^#9:Expr.Call#, + // Result + __result__^#10:Expr.Ident#)^#11:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + __result__, + // Init + true^#5[1,5]#, + // LoopCondition + @not_strictly_false( + __result__^#6[1,5]# + )^#7[1,5]#, + // LoopStep + _&&_( + __result__^#8[1,5]#, + f^#4[1,9]# + )^#9[1,5]#, + // Result + __result__^#10[1,5]#)^#11[1,5]# +M: m^#1:Expr.Ident#.all( + v^#3:Expr.Ident#, + f^#4:Expr.Ident# +)^#0:Expr.Call# + +I: m.map(v, f) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + __result__, + // Init + []^#5:Expr.CreateList#, + // LoopCondition + true^#6:bool#, + // LoopStep + _+_( + __result__^#7:Expr.Ident#, + [ + f^#4:Expr.Ident# + ]^#8:Expr.CreateList# + )^#9:Expr.Call#, + // Result + __result__^#10:Expr.Ident#)^#11:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + __result__, + // Init + []^#5[1,5]#, + // LoopCondition + true^#6[1,5]#, + // LoopStep + _+_( + __result__^#7[1,5]#, + [ + f^#4[1,9]# + ]^#8[1,5]# + )^#9[1,5]#, + // Result + __result__^#10[1,5]#)^#11[1,5]# +M: m^#1:Expr.Ident#.map( + v^#3:Expr.Ident#, + f^#4:Expr.Ident# +)^#0:Expr.Call# + +I: m.map(v, p, f) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + __result__, + // Init + []^#6:Expr.CreateList#, + // LoopCondition + true^#7:bool#, + // LoopStep + _?_:_( + p^#4:Expr.Ident#, + _+_( + __result__^#8:Expr.Ident#, + [ + f^#5:Expr.Ident# + ]^#9:Expr.CreateList# + )^#10:Expr.Call#, + __result__^#11:Expr.Ident# + )^#12:Expr.Call#, + // Result + __result__^#13:Expr.Ident#)^#14:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + __result__, + // Init + []^#6[1,5]#, + // LoopCondition + true^#7[1,5]#, + // LoopStep + _?_:_( + p^#4[1,9]#, + _+_( + __result__^#8[1,5]#, + [ + f^#5[1,12]# + ]^#9[1,5]# + )^#10[1,5]#, + __result__^#11[1,5]# + )^#12[1,5]#, + // Result + __result__^#13[1,5]#)^#14[1,5]# +M: m^#1:Expr.Ident#.map( + v^#3:Expr.Ident#, + p^#4:Expr.Ident#, + f^#5:Expr.Ident# +)^#0:Expr.Call# + +I: m.filter(v, p) +=====> +P: __comprehension__( + // Variable + v, + // Target + m^#1:Expr.Ident#, + // Accumulator + __result__, + // Init + []^#5:Expr.CreateList#, + // LoopCondition + true^#6:bool#, + // LoopStep + _?_:_( + p^#4:Expr.Ident#, + _+_( + __result__^#7:Expr.Ident#, + [ + v^#3:Expr.Ident# + ]^#8:Expr.CreateList# + )^#9:Expr.Call#, + __result__^#10:Expr.Ident# + )^#11:Expr.Call#, + // Result + __result__^#12:Expr.Ident#)^#13:Expr.Comprehension# +L: __comprehension__( + // Variable + v, + // Target + m^#1[1,0]#, + // Accumulator + __result__, + // Init + []^#5[1,8]#, + // LoopCondition + true^#6[1,8]#, + // LoopStep + _?_:_( + p^#4[1,12]#, + _+_( + __result__^#7[1,8]#, + [ + v^#3[1,9]# + ]^#8[1,8]# + )^#9[1,8]#, + __result__^#10[1,8]# + )^#11[1,8]#, + // Result + __result__^#12[1,8]#)^#13[1,8]# +M: m^#1:Expr.Ident#.filter( + v^#3:Expr.Ident#, + p^#4:Expr.Ident# +)^#0:Expr.Call# \ No newline at end of file diff --git a/parser/src/test/resources/source_info.baseline b/parser/src/test/resources/source_info.baseline new file mode 100644 index 000000000..153a49822 --- /dev/null +++ b/parser/src/test/resources/source_info.baseline @@ -0,0 +1,143 @@ +I: [{}, {'field': true}].exists(i, has(i.field)) +=====> +S: location: "" +line_offsets: 46 +positions { + key: 1 + value: 0 +} +positions { + key: 2 + value: 1 +} +positions { + key: 3 + value: 5 +} +positions { + key: 4 + value: 13 +} +positions { + key: 5 + value: 6 +} +positions { + key: 6 + value: 15 +} +positions { + key: 8 + value: 29 +} +positions { + key: 10 + value: 36 +} +positions { + key: 11 + value: 37 +} +positions { + key: 12 + value: 35 +} +positions { + key: 13 + value: 28 +} +positions { + key: 14 + value: 28 +} +positions { + key: 15 + value: 28 +} +positions { + key: 16 + value: 28 +} +positions { + key: 17 + value: 28 +} +positions { + key: 18 + value: 28 +} +positions { + key: 19 + value: 28 +} +positions { + key: 20 + value: 28 +} +macro_calls { + key: 12 + value { + call_expr { + function: "has" + args { + id: 11 + select_expr { + operand { + id: 10 + ident_expr { + name: "i" + } + } + field: "field" + } + } + } + } +} +macro_calls { + key: 20 + value { + call_expr { + target { + id: 1 + list_expr { + elements { + id: 2 + struct_expr { + } + } + elements { + id: 3 + struct_expr { + entries { + id: 4 + map_key { + id: 5 + const_expr { + string_value: "field" + } + } + value { + id: 6 + const_expr { + bool_value: true + } + } + } + } + } + } + } + function: "exists" + args { + id: 8 + ident_expr { + name: "i" + } + } + args { + id: 12 + } + } + } +} diff --git a/policy/BUILD.bazel b/policy/BUILD.bazel new file mode 100644 index 000000000..bce68f001 --- /dev/null +++ b/policy/BUILD.bazel @@ -0,0 +1,67 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "policy", + exports = ["//policy/src/main/java/dev/cel/policy"], +) + +java_library( + name = "compiled_rule", + exports = ["//policy/src/main/java/dev/cel/policy:compiled_rule"], +) + +java_library( + name = "source", + exports = ["//policy/src/main/java/dev/cel/policy:source"], +) + +java_library( + name = "validation_exception", + exports = ["//policy/src/main/java/dev/cel/policy:validation_exception"], +) + +java_library( + name = "parser", + exports = ["//policy/src/main/java/dev/cel/policy:parser"], +) + +java_library( + name = "policy_parser_context", + exports = ["//policy/src/main/java/dev/cel/policy:policy_parser_context"], +) + +java_library( + name = "parser_factory", + exports = ["//policy/src/main/java/dev/cel/policy:parser_factory"], +) + +java_library( + name = "compiler_factory", + exports = ["//policy/src/main/java/dev/cel/policy:compiler_factory"], +) + +java_library( + name = "parser_builder", + exports = ["//policy/src/main/java/dev/cel/policy:parser_builder"], +) + +java_library( + name = "compiler", + exports = ["//policy/src/main/java/dev/cel/policy:compiler"], +) + +java_library( + name = "compiler_builder", + exports = ["//policy/src/main/java/dev/cel/policy:compiler_builder"], +) + +java_library( + name = "rule_composer", + visibility = ["//:internal"], + exports = ["//policy/src/main/java/dev/cel/policy:rule_composer"], +) diff --git a/policy/src/main/java/dev/cel/policy/BUILD.bazel b/policy/src/main/java/dev/cel/policy/BUILD.bazel new file mode 100644 index 000000000..e0d6af461 --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/BUILD.bazel @@ -0,0 +1,266 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//policy:__pkg__", + "//publish:__pkg__", + ], +) + +java_library( + name = "policy", + srcs = [ + "CelPolicy.java", + ], + tags = [ + ], + deps = [ + ":required_fields_checker", + ":source", + "//:auto_value", + "//common/formats:value_string", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "source", + srcs = [ + "CelPolicySource.java", + ], + tags = [ + ], + deps = [ + "//:auto_value", + "//common:cel_source_helper", + "//common:source", + "//common:source_location", + "//common/internal", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "validation_exception", + srcs = [ + "CelPolicyValidationException.java", + ], + tags = [ + ], +) + +java_library( + name = "parser_factory", + srcs = ["CelPolicyParserFactory.java"], + tags = [ + ], + deps = [ + ":parser_builder", + ":yaml_parser", + "@maven//:org_yaml_snakeyaml", + ], +) + +java_library( + name = "yaml_parser", + srcs = [ + "CelPolicyYamlParser.java", + ], + deps = [ + ":parser", + ":parser_builder", + ":policy", + ":policy_parser_context", + ":source", + ":validation_exception", + "//common:compiler_common", + "//common/formats:parser_context", + "//common/formats:value_string", + "//common/formats:yaml_helper", + "//common/formats:yaml_parser_context_impl", + "//common/internal", + "@maven//:com_google_guava_guava", + "@maven//:org_yaml_snakeyaml", + ], +) + +java_library( + name = "parser", + srcs = [ + "CelPolicyParser.java", + ], + tags = [ + ], + deps = [ + ":policy", + ":policy_parser_context", + ":validation_exception", + ], +) + +java_library( + name = "parser_builder", + srcs = [ + "CelPolicyParserBuilder.java", + ], + tags = [ + ], + deps = [ + ":parser", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "compiler", + srcs = [ + "CelPolicyCompiler.java", + ], + tags = [ + ], + deps = [ + ":compiled_rule", + ":policy", + ":validation_exception", + "//common:cel_ast", + ], +) + +java_library( + name = "compiler_builder", + srcs = [ + "CelPolicyCompilerBuilder.java", + ], + tags = [ + ], + deps = [ + ":compiler", + "//optimizer:ast_optimizer", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "compiler_factory", + srcs = ["CelPolicyCompilerFactory.java"], + tags = [ + ], + deps = [ + ":compiler_builder", + ":compiler_impl", + "//bundle:cel", + "//checker:checker_builder", + "//compiler", + "//compiler:compiler_builder", + "//parser:parser_builder", + "//runtime", + ], +) + +java_library( + name = "policy_parser_context", + srcs = [ + "PolicyParserContext.java", + ], + tags = [ + ], + deps = [ + ":policy", + "//:auto_value", + "//common/formats:parser_context", + "//policy:source", + ], +) + +java_library( + name = "compiled_rule", + srcs = ["CelCompiledRule.java"], + deps = [ + "//:auto_value", + "//bundle:cel", + "//common:cel_ast", + "//common:compiler_common", + "//common/ast", + "//common/formats:value_string", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "compiler_impl", + srcs = [ + "CelPolicyCompilerImpl.java", + ], + visibility = ["//visibility:private"], + deps = [ + ":compiled_rule", + ":compiler", + ":compiler_builder", + ":policy", + ":rule_composer", + ":source", + ":validation_exception", + "//bundle:cel", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:source_location", + "//common/ast", + "//common/formats:value_string", + "//common/types", + "//common/types:type_providers", + "//optimizer", + "//optimizer:ast_optimizer", + "//optimizer:optimization_exception", + "//optimizer:optimizer_builder", + "//optimizer/optimizers:common_subexpression_elimination", + "//optimizer/optimizers:constant_folding", + "//validator", + "//validator:ast_validator", + "//validator:validator_builder", + "//validator/validators:ast_depth_limit_validator", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "required_fields_checker", + srcs = [ + "RequiredFieldsChecker.java", + ], + visibility = ["//visibility:private"], + deps = [ + "//:auto_value", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "rule_composer", + srcs = ["RuleComposer.java"], + deps = [ + ":compiled_rule", + "//bundle:cel", + "//common:cel_ast", + "//common:compiler_common", + "//common:mutable_ast", + "//common:mutable_source", + "//common:operator", + "//common/ast", + "//common/ast:mutable_expr", + "//common/formats:value_string", + "//common/navigation:mutable_navigation", + "//common/types:cel_types", + "//common/types:type_providers", + "//extensions:optional_library", + "//optimizer:ast_optimizer", + "//optimizer:mutable_ast", + "@maven//:com_google_guava_guava", + ], +) diff --git a/policy/src/main/java/dev/cel/policy/CelCompiledRule.java b/policy/src/main/java/dev/cel/policy/CelCompiledRule.java new file mode 100644 index 000000000..af40bd74f --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelCompiledRule.java @@ -0,0 +1,163 @@ +// Copyright 2024 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.policy; + +import com.google.auto.value.AutoOneOf; +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelVarDecl; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.formats.ValueString; +import java.util.Optional; + +/** + * Abstract representation of a compiled rule. This contains set of compiled variables and match + * statements which defines an expression graph for a policy. + */ +@AutoValue +public abstract class CelCompiledRule { + + /** Source metadata identifier associated with the compiled rule. */ + public abstract long sourceId(); + + public abstract Optional ruleId(); + + public abstract ImmutableList variables(); + + public abstract ImmutableList matches(); + + public abstract Cel cel(); + + /** + * HasOptionalOutput returns whether the rule returns a concrete or optional value. The rule may + * return an optional value if all match expressions under the rule are conditional. + */ + public boolean hasOptionalOutput() { + boolean isOptionalOutput = false; + for (CelCompiledMatch match : matches()) { + if (match.result().kind().equals(CelCompiledMatch.Result.Kind.RULE) + && match.result().rule().hasOptionalOutput()) { + // If the nested rule is unconditional, the matching may fallthrough to the next match + // in this context (unwrapping the optional value from the nested rule). + if (!match.isConditionTriviallyTrue()) { + return true; + } + isOptionalOutput = true; + } else if (match.isConditionTriviallyTrue()) { + return false; + } else { + isOptionalOutput = true; + } + } + + return isOptionalOutput; + } + + /** + * A compiled policy variable (ex: variables.foo). Note that this is not the same thing as the + * variables declared in the config. + */ + @AutoValue + public abstract static class CelCompiledVariable { + public abstract String name(); + + /** Compiled variable in AST. */ + public abstract CelAbstractSyntaxTree ast(); + + /** The variable declaration used to compile this variable in {@link #ast}. */ + public abstract CelVarDecl celVarDecl(); + + static CelCompiledVariable create( + String name, CelAbstractSyntaxTree ast, CelVarDecl celVarDecl) { + return new AutoValue_CelCompiledRule_CelCompiledVariable(name, ast, celVarDecl); + } + } + + /** A compiled Match. */ + @AutoValue + public abstract static class CelCompiledMatch { + /** Source metadata identifier associated with the compiled match. */ + public abstract long sourceId(); + + public abstract CelAbstractSyntaxTree condition(); + + public abstract Result result(); + + public boolean isConditionTriviallyTrue() { + CelExpr celExpr = condition().getExpr(); + return celExpr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE) + && celExpr.constant().booleanValue(); + } + + /** Encapsulates the result of this match when condition is met. (either an output or a rule) */ + @AutoOneOf(CelCompiledMatch.Result.Kind.class) + public abstract static class Result { + public abstract OutputValue output(); + + public abstract CelCompiledRule rule(); + + public abstract Kind kind(); + + static Result ofOutput(long id, CelAbstractSyntaxTree ast) { + return AutoOneOf_CelCompiledRule_CelCompiledMatch_Result.output( + OutputValue.create(id, ast)); + } + + static Result ofRule(CelCompiledRule value) { + return AutoOneOf_CelCompiledRule_CelCompiledMatch_Result.rule(value); + } + + /** Kind for {@link Result}. */ + public enum Kind { + OUTPUT, + RULE + } + } + + /** + * Encapsulates the output value of the match with its original ID that was used to compile + * with. + */ + @AutoValue + public abstract static class OutputValue { + + /** Source metadata identifier associated with the output. */ + public abstract long sourceId(); + + public abstract CelAbstractSyntaxTree ast(); + + public static OutputValue create(long id, CelAbstractSyntaxTree ast) { + return new AutoValue_CelCompiledRule_CelCompiledMatch_OutputValue(id, ast); + } + } + + static CelCompiledMatch create( + long sourceId, CelAbstractSyntaxTree condition, CelCompiledMatch.Result result) { + return new AutoValue_CelCompiledRule_CelCompiledMatch(sourceId, condition, result); + } + } + + static CelCompiledRule create( + long sourceId, + Optional ruleId, + ImmutableList variables, + ImmutableList matches, + Cel cel) { + return new AutoValue_CelCompiledRule(sourceId, ruleId, variables, matches, cel); + } +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicy.java b/policy/src/main/java/dev/cel/policy/CelPolicy.java new file mode 100644 index 000000000..19f6631d0 --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicy.java @@ -0,0 +1,331 @@ +// Copyright 2024 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.policy; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.auto.value.AutoOneOf; +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.common.formats.ValueString; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** + * Abstract representation of a policy. It declares a name, rule, and evaluation semantic for a + * given expression graph. + */ +@AutoValue +public abstract class CelPolicy { + + public abstract ValueString name(); + + public abstract Optional description(); + + public abstract Optional displayName(); + + public abstract Rule rule(); + + public abstract CelPolicySource policySource(); + + public abstract ImmutableMap metadata(); + + public abstract ImmutableList imports(); + + /** Creates a new builder to construct a {@link CelPolicy} instance. */ + public static Builder newBuilder() { + return new AutoValue_CelPolicy.Builder() + .setName(ValueString.of(0, "")) + .setRule(Rule.newBuilder(0).build()) + .setMetadata(ImmutableMap.of()); + } + + public abstract Builder toBuilder(); + + /** Builder for {@link CelPolicy}. */ + @AutoValue.Builder + public abstract static class Builder { + public abstract CelPolicySource policySource(); + + public abstract Builder setName(ValueString name); + + public abstract Builder setDescription(ValueString description); + + public abstract Builder setDisplayName(ValueString displayName); + + public abstract Builder setRule(Rule rule); + + public abstract Builder setPolicySource(CelPolicySource policySource); + + private final HashMap metadata = new HashMap<>(); + + public abstract Builder setMetadata(ImmutableMap value); + + private final ArrayList importList = new ArrayList<>(); + + abstract Builder setImports(ImmutableList value); + + public List imports() { + return Collections.unmodifiableList(importList); + } + + public Map metadata() { + return Collections.unmodifiableMap(metadata); + } + + @CanIgnoreReturnValue + public Builder addImport(Import value) { + importList.add(value); + return this; + } + + @CanIgnoreReturnValue + public Builder addImports(Collection values) { + importList.addAll(values); + return this; + } + + @CanIgnoreReturnValue + public Builder putMetadata(String key, Object value) { + metadata.put(key, value); + return this; + } + + @CanIgnoreReturnValue + public Builder putMetadata(Map map) { + metadata.putAll(map); + return this; + } + + abstract CelPolicy autoBuild(); + + public CelPolicy build() { + setImports(ImmutableList.copyOf(importList)); + setMetadata(ImmutableMap.copyOf(metadata)); + return autoBuild(); + } + } + + /** + * Rule declares a rule identifier, description, along with a set of variables and match + * statements. + */ + @AutoValue + public abstract static class Rule { + public abstract long id(); + + public abstract Optional ruleId(); + + public abstract Optional description(); + + public abstract ImmutableSet variables(); + + public abstract ImmutableSet matches(); + + /** Builder for {@link Rule}. */ + public static Builder newBuilder(long id) { + return new AutoValue_CelPolicy_Rule.Builder() + .setId(id) + .setVariables(ImmutableSet.of()) + .setMatches(ImmutableSet.of()); + } + + /** Creates a new builder to construct a {@link Rule} instance. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Rule.Builder setRuleId(ValueString id); + + public abstract Rule.Builder setDescription(ValueString description); + + abstract ImmutableSet variables(); + + abstract ImmutableSet.Builder variablesBuilder(); + + abstract ImmutableSet matches(); + + abstract ImmutableSet.Builder matchesBuilder(); + + abstract Builder setId(long value); + + @CanIgnoreReturnValue + public Builder addVariables(Variable... variables) { + return addVariables(Arrays.asList(variables)); + } + + @CanIgnoreReturnValue + public Builder addVariables(Iterable variables) { + this.variablesBuilder().addAll(checkNotNull(variables)); + return this; + } + + @CanIgnoreReturnValue + public Builder addMatches(Match... matches) { + return addMatches(Arrays.asList(matches)); + } + + @CanIgnoreReturnValue + public Builder addMatches(Iterable matches) { + this.matchesBuilder().addAll(checkNotNull(matches)); + return this; + } + + abstract Rule.Builder setVariables(ImmutableSet variables); + + abstract Rule.Builder setMatches(ImmutableSet matches); + + public abstract Rule build(); + } + } + + /** + * Match declares a condition (defaults to true) as well as an output or a rule. Either the output + * or the rule field may be set, but not both. + */ + @AutoValue + public abstract static class Match { + + public abstract ValueString condition(); + + public abstract Result result(); + + public abstract long id(); + + /** Explanation returns the explanation expression, or empty expression if output is not set. */ + public abstract Optional explanation(); + + /** Encapsulates the result of this match when condition is met. (either an output or a rule) */ + @AutoOneOf(Match.Result.Kind.class) + public abstract static class Result { + public abstract ValueString output(); + + public abstract Rule rule(); + + public abstract Kind kind(); + + public static Result ofOutput(ValueString value) { + return AutoOneOf_CelPolicy_Match_Result.output(value); + } + + public static Result ofRule(Rule value) { + return AutoOneOf_CelPolicy_Match_Result.rule(value); + } + + /** Kind for {@link Result}. */ + public enum Kind { + OUTPUT, + RULE + } + } + + /** Builder for {@link Match}. */ + @AutoValue.Builder + public abstract static class Builder implements RequiredFieldsChecker { + public abstract Builder setId(long value); + + public abstract Builder setCondition(ValueString condition); + + public abstract Builder setResult(Result result); + + public abstract Builder setExplanation(ValueString explanation); + + abstract Optional id(); + + public abstract Optional result(); + + abstract Optional explanation(); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of(RequiredField.of("output or a rule", this::result)); + } + + public abstract Match build(); + } + + /** Creates a new builder to construct a {@link Match} instance. */ + public static Builder newBuilder(long id) { + return new AutoValue_CelPolicy_Match.Builder().setId(id); + } + } + + /** Variable is a named expression which may be referenced in subsequent expressions. */ + @AutoValue + public abstract static class Variable { + + public abstract ValueString name(); + + public abstract ValueString expression(); + + public abstract Optional description(); + + public abstract Optional displayName(); + + /** Builder for {@link Variable}. */ + @AutoValue.Builder + public abstract static class Builder implements RequiredFieldsChecker { + + abstract Optional name(); + + abstract Optional expression(); + + abstract Optional description(); + + abstract Optional displayName(); + + public abstract Builder setName(ValueString name); + + public abstract Builder setExpression(ValueString expression); + + public abstract Builder setDescription(ValueString description); + + public abstract Builder setDisplayName(ValueString displayName); + + @Override + public ImmutableList requiredFields() { + return ImmutableList.of( + RequiredField.of("name", this::name), RequiredField.of("expression", this::expression)); + } + + public abstract Variable build(); + } + + /** Creates a new builder to construct a {@link Variable} instance. */ + public static Builder newBuilder() { + return new AutoValue_CelPolicy_Variable.Builder(); + } + } + + /** Import represents an imported type name which is aliased within CEL expressions. */ + @AutoValue + public abstract static class Import { + public abstract long id(); + + public abstract ValueString name(); + + public static Import create(long id, ValueString name) { + return new AutoValue_CelPolicy_Import(id, name); + } + } +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicyCompiler.java b/policy/src/main/java/dev/cel/policy/CelPolicyCompiler.java new file mode 100644 index 000000000..e0af6d85b --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicyCompiler.java @@ -0,0 +1,45 @@ +// Copyright 2024 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.policy; + +import dev.cel.common.CelAbstractSyntaxTree; + +/** Public interface for compiling CEL policies. */ +public interface CelPolicyCompiler { + + /** + * Combines the {@link #compileRule} and {@link #compose} into a single call. + * + *

This generates a single CEL AST from a collection of policy expressions associated with a + * CEL environment. + */ + default CelAbstractSyntaxTree compile(CelPolicy policy) throws CelPolicyValidationException { + return compose(policy, compileRule(policy)); + } + + /** + * Produces a {@link CelCompiledRule} from the policy which contains a set of compiled variables + * and match statements. Compiled rule defines an expression graph, which can be composed into a + * single expression via {@link #compose} call. + */ + CelCompiledRule compileRule(CelPolicy policy) throws CelPolicyValidationException; + + /** + * Composes {@link CelCompiledRule}, representing an expression graph, into a single expression + * value. + */ + CelAbstractSyntaxTree compose(CelPolicy policy, CelCompiledRule compiledRule) + throws CelPolicyValidationException; +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicyCompilerBuilder.java b/policy/src/main/java/dev/cel/policy/CelPolicyCompilerBuilder.java new file mode 100644 index 000000000..4089477a1 --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicyCompilerBuilder.java @@ -0,0 +1,49 @@ +// Copyright 2024 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.policy; + +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.optimizer.CelAstOptimizer; +import java.util.List; + +/** Interface for building an instance of {@link CelPolicyCompiler} */ +public interface CelPolicyCompilerBuilder { + + /** Sets the prefix for the policy variables. Default is `variables.`. */ + @CanIgnoreReturnValue + CelPolicyCompilerBuilder setVariablesPrefix(String prefix); + + /** + * Limit the number of iteration while composing rules into a single AST. An exception is thrown + * if the iteration count exceeds the set value. + */ + @CanIgnoreReturnValue + CelPolicyCompilerBuilder setIterationLimit(int iterationLimit); + + /** + * Enforces the composed AST to stay below the configured depth limit. An exception is thrown if + * the depth exceeds the configured limit. Setting a negative value disables this check. + */ + @CanIgnoreReturnValue + CelPolicyCompilerBuilder setAstDepthLimit(int iterationLimit); + + /** Configures the policy compiler to run the provided optimizers on compiled policies. */ + @CanIgnoreReturnValue + CelPolicyCompilerBuilder setOptimizers(List optimizers); + + @CheckReturnValue + CelPolicyCompiler build(); +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicyCompilerFactory.java b/policy/src/main/java/dev/cel/policy/CelPolicyCompilerFactory.java new file mode 100644 index 000000000..8641e5bb7 --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicyCompilerFactory.java @@ -0,0 +1,46 @@ +// Copyright 2024 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.policy; + +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.checker.CelChecker; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelParser; +import dev.cel.runtime.CelRuntime; + +/** Factory class for producing policy compilers. */ +public final class CelPolicyCompilerFactory { + + /** Create a builder for constructing a {@link CelPolicyCompiler} instance. */ + public static CelPolicyCompilerBuilder newPolicyCompiler(Cel cel) { + return CelPolicyCompilerImpl.newBuilder(cel); + } + + /** Create a builder for constructing a {@link CelPolicyCompiler} instance. */ + public static CelPolicyCompilerBuilder newPolicyCompiler( + CelCompiler celCompiler, CelRuntime celRuntime) { + return newPolicyCompiler(CelFactory.combine(celCompiler, celRuntime)); + } + + /** Create a builder for constructing a {@link CelPolicyCompiler} instance. */ + public static CelPolicyCompilerBuilder newPolicyCompiler( + CelParser celParser, CelChecker celChecker, CelRuntime celRuntime) { + return newPolicyCompiler(CelCompilerFactory.combine(celParser, celChecker), celRuntime); + } + + private CelPolicyCompilerFactory() {} +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicyCompilerImpl.java b/policy/src/main/java/dev/cel/policy/CelPolicyCompilerImpl.java new file mode 100644 index 000000000..37a79f98a --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicyCompilerImpl.java @@ -0,0 +1,408 @@ +// Copyright 2024 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.policy; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelIssue; +import dev.cel.common.CelSource; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.CelVarDecl; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.formats.ValueString; +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; +import dev.cel.optimizer.CelAstOptimizer; +import dev.cel.optimizer.CelOptimizationException; +import dev.cel.optimizer.CelOptimizer; +import dev.cel.optimizer.CelOptimizerFactory; +import dev.cel.optimizer.optimizers.ConstantFoldingOptimizer; +import dev.cel.optimizer.optimizers.SubexpressionOptimizer; +import dev.cel.optimizer.optimizers.SubexpressionOptimizer.SubexpressionOptimizerOptions; +import dev.cel.policy.CelCompiledRule.CelCompiledMatch; +import dev.cel.policy.CelCompiledRule.CelCompiledMatch.Result; +import dev.cel.policy.CelCompiledRule.CelCompiledMatch.Result.Kind; +import dev.cel.policy.CelCompiledRule.CelCompiledVariable; +import dev.cel.policy.CelPolicy.Import; +import dev.cel.policy.CelPolicy.Match; +import dev.cel.policy.CelPolicy.Variable; +import dev.cel.policy.RuleComposer.RuleCompositionException; +import dev.cel.validator.CelAstValidator; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; +import dev.cel.validator.validators.AstDepthLimitValidator; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + +/** Package-private implementation for policy compiler. */ +final class CelPolicyCompilerImpl implements CelPolicyCompiler { + private static final String DEFAULT_VARIABLE_PREFIX = "variables."; + private static final int DEFAULT_ITERATION_LIMIT = 1000; + private final Cel cel; + private final String variablesPrefix; + private final int iterationLimit; + private final ImmutableList optimizers; + private final Optional astDepthValidator; + + @Override + public CelCompiledRule compileRule(CelPolicy policy) throws CelPolicyValidationException { + CompilerContext compilerContext = new CompilerContext(policy.policySource()); + + Cel extendedCel = this.cel; + + if (!policy.imports().isEmpty()) { + CelContainer.Builder containerBuilder = + extendedCel.toCheckerBuilder().container().toBuilder(); + + for (Import imp : policy.imports()) { + try { + containerBuilder.addAbbreviations(imp.name().value()); + } catch (IllegalArgumentException e) { + compilerContext.addIssue( + imp.id(), + CelIssue.formatError( + 1, 0, String.format("Error configuring import: %s", e.getMessage()))); + } + } + + extendedCel = extendedCel.toCelBuilder().setContainer(containerBuilder.build()).build(); + } + + CelCompiledRule compiledRule = compileRuleImpl(policy.rule(), extendedCel, compilerContext); + if (compilerContext.hasError()) { + throw new CelPolicyValidationException(compilerContext.getIssueString()); + } + + return compiledRule; + } + + @Override + public CelAbstractSyntaxTree compose(CelPolicy policy, CelCompiledRule compiledRule) + throws CelPolicyValidationException { + Cel cel = compiledRule.cel(); + CelOptimizer composingOptimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel) + .addAstOptimizers( + RuleComposer.newInstance(compiledRule, variablesPrefix, iterationLimit)) + .build(); + + CelAbstractSyntaxTree ast; + + try { + // This is a minimal expression used as a basis of stitching together all the rules into a + // single graph. + ast = cel.compile("true").getAst(); + ast = composingOptimizer.optimize(ast); + } catch (CelValidationException | CelOptimizationException e) { + if (e.getCause() instanceof RuleCompositionException) { + RuleCompositionException re = (RuleCompositionException) e.getCause(); + CompilerContext compilerContext = new CompilerContext(policy.policySource()); + // The exact CEL error message produced from composition failure isn't too useful for users. + // Ex: ERROR: :1:1: found no matching overload for '_?_:_' applied to '(bool, map(int, int), + // bool)' (candidates: (bool, %A0, %A0)) + // Transform the error messages in a user-friendly way while retaining the original + // CelValidationException as its originating cause. + + ImmutableList transformedIssues = + re.compileException.getErrors().stream() + .map(x -> CelIssue.formatError(x.getSourceLocation(), re.failureReason)) + .collect(toImmutableList()); + for (long id : re.errorIds) { + compilerContext.addIssue(id, transformedIssues); + } + + throw new CelPolicyValidationException(compilerContext.getIssueString(), re.getCause()); + } + + // Something has gone seriously wrong. + throw new CelPolicyValidationException("Unexpected error while composing rules.", e); + } + + CelOptimizer astOptimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(cel).addAstOptimizers(optimizers).build(); + try { + // Optimize the composed graph using const fold and CSE + ast = astOptimizer.optimize(ast); + } catch (CelOptimizationException e) { + throw new CelPolicyValidationException( + "Failed to optimize the composed policy. Reason: " + e.getMessage(), e); + } + + assertAstDepthIsSafe(ast, cel); + + return ast; + } + + private void assertAstDepthIsSafe(CelAbstractSyntaxTree ast, Cel cel) + throws CelPolicyValidationException { + if (!astDepthValidator.isPresent()) { + return; + } + CelValidator celValidator = + CelValidatorFactory.standardCelValidatorBuilder(cel) + .addAstValidators(astDepthValidator.get()) + .build(); + CelValidationResult result = celValidator.validate(ast); + if (result.hasError()) { + throw new CelPolicyValidationException(result.getErrorString()); + } + } + + private CelCompiledRule compileRuleImpl( + CelPolicy.Rule rule, Cel ruleCel, CompilerContext compilerContext) { + // A local CEL environment used to compile a single rule. This temporary environment + // is used to declare policy variables iteratively in a given policy, ensuring proper scoping + // across a single / nested rule. + Cel localCel = ruleCel; + ImmutableList.Builder variableBuilder = ImmutableList.builder(); + for (Variable variable : rule.variables()) { + ValueString expression = variable.expression(); + CelAbstractSyntaxTree varAst; + CelType outputType = SimpleType.DYN; + try { + varAst = localCel.compile(expression.value()).getAst(); + outputType = varAst.getResultType(); + } catch (CelValidationException e) { + compilerContext.addIssue(expression.id(), e.getErrors()); + // A sentinel AST representing an error is created to allow compiler checks to continue + varAst = newErrorAst(); + } + String variableName = variable.name().value(); + CelVarDecl newVariable = + CelVarDecl.newVarDeclaration(variablesPrefix + variableName, outputType); + localCel = localCel.toCelBuilder().addVarDeclarations(newVariable).build(); + variableBuilder.add(CelCompiledVariable.create(variableName, varAst, newVariable)); + } + + ImmutableList.Builder matchBuilder = ImmutableList.builder(); + for (Match match : rule.matches()) { + CelAbstractSyntaxTree conditionAst; + try { + conditionAst = localCel.compile(match.condition().value()).getAst(); + if (!conditionAst.getResultType().equals(SimpleType.BOOL)) { + compilerContext.addIssue( + match.condition().id(), + CelIssue.formatError(1, 0, "condition must produce a boolean output.")); + } + } catch (CelValidationException e) { + compilerContext.addIssue(match.condition().id(), e.getErrors()); + continue; + } + + Result matchResult; + switch (match.result().kind()) { + case OUTPUT: + CelAbstractSyntaxTree outputAst; + ValueString output = match.result().output(); + try { + outputAst = localCel.compile(output.value()).getAst(); + } catch (CelValidationException e) { + compilerContext.addIssue(output.id(), e.getErrors()); + continue; + } + + matchResult = Result.ofOutput(output.id(), outputAst); + break; + case RULE: + CelCompiledRule nestedRule = + compileRuleImpl(match.result().rule(), localCel, compilerContext); + matchResult = Result.ofRule(nestedRule); + break; + default: + throw new IllegalArgumentException("Unexpected kind: " + match.result().kind()); + } + + matchBuilder.add(CelCompiledMatch.create(match.id(), conditionAst, matchResult)); + } + + CelCompiledRule compiledRule = + CelCompiledRule.create( + rule.id(), rule.ruleId(), variableBuilder.build(), matchBuilder.build(), ruleCel); + + // Validate that all branches in the policy are reachable + checkUnreachableCode(compiledRule, compilerContext); + + return compiledRule; + } + + private void checkUnreachableCode(CelCompiledRule compiledRule, CompilerContext compilerContext) { + ImmutableList compiledMatches = compiledRule.matches(); + int matchCount = compiledMatches.size(); + for (int i = matchCount - 1; i >= 0; i--) { + CelCompiledMatch compiledMatch = compiledMatches.get(i); + boolean isTriviallyTrue = compiledMatch.isConditionTriviallyTrue(); + + // If the match is a single output or a nested rule that always returns a value, it is + // exhaustive. If the condition is trivially true, then all subsequent branches are + // unreachable. + boolean isExhaustive = + isTriviallyTrue + && (compiledMatch.result().kind().equals(Kind.OUTPUT) + || !compiledMatch.result().rule().hasOptionalOutput()); + + if (isExhaustive && i != matchCount - 1) { + if (compiledMatch.result().kind().equals(Kind.OUTPUT)) { + compilerContext.addIssue( + compiledMatch.sourceId(), + CelIssue.formatError(1, 0, "Match creates unreachable outputs")); + } else { + compilerContext.addIssue( + compiledMatch.result().rule().sourceId(), + CelIssue.formatError(1, 0, "Rule creates unreachable outputs")); + } + } + } + } + + private static CelAbstractSyntaxTree newErrorAst() { + return CelAbstractSyntaxTree.newParsedAst( + CelExpr.ofConstant(0, CelConstant.ofValue("*error*")), CelSource.newBuilder().build()); + } + + private static final class CompilerContext { + private final ArrayList issues; + private final CelPolicySource celPolicySource; + + private void addIssue(long id, CelIssue... issues) { + addIssue(id, Arrays.asList(issues)); + } + + private void addIssue(long id, List issues) { + for (CelIssue issue : issues) { + CelSourceLocation absoluteLocation = computeAbsoluteLocation(id, issue); + this.issues.add(CelIssue.formatError(absoluteLocation, issue.getMessage())); + } + } + + private CelSourceLocation computeAbsoluteLocation(long id, CelIssue issue) { + int policySourceOffset = + Optional.ofNullable(celPolicySource.getPositionsMap().get(id)).orElse(-1); + if (policySourceOffset == -1) { + return CelSourceLocation.NONE; + } + CelSourceLocation policySourceLocation = + celPolicySource.getOffsetLocation(policySourceOffset).orElse(null); + if (policySourceLocation == null) { + return CelSourceLocation.NONE; + } + + int absoluteLine = issue.getSourceLocation().getLine() + policySourceLocation.getLine() - 1; + int absoluteColumn = issue.getSourceLocation().getColumn() + policySourceLocation.getColumn(); + int absoluteOffset = celPolicySource.getContent().lineOffsets().get(absoluteLine - 2); + + return celPolicySource + .getOffsetLocation(absoluteOffset + absoluteColumn) + .orElse(CelSourceLocation.NONE); + } + + private boolean hasError() { + return !issues.isEmpty(); + } + + private String getIssueString() { + return CelIssue.toDisplayString(issues, celPolicySource); + } + + private CompilerContext(CelPolicySource celPolicySource) { + this.issues = new ArrayList<>(); + this.celPolicySource = celPolicySource; + } + } + + static final class Builder implements CelPolicyCompilerBuilder { + private final Cel cel; + private String variablesPrefix; + private int iterationLimit; + private ImmutableList optimizers; + private Optional astDepthLimitValidator; + + private Builder(Cel cel) { + this.cel = cel; + this.astDepthLimitValidator = Optional.of(AstDepthLimitValidator.DEFAULT); + } + + @Override + @CanIgnoreReturnValue + public Builder setVariablesPrefix(String prefix) { + this.variablesPrefix = checkNotNull(prefix); + return this; + } + + @Override + @CanIgnoreReturnValue + public Builder setIterationLimit(int iterationLimit) { + this.iterationLimit = iterationLimit; + return this; + } + + @Override + @CanIgnoreReturnValue + public Builder setAstDepthLimit(int astDepthLimit) { + if (astDepthLimit < 0) { + astDepthLimitValidator = Optional.empty(); + } else { + astDepthLimitValidator = Optional.of(AstDepthLimitValidator.newInstance(astDepthLimit)); + } + return this; + } + + @Override + public Builder setOptimizers(List optimizers) { + this.optimizers = ImmutableList.copyOf(optimizers); + return this; + } + + @Override + public CelPolicyCompiler build() { + return new CelPolicyCompilerImpl( + cel, this.variablesPrefix, this.iterationLimit, this.optimizers, astDepthLimitValidator); + } + } + + static Builder newBuilder(Cel cel) { + return new Builder(cel) + .setVariablesPrefix(DEFAULT_VARIABLE_PREFIX) + .setIterationLimit(DEFAULT_ITERATION_LIMIT) + .setOptimizers( + ImmutableList.of( + ConstantFoldingOptimizer.getInstance(), + SubexpressionOptimizer.newInstance( + SubexpressionOptimizerOptions.newBuilder().populateMacroCalls(true).build()))); + } + + private CelPolicyCompilerImpl( + Cel cel, + String variablesPrefix, + int iterationLimit, + ImmutableList optimizers, + Optional astDepthValidator) { + this.cel = checkNotNull(cel); + this.variablesPrefix = checkNotNull(variablesPrefix); + this.iterationLimit = iterationLimit; + this.optimizers = optimizers; + this.astDepthValidator = astDepthValidator; + } +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicyParser.java b/policy/src/main/java/dev/cel/policy/CelPolicyParser.java new file mode 100644 index 000000000..4a20188d5 --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicyParser.java @@ -0,0 +1,94 @@ +// Copyright 2024 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.policy; + +/** CelPolicyParser is the interface for parsing policies into a canonical Policy representation. */ +public interface CelPolicyParser { + + /** Parses the input {@code policySource} and returns a {@link CelPolicy}. */ + CelPolicy parse(String policySource) throws CelPolicyValidationException; + + /** + * Parses the input {@code policySource} and returns a {@link CelPolicy}. + * + *

The {@code description} may be used to help tailor error messages for the location where the + * {@code policySource} originates, e.g. a file name or form UI element. + */ + CelPolicy parse(String policySource, String description) throws CelPolicyValidationException; + + /** + * TagVisitor declares a set of interfaces for handling custom tags which would otherwise be + * unsupported within the policy, rule, match, or variable objects. + * + * @param Type of the node (ex: YAML). + */ + interface TagVisitor { + + /** + * visitPolicyTag accepts a parser context, field id, tag name, yaml node, and parent Policy to + * allow for continued parsing within a custom tag. + */ + default void visitPolicyTag( + PolicyParserContext ctx, + long id, + String tagName, + T node, + CelPolicy.Builder policyBuilder) { + ctx.reportError(id, String.format("Unsupported policy tag: %s", tagName)); + } + + /** + * visitRuleTag accepts a parser context, field id, tag name, yaml node, as well as the parent + * policy and current rule to allow for continued parsing within custom tags. + */ + default void visitRuleTag( + PolicyParserContext ctx, + long id, + String tagName, + T node, + CelPolicy.Builder policyBuilder, + CelPolicy.Rule.Builder ruleBuilder) { + ctx.reportError(id, String.format("Unsupported rule tag: %s", tagName)); + } + + /** + * visitMatchTag accepts a parser context, field id, tag name, yaml node, as well as the parent + * policy and current match to allow for continued parsing within custom tags. + */ + default void visitMatchTag( + PolicyParserContext ctx, + long id, + String tagName, + T node, + CelPolicy.Builder policyBuilder, + CelPolicy.Match.Builder matchBuilder) { + ctx.reportError(id, String.format("Unsupported match tag: %s", tagName)); + } + + /** + * visitVariableTag accepts a parser context, field id, tag name, yaml node, as well as the + * parent policy and current variable to allow for continued parsing within custom tags. + */ + default void visitVariableTag( + PolicyParserContext ctx, + long id, + String tagName, + T node, + CelPolicy.Builder policyBuilder, + CelPolicy.Variable.Builder variableBuilder) { + ctx.reportError(id, String.format("Unsupported variable tag: %s", tagName)); + } + } +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicyParserBuilder.java b/policy/src/main/java/dev/cel/policy/CelPolicyParserBuilder.java new file mode 100644 index 000000000..266264780 --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicyParserBuilder.java @@ -0,0 +1,59 @@ +// Copyright 2024 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.policy; + +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.policy.CelPolicyParser.TagVisitor; + +/** + * Interface for building an instance of {@link CelPolicyParser}. + * + * @param Type of the node (Ex: YAML). + */ +public interface CelPolicyParserBuilder { + + /** Adds a custom tag visitor to allow for handling of custom tags. */ + @CanIgnoreReturnValue + CelPolicyParserBuilder addTagVisitor(TagVisitor tagVisitor); + + /** + * Configures the parser to allow for key-value pairs to declare a variable name and expression. + * + *

For example: + * + * 

{@code
+   * variables:
+   * - foo: bar
+   * - baz: qux
+   * }
+ * + *

This is in contrast to the default behavior, which requires the following syntax: + * + * 

{@code
+   * variables:
+   * - name: foo
+   *   expression: bar
+   * - name: baz
+   *   expression: qux
+   * }
+ */ + @CanIgnoreReturnValue + CelPolicyParserBuilder enableSimpleVariables(boolean enable); + + /** Builds a new instance of {@link CelPolicyParser}. */ + @CheckReturnValue + CelPolicyParser build(); +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicyParserFactory.java b/policy/src/main/java/dev/cel/policy/CelPolicyParserFactory.java new file mode 100644 index 000000000..1c7ba225b --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicyParserFactory.java @@ -0,0 +1,31 @@ +// Copyright 2024 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.policy; + +import org.yaml.snakeyaml.nodes.Node; + +/** Factory class for producing policy parser and policy config parsers. */ +public final class CelPolicyParserFactory { + + /** + * Configure a builder to construct a {@link CelPolicyParser} instance that takes in a YAML + * document. + */ + public static CelPolicyParserBuilder newYamlParserBuilder() { + return CelPolicyYamlParser.newBuilder(); + } + + private CelPolicyParserFactory() {} +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicySource.java b/policy/src/main/java/dev/cel/policy/CelPolicySource.java new file mode 100644 index 000000000..2bf488bae --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicySource.java @@ -0,0 +1,78 @@ +// Copyright 2024 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.policy; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.CelSourceHelper; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.Source; +import dev.cel.common.internal.CelCodePointArray; +import java.util.Map; +import java.util.Optional; + +/** CelPolicySource represents the source content of a policy and its related metadata. */ +@AutoValue +public abstract class CelPolicySource implements Source { + + @Override + public abstract CelCodePointArray getContent(); + + @Override + public abstract String getDescription(); + + @Override + public abstract ImmutableMap getPositionsMap(); + + @Override + public Optional getSnippet(int line) { + return CelSourceHelper.getSnippet(getContent(), line); + } + + /** + * Get the line and column in the source expression text for the given code point {@code offset}. + */ + public Optional getOffsetLocation(int offset) { + return CelSourceHelper.getOffsetLocation(getContent(), offset); + } + + /** Builder for {@link CelPolicySource}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setContent(CelCodePointArray content); + + public abstract Builder setDescription(String description); + + public abstract Builder setPositionsMap(Map value); + + @CheckReturnValue + public abstract CelPolicySource build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder(String content) { + return newBuilder(CelCodePointArray.fromString(content)); + } + + public static Builder newBuilder(CelCodePointArray celCodePointArray) { + return new AutoValue_CelPolicySource.Builder() + .setDescription("") + .setContent(celCodePointArray) + .setPositionsMap(ImmutableMap.of()); + } +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicyValidationException.java b/policy/src/main/java/dev/cel/policy/CelPolicyValidationException.java new file mode 100644 index 000000000..4d52fcc1d --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicyValidationException.java @@ -0,0 +1,30 @@ +// Copyright 2024 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.policy; + +/** + * CelPolicyValidationException encapsulates all issues that arise when parsing or compiling a + * policy. + */ +public final class CelPolicyValidationException extends Exception { + + public CelPolicyValidationException(String message) { + super(message); + } + + public CelPolicyValidationException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/policy/src/main/java/dev/cel/policy/CelPolicyYamlParser.java b/policy/src/main/java/dev/cel/policy/CelPolicyYamlParser.java new file mode 100644 index 000000000..18b406af0 --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/CelPolicyYamlParser.java @@ -0,0 +1,498 @@ +// Copyright 2024 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.policy; + +import static com.google.common.base.Preconditions.checkNotNull; +import static dev.cel.common.formats.YamlHelper.ERROR; +import static dev.cel.common.formats.YamlHelper.assertRequiredFields; +import static dev.cel.common.formats.YamlHelper.assertYamlType; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelIssue; +import dev.cel.common.formats.ParserContext; +import dev.cel.common.formats.ValueString; +import dev.cel.common.formats.YamlHelper; +import dev.cel.common.formats.YamlHelper.YamlNodeType; +import dev.cel.common.formats.YamlParserContextImpl; +import dev.cel.common.internal.CelCodePointArray; +import dev.cel.policy.CelPolicy.Import; +import dev.cel.policy.CelPolicy.Match; +import dev.cel.policy.CelPolicy.Match.Result; +import dev.cel.policy.CelPolicy.Variable; +import java.util.List; +import java.util.Map; +import org.yaml.snakeyaml.nodes.MappingNode; +import org.yaml.snakeyaml.nodes.Node; +import org.yaml.snakeyaml.nodes.NodeTuple; +import org.yaml.snakeyaml.nodes.ScalarNode; +import org.yaml.snakeyaml.nodes.SequenceNode; + +final class CelPolicyYamlParser implements CelPolicyParser { + + // Sentinel values for parsing errors + private static final ValueString ERROR_VALUE = ValueString.newBuilder().setValue(ERROR).build(); + private static final Match ERROR_MATCH = + Match.newBuilder(0).setCondition(ERROR_VALUE).setResult(Result.ofOutput(ERROR_VALUE)).build(); + private static final Variable ERROR_VARIABLE = + Variable.newBuilder().setExpression(ERROR_VALUE).setName(ERROR_VALUE).build(); + + private final TagVisitor tagVisitor; + private final boolean enableSimpleVariables; + + @Override + public CelPolicy parse(String policySource) throws CelPolicyValidationException { + return parse(policySource, ""); + } + + @Override + public CelPolicy parse(String policySource, String description) + throws CelPolicyValidationException { + ParserImpl parser = + new ParserImpl(tagVisitor, enableSimpleVariables, policySource, description); + return parser.parseYaml(); + } + + private static class ParserImpl implements PolicyParserContext { + + private final TagVisitor tagVisitor; + private final boolean enableSimpleVariables; + private final CelPolicySource policySource; + private final ParserContext ctx; + + private CelPolicy parseYaml() throws CelPolicyValidationException { + Node node; + String policySourceString = policySource.getContent().toString(); + try { + Node yamlNode = + YamlHelper.parseYamlSource(policySourceString) + .orElseThrow( + () -> + new CelPolicyValidationException( + String.format( + "YAML document empty or malformed: %s", policySourceString))); + node = yamlNode; + } catch (RuntimeException e) { + throw new CelPolicyValidationException("YAML document is malformed: " + e.getMessage(), e); + } + + CelPolicy celPolicy = parsePolicy(this, node); + + if (!ctx.getIssues().isEmpty()) { + throw new CelPolicyValidationException( + CelIssue.toDisplayString(ctx.getIssues(), celPolicy.policySource())); + } + + return celPolicy; + } + + @Override + public NewPolicyMetadata newPolicy(Node node) { + long id = ctx.collectMetadata(node); + return NewPolicyMetadata.create(policySource, id); + } + + @Override + public CelPolicy parsePolicy(PolicyParserContext ctx, Node node) { + NewPolicyMetadata newPolicyMetadata = newPolicy(node); + CelPolicy.Builder policyBuilder = newPolicyMetadata.policyBuilder(); + if (!assertYamlType(ctx, newPolicyMetadata.id(), node, YamlNodeType.MAP)) { + return policyBuilder.build(); + } + + MappingNode rootNode = (MappingNode) node; + for (NodeTuple nodeTuple : rootNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "imports": + parseImports(policyBuilder, ctx, valueNode); + break; + case "name": + policyBuilder.setName(ctx.newYamlString(valueNode)); + break; + case "description": + policyBuilder.setDescription(ctx.newYamlString(valueNode)); + break; + case "display_name": + policyBuilder.setDisplayName(ctx.newYamlString(valueNode)); + break; + case "rule": + policyBuilder.setRule(parseRule(ctx, policyBuilder, valueNode)); + break; + default: + tagVisitor.visitPolicyTag(ctx, keyId, fieldName, valueNode, policyBuilder); + break; + } + } + + return policyBuilder + .setPolicySource(policySource.toBuilder().setPositionsMap(ctx.getIdToOffsetMap()).build()) + .build(); + } + + private void parseImports( + CelPolicy.Builder policyBuilder, PolicyParserContext ctx, Node node) { + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.LIST)) { + return; + } + + SequenceNode importListNode = (SequenceNode) node; + for (Node importNode : importListNode.getValue()) { + parseImport(policyBuilder, ctx, importNode); + } + } + + private void parseImport( + CelPolicy.Builder policyBuilder, PolicyParserContext ctx, Node node) { + long importId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, importId, node, YamlNodeType.MAP)) { + return; + } + + MappingNode mappingNode = (MappingNode) node; + for (NodeTuple nodeTuple : mappingNode.getValue()) { + Node key = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(key); + if (!assertYamlType(ctx, keyId, key, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + + String fieldName = ((ScalarNode) key).getValue(); + if (!fieldName.equals("name")) { + ctx.reportError( + keyId, String.format("Invalid import key: %s, expected 'name'", fieldName)); + continue; + } + + Node value = nodeTuple.getValueNode(); + long valueId = ctx.collectMetadata(value); + if (!assertYamlType(ctx, valueId, value, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + + policyBuilder.addImport(Import.create(valueId, ctx.newYamlString(value))); + } + } + + @Override + public CelPolicy.Rule parseRule( + PolicyParserContext ctx, CelPolicy.Builder policyBuilder, Node node) { + long valueId = ctx.collectMetadata(node); + CelPolicy.Rule.Builder ruleBuilder = CelPolicy.Rule.newBuilder(valueId); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.MAP)) { + return ruleBuilder.build(); + } + + for (NodeTuple nodeTuple : ((MappingNode) node).getValue()) { + Node key = nodeTuple.getKeyNode(); + long tagId = ctx.collectMetadata(key); + if (!assertYamlType(ctx, tagId, key, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + String fieldName = ((ScalarNode) key).getValue(); + Node value = nodeTuple.getValueNode(); + switch (fieldName) { + case "id": + ruleBuilder.setRuleId(ctx.newYamlString(value)); + break; + case "description": + ruleBuilder.setDescription(ctx.newYamlString(value)); + break; + case "variables": + ruleBuilder.addVariables(parseVariables(ctx, policyBuilder, value)); + break; + case "match": + ruleBuilder.addMatches(parseMatches(ctx, policyBuilder, value)); + break; + default: + tagVisitor.visitRuleTag(ctx, tagId, fieldName, value, policyBuilder, ruleBuilder); + break; + } + } + return ruleBuilder.build(); + } + + private ImmutableSet parseMatches( + PolicyParserContext ctx, CelPolicy.Builder policyBuilder, Node node) { + long valueId = ctx.collectMetadata(node); + ImmutableSet.Builder matchesBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + return matchesBuilder.build(); + } + + SequenceNode matchListNode = (SequenceNode) node; + for (Node elementNode : matchListNode.getValue()) { + matchesBuilder.add(parseMatch(ctx, policyBuilder, elementNode)); + } + + return matchesBuilder.build(); + } + + @Override + public CelPolicy.Match parseMatch( + PolicyParserContext ctx, CelPolicy.Builder policyBuilder, Node node) { + long nodeId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, nodeId, node, YamlNodeType.MAP)) { + return ERROR_MATCH; + } + MappingNode matchNode = (MappingNode) node; + CelPolicy.Match.Builder matchBuilder = + CelPolicy.Match.newBuilder(nodeId).setCondition(ValueString.of(ctx.nextId(), "true")); + for (NodeTuple nodeTuple : matchNode.getValue()) { + Node key = nodeTuple.getKeyNode(); + long tagId = ctx.collectMetadata(key); + if (!assertYamlType(ctx, tagId, key, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + String fieldName = ((ScalarNode) key).getValue(); + Node value = nodeTuple.getValueNode(); + switch (fieldName) { + case "condition": + matchBuilder.setCondition(ctx.newSourceString(value)); + break; + case "output": + matchBuilder + .result() + .filter(result -> result.kind().equals(Match.Result.Kind.RULE)) + .ifPresent( + result -> ctx.reportError(tagId, "Only the rule or the output may be set")); + matchBuilder.setResult(Match.Result.ofOutput(ctx.newSourceString(value))); + break; + case "explanation": + matchBuilder + .result() + .filter(result -> result.kind().equals(Match.Result.Kind.RULE)) + .ifPresent( + result -> + ctx.reportError( + tagId, + "Explanation can only be set on output match cases, not nested rules")); + matchBuilder.setExplanation(ctx.newYamlString(value)); + break; + case "rule": + matchBuilder + .result() + .filter(result -> result.kind().equals(Match.Result.Kind.OUTPUT)) + .ifPresent( + result -> ctx.reportError(tagId, "Only the rule or the output may be set")); + matchBuilder + .explanation() + .ifPresent( + result -> + ctx.reportError( + result.id(), + "Explanation can only be set on output match cases, not nested rules")); + matchBuilder.setResult(Match.Result.ofRule(parseRule(ctx, policyBuilder, value))); + break; + default: + tagVisitor.visitMatchTag(ctx, tagId, fieldName, value, policyBuilder, matchBuilder); + break; + } + } + + if (!assertRequiredFields(ctx, nodeId, matchBuilder.getMissingRequiredFieldNames())) { + return ERROR_MATCH; + } + + return matchBuilder.build(); + } + + private ImmutableSet parseVariables( + PolicyParserContext ctx, CelPolicy.Builder policyBuilder, Node node) { + long valueId = ctx.collectMetadata(node); + ImmutableSet.Builder variableBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + return variableBuilder.build(); + } + + SequenceNode variableListNode = (SequenceNode) node; + for (Node elementNode : variableListNode.getValue()) { + variableBuilder.add(parseVariable(ctx, policyBuilder, elementNode)); + } + + return variableBuilder.build(); + } + + @Override + public CelPolicy.Variable parseVariable( + PolicyParserContext ctx, CelPolicy.Builder policyBuilder, Node node) { + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) { + return ERROR_VARIABLE; + } + + MappingNode variableMap = (MappingNode) node; + Variable.Builder builder = Variable.newBuilder(); + + if (enableSimpleVariables) { + return parseVariableInline(ctx, id, variableMap, builder); + } + return parseVariableObject(ctx, policyBuilder, id, variableMap, builder); + } + + private Variable parseVariableInline( + PolicyParserContext ctx, long id, MappingNode variableMap, Variable.Builder builder) { + int iterations = 0; + for (NodeTuple nodeTuple : variableMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + builder + .setName(ctx.newYamlString(keyNode)) + .setExpression(ctx.newSourceString(nodeTuple.getValueNode())); + iterations++; + + if (iterations > 1) { + ctx.reportError(keyId, "Only one variable may be defined inline"); + } + } + + if (!assertRequiredFields(ctx, id, builder.getMissingRequiredFieldNames())) { + return ERROR_VARIABLE; + } + + return builder.build(); + } + + private Variable parseVariableObject( + PolicyParserContext ctx, + CelPolicy.Builder policyBuilder, + long id, + MappingNode variableMap, + Variable.Builder builder) { + for (NodeTuple nodeTuple : variableMap.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String keyName = ((ScalarNode) keyNode).getValue(); + switch (keyName) { + case "name": + builder.setName(ctx.newYamlString(valueNode)); + break; + case "expression": + builder.setExpression(ctx.newSourceString(valueNode)); + break; + case "description": + builder.setDescription(ctx.newYamlString(valueNode)); + break; + case "display_name": + builder.setDisplayName(ctx.newYamlString(valueNode)); + break; + default: + tagVisitor.visitVariableTag(ctx, keyId, keyName, valueNode, policyBuilder, builder); + break; + } + } + + if (!assertRequiredFields(ctx, id, builder.getMissingRequiredFieldNames())) { + return ERROR_VARIABLE; + } + + return builder.build(); + } + + private ParserImpl( + TagVisitor tagVisitor, + boolean enableSimpleVariables, + String source, + String description) { + this.tagVisitor = tagVisitor; + this.enableSimpleVariables = enableSimpleVariables; + this.policySource = + CelPolicySource.newBuilder(CelCodePointArray.fromString(source)) + .setDescription(description) + .build(); + this.ctx = YamlParserContextImpl.newInstance(policySource); + } + + @Override + public long nextId() { + return ctx.nextId(); + } + + @Override + public long collectMetadata(Node node) { + return ctx.collectMetadata(node); + } + + @Override + public void reportError(long id, String message) { + ctx.reportError(id, message); + } + + @Override + public List getIssues() { + return ctx.getIssues(); + } + + @Override + public Map getIdToOffsetMap() { + return ctx.getIdToOffsetMap(); + } + + @Override + public ValueString newYamlString(Node node) { + return ctx.newYamlString(node); + } + + @Override + public ValueString newSourceString(Node node) { + return ctx.newSourceString(node); + } + } + + static final class Builder implements CelPolicyParserBuilder { + + private TagVisitor tagVisitor; + private boolean enableSimpleVariables; + + private Builder() { + this.tagVisitor = new TagVisitor() {}; + this.enableSimpleVariables = false; + } + + @Override + public CelPolicyParserBuilder addTagVisitor(TagVisitor tagVisitor) { + this.tagVisitor = tagVisitor; + return this; + } + + @Override + public CelPolicyParserBuilder enableSimpleVariables(boolean enable) { + this.enableSimpleVariables = enable; + return this; + } + + @Override + public CelPolicyParser build() { + return new CelPolicyYamlParser(tagVisitor, enableSimpleVariables); + } + } + + static CelPolicyParserBuilder newBuilder() { + return new Builder().enableSimpleVariables(false); + } + + private CelPolicyYamlParser(TagVisitor tagVisitor, boolean enableSimpleVariables) { + this.tagVisitor = checkNotNull(tagVisitor); + this.enableSimpleVariables = enableSimpleVariables; + } +} diff --git a/policy/src/main/java/dev/cel/policy/PolicyParserContext.java b/policy/src/main/java/dev/cel/policy/PolicyParserContext.java new file mode 100644 index 000000000..204bf591f --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/PolicyParserContext.java @@ -0,0 +1,54 @@ +// Copyright 2025 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.policy; + +import com.google.auto.value.AutoValue; +import dev.cel.common.formats.ParserContext; +import dev.cel.policy.CelPolicy.Match; +import dev.cel.policy.CelPolicy.Rule; +import dev.cel.policy.CelPolicy.Variable; + +/** + * PolicyParserContext declares a set of interfaces for creating and managing metadata specifically + * for {@link CelPolicy}. + */ +public interface PolicyParserContext extends ParserContext { + + /** + * Wrapper for a new instance of {@link CelPolicy.Builder} and the associated node ID. The + * CelPolicy builder also has a policy source set by the parser. + */ + @AutoValue + abstract class NewPolicyMetadata { + public abstract CelPolicy.Builder policyBuilder(); + + public abstract long id(); + + static NewPolicyMetadata create(CelPolicySource source, long id) { + return new AutoValue_PolicyParserContext_NewPolicyMetadata( + CelPolicy.newBuilder().setPolicySource(source), id); + } + } + + NewPolicyMetadata newPolicy(T node); + + CelPolicy parsePolicy(PolicyParserContext ctx, T node); + + Rule parseRule(PolicyParserContext ctx, CelPolicy.Builder policyBuilder, T node); + + Match parseMatch(PolicyParserContext ctx, CelPolicy.Builder policyBuilder, T node); + + Variable parseVariable(PolicyParserContext ctx, CelPolicy.Builder policyBuilder, T node); +} diff --git a/policy/src/main/java/dev/cel/policy/RequiredFieldsChecker.java b/policy/src/main/java/dev/cel/policy/RequiredFieldsChecker.java new file mode 100644 index 000000000..e46b2822a --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/RequiredFieldsChecker.java @@ -0,0 +1,49 @@ +// Copyright 2024 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.policy; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import java.util.Optional; +import java.util.function.Supplier; + +/** + * Interface to be implemented on a builder that can be used to verify all required fields being + * set. + */ +interface RequiredFieldsChecker { + + ImmutableList requiredFields(); + + default ImmutableList getMissingRequiredFieldNames() { + return requiredFields().stream() + .filter(entry -> !entry.fieldValue().get().isPresent()) + .map(RequiredField::displayName) + .collect(toImmutableList()); + } + + @AutoValue + abstract class RequiredField { + abstract String displayName(); + + abstract Supplier> fieldValue(); + + static RequiredField of(String displayName, Supplier> fieldValue) { + return new AutoValue_RequiredFieldsChecker_RequiredField(displayName, fieldValue); + } + } +} diff --git a/policy/src/main/java/dev/cel/policy/RuleComposer.java b/policy/src/main/java/dev/cel/policy/RuleComposer.java new file mode 100644 index 000000000..73d31a4ee --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/RuleComposer.java @@ -0,0 +1,382 @@ +// Copyright 2024 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.policy; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableList.toImmutableList; +import static java.util.stream.Collectors.toCollection; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelMutableAst; +import dev.cel.common.CelMutableSource; +import dev.cel.common.CelValidationException; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelMutableExpr; +import dev.cel.common.formats.ValueString; +import dev.cel.common.navigation.CelNavigableMutableAst; +import dev.cel.common.navigation.CelNavigableMutableExpr; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypes; +import dev.cel.extensions.CelOptionalLibrary.Function; +import dev.cel.optimizer.AstMutator; +import dev.cel.optimizer.CelAstOptimizer; +import dev.cel.policy.CelCompiledRule.CelCompiledMatch; +import dev.cel.policy.CelCompiledRule.CelCompiledMatch.OutputValue; +import dev.cel.policy.CelCompiledRule.CelCompiledMatch.Result; +import dev.cel.policy.CelCompiledRule.CelCompiledVariable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** Package-private class for composing various rules into a single expression using optimizer. */ +final class RuleComposer implements CelAstOptimizer { + private final CelCompiledRule compiledRule; + private final String variablePrefix; + private final AstMutator astMutator; + + @Override + public OptimizationResult optimize(CelAbstractSyntaxTree ast, Cel cel) { + Step result = optimizeRule(cel, compiledRule); + return OptimizationResult.create(result.expr.toParsedAst()); + } + + private Step optimizeRule(Cel cel, CelCompiledRule compiledRule) { + cel = + cel.toCelBuilder() + .addVarDeclarations( + compiledRule.variables().stream() + .map(CelCompiledVariable::celVarDecl) + .collect(toImmutableList())) + .build(); + + Step output = null; + // If the rule has an optional output, the last result in the ternary should return + // `optional.none`. This output is implicit and created here to reflect the desired + // last possible output of this type of rule. + if (compiledRule.hasOptionalOutput()) { + output = + Step.newUnconditionalOptionalStep( + newTrueLiteral(), astMutator.newGlobalCall(Function.OPTIONAL_NONE.getFunction())); + } + + long lastOutputId = 0; + // The expected output type of the rule, used to verify that all branches agree on the type. + CelType lastOutputType = null; + for (CelCompiledMatch match : Lists.reverse(compiledRule.matches())) { + CelAbstractSyntaxTree conditionAst = match.condition(); + boolean isTriviallyTrue = match.isConditionTriviallyTrue(); + CelMutableAst condAst = CelMutableAst.fromCelAst(conditionAst); + + long currentSourceId = lastOutputId; + + switch (match.result().kind()) { + case OUTPUT: + // If the match has an output, then it is considered a non-optional output since + // it is explicitly stated. If the rule itself is optional, then the base case value + // of output being optional.none() will convert the non-optional value to an optional + // one. + OutputValue matchOutput = match.result().output(); + Step step = + Step.newNonOptionalStep( + !isTriviallyTrue, condAst, CelMutableAst.fromCelAst(matchOutput.ast())); + currentSourceId = matchOutput.sourceId(); + + output = combine(astMutator, step, output); + + String outputFailureMessage = + String.format( + "incompatible output types: block has output type %s, but previous outputs have" + + " type %s", + lastOutputType == null ? "" : CelTypes.format(lastOutputType), + CelTypes.format(matchOutput.ast().getResultType())); + lastOutputType = + assertComposedAstIsValid( + cel, output.expr, outputFailureMessage, currentSourceId, lastOutputId) + .getResultType(); + + break; + case RULE: + // If the match has a nested rule, then compute the rule and whether it has + // an optional return value. + CelCompiledRule matchNestedRule = match.result().rule(); + Step nestedRule = optimizeRule(cel, matchNestedRule); + Step ruleStep = + new Step( + matchNestedRule.hasOptionalOutput(), !isTriviallyTrue, condAst, nestedRule.expr); + currentSourceId = getFirstOutputSourceId(matchNestedRule); + + output = combine(astMutator, ruleStep, output); + + lastOutputType = + assertComposedAstIsValid( + cel, + output.expr, + String.format( + "failed composing the subrule '%s' due to incompatible output types.", + matchNestedRule.ruleId().map(ValueString::value).orElse("")), + currentSourceId, + lastOutputId) + .getResultType(); + break; + } + + lastOutputId = currentSourceId; + } + + Preconditions.checkState(output != null, "Policy contains no outputs."); + CelMutableAst resultExpr = output.expr; + resultExpr = inlineCompiledVariables(resultExpr, compiledRule.variables()); + resultExpr = astMutator.renumberIdsConsecutively(resultExpr); + + return output.isOptional + ? Step.newUnconditionalOptionalStep(newTrueLiteral(), resultExpr) + : Step.newUnconditionalNonOptionalStep(newTrueLiteral(), resultExpr); + } + + static RuleComposer newInstance( + CelCompiledRule compiledRule, String variablePrefix, int iterationLimit) { + return new RuleComposer(compiledRule, variablePrefix, iterationLimit); + } + + // Assembles two output expressions into a single output step. + private Step combine(AstMutator astMutator, Step currentStep, Step accumulatedStep) { + if (accumulatedStep == null) { + return currentStep; + } + CelMutableAst trueCondition = newTrueLiteral(); + + if (currentStep.isOptional) { + return combineWhenCurrentIsOptional(currentStep, accumulatedStep, astMutator, trueCondition); + } else { + return combineWhenCurrentIsNonOptional( + currentStep, accumulatedStep, astMutator, trueCondition); + } + } + + private Step combineWhenCurrentIsOptional( + Step currentStep, Step accumulatedStep, AstMutator astMutator, CelMutableAst trueCondition) { + // optional.combine(optional) // optional + // (optional && conditional).combine(non-optional) // optional + // (optional && unconditional).combine(non-optional) // non-optional + if (accumulatedStep.isOptional) { + if (currentStep.isConditional) { + return Step.newUnconditionalOptionalStep( + trueCondition, + astMutator.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + currentStep.cond, + currentStep.expr, + accumulatedStep.expr)); + } else { + if (!isOptionalNone(accumulatedStep.expr)) { + // If either the nested rule or current condition output are optional then + // use optional.or() to specify the combination of the first and second results + // Note, the argument order is reversed due to the traversal of matches in + // reverse order. + return Step.newUnconditionalOptionalStep( + trueCondition, + astMutator.newMemberCall(currentStep.expr, "or", accumulatedStep.expr)); + } + return currentStep; + } + } else { // accumulatedStep is non-optional + if (currentStep.isConditional) { + return Step.newUnconditionalOptionalStep( + trueCondition, + astMutator.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + currentStep.cond, + currentStep.expr, + astMutator.newGlobalCall( + Function.OPTIONAL_OF.getFunction(), accumulatedStep.expr))); + } else { + return Step.newUnconditionalNonOptionalStep( + trueCondition, + astMutator.newMemberCall(currentStep.expr, "orValue", accumulatedStep.expr)); + } + } + } + + private Step combineWhenCurrentIsNonOptional( + Step currentStep, Step accumulatedStep, AstMutator astMutator, CelMutableAst trueCondition) { + // non-optional.combine(non-optional) // non-optional + // (non-optional && conditional).combine(optional) // optional + // (non-optional && unconditional).combine(optional) // non-optional + // + // The last combination case is unusual, but effectively it means that the non-optional value + // prunes away + // the potential optional output. + if (accumulatedStep.isOptional) { + if (currentStep.isConditional) { + return Step.newUnconditionalOptionalStep( + trueCondition, + astMutator.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + currentStep.cond, + astMutator.newGlobalCall(Function.OPTIONAL_OF.getFunction(), currentStep.expr), + accumulatedStep.expr)); + } else { + // If the condition is trivially true, none of the matches in the rule causes the result + // to become optional, and the rule is not the last match, then this will introduce + // unreachable outputs or rules (pruning away 'accumulatedStep'). + return currentStep; + } + } else { // accumulatedStep is non-optional + return Step.newUnconditionalNonOptionalStep( + trueCondition, + astMutator.newGlobalCall( + Operator.CONDITIONAL.getFunction(), + currentStep.cond, + currentStep.expr, + accumulatedStep.expr)); + } + } + + private static boolean isOptionalNone(CelMutableAst ast) { + CelMutableExpr expr = ast.expr(); + return expr.getKind().equals(Kind.CALL) + && expr.call().function().equals("optional.none") + && expr.call().args().isEmpty(); + } + + private static CelMutableAst newTrueLiteral() { + return CelMutableAst.of( + CelMutableExpr.ofConstant(CelConstant.ofValue(true)), CelMutableSource.newInstance()); + } + + private CelMutableAst inlineCompiledVariables( + CelMutableAst ast, List compiledVariables) { + CelMutableAst mutatedAst = ast; + for (CelCompiledVariable compiledVariable : Lists.reverse(compiledVariables)) { + String variableName = variablePrefix + compiledVariable.name(); + ImmutableList exprsToReplace = + CelNavigableMutableAst.fromAst(mutatedAst) + .getRoot() + .allNodes() + .filter( + node -> + node.expr().getKind().equals(Kind.IDENT) + && node.expr().ident().name().equals(variableName)) + .collect(toImmutableList()); + + for (CelNavigableMutableExpr expr : exprsToReplace) { + CelMutableAst variableAst = CelMutableAst.fromCelAst(compiledVariable.ast()); + mutatedAst = astMutator.replaceSubtree(mutatedAst, variableAst, expr.id()); + } + } + + return mutatedAst; + } + + private CelAbstractSyntaxTree assertComposedAstIsValid( + Cel cel, CelMutableAst composedAst, String failureMessage, Long... ids) { + return assertComposedAstIsValid(cel, composedAst, failureMessage, Arrays.asList(ids)); + } + + private CelAbstractSyntaxTree assertComposedAstIsValid( + Cel cel, CelMutableAst composedAst, String failureMessage, List ids) { + try { + return cel.check(composedAst.toParsedAst()).getAst(); + } catch (CelValidationException e) { + ids = ids.stream().filter(id -> id > 0).collect(toCollection(ArrayList::new)); + throw new RuleCompositionException(failureMessage, e, ids); + } + } + + private static long getFirstOutputSourceId(CelCompiledRule rule) { + for (CelCompiledMatch match : rule.matches()) { + if (match.result().kind() == Result.Kind.OUTPUT) { + return match.result().output().sourceId(); + } else if (match.result().kind() == Result.Kind.RULE) { + return getFirstOutputSourceId(match.result().rule()); + } + } + + // Fallback to the nested rule ID if the policy is invalid and contains no output + return rule.sourceId(); + } + + // Step represents an intermediate stage of rule and match expression composition. + // + // The CelCompiledRule and CelCompiledMatch types are meant to represent standalone tuples of + // condition and output expressions, and have no notion of how the order of combination would + // impact composition since composition rules may vary based on the policy execution semantic, + // e.g. first-match versus logical-or, logical-and, or accumulation. + private static class Step { + /** + * Indicates whether the output step has an optional result. Individual conditional attributes + * are not optional; however, rules and subrules can have optional output. + */ + private final boolean isOptional; + + /** True if the condition expression is not trivially true. */ + private final boolean isConditional; + + /** The condition associated with the output. */ + private final CelMutableAst cond; + + /** The output expression for the step. */ + private final CelMutableAst expr; + + private Step( + boolean isOptional, boolean isConditional, CelMutableAst cond, CelMutableAst expr) { + this.isOptional = isOptional; + this.isConditional = isConditional; + this.cond = cond; + this.expr = expr; + } + + private static Step newNonOptionalStep( + boolean isConditional, CelMutableAst cond, CelMutableAst expr) { + return new Step(/* isOptional= */ false, isConditional, cond, expr); + } + + private static Step newUnconditionalOptionalStep( + CelMutableAst trueCondition, CelMutableAst expr) { + return new Step(/* isOptional= */ true, /* isConditional= */ false, trueCondition, expr); + } + + private static Step newUnconditionalNonOptionalStep( + CelMutableAst trueCondition, CelMutableAst expr) { + return new Step(/* isOptional= */ false, /* isConditional= */ false, trueCondition, expr); + } + } + + static final class RuleCompositionException extends RuntimeException { + final String failureReason; + final List errorIds; + final CelValidationException compileException; + + private RuleCompositionException( + String failureReason, CelValidationException e, List errorIds) { + super(e); + this.failureReason = failureReason; + this.errorIds = errorIds; + this.compileException = e; + } + } + + private RuleComposer(CelCompiledRule compiledRule, String variablePrefix, int iterationLimit) { + this.compiledRule = checkNotNull(compiledRule); + this.variablePrefix = variablePrefix; + this.astMutator = AstMutator.newInstance(iterationLimit); + } +} diff --git a/policy/src/main/java/dev/cel/policy/testing/BUILD.bazel b/policy/src/main/java/dev/cel/policy/testing/BUILD.bazel new file mode 100644 index 000000000..3a8a4950b --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/testing/BUILD.bazel @@ -0,0 +1,27 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//policy/testing:__pkg__", + ], +) + +java_library( + name = "k8s_tag_handler", + srcs = ["K8sTagHandler.java"], + tags = [ + ], + deps = [ + "//common/formats:value_string", + "//common/formats:yaml_helper", + "//policy", + "//policy:parser", + "//policy:policy_parser_context", + "@maven//:com_google_guava_guava", + "@maven//:org_yaml_snakeyaml", + ], +) diff --git a/policy/src/main/java/dev/cel/policy/testing/K8sTagHandler.java b/policy/src/main/java/dev/cel/policy/testing/K8sTagHandler.java new file mode 100644 index 000000000..04635e054 --- /dev/null +++ b/policy/src/main/java/dev/cel/policy/testing/K8sTagHandler.java @@ -0,0 +1,117 @@ +// 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.policy.testing; + +import com.google.common.annotations.VisibleForTesting; +import dev.cel.common.formats.ValueString; +import dev.cel.common.formats.YamlHelper; +import dev.cel.common.formats.YamlHelper.YamlNodeType; +import dev.cel.policy.CelPolicy; +import dev.cel.policy.CelPolicy.Match; +import dev.cel.policy.CelPolicyParser.TagVisitor; +import dev.cel.policy.PolicyParserContext; +import org.yaml.snakeyaml.nodes.Node; +import org.yaml.snakeyaml.nodes.SequenceNode; + +/** + * K8sTagHandler is a {@link TagVisitor} implementation to support parsing Kubernetes + * ValidatingAdmissionPolicy structures in testing and conformance environments. + */ +@VisibleForTesting +public final class K8sTagHandler implements TagVisitor { + + @Override + public void visitPolicyTag( + PolicyParserContext ctx, + long id, + String tagName, + Node node, + CelPolicy.Builder policyBuilder) { + switch (tagName) { + case "kind": + policyBuilder.putMetadata("kind", ctx.newYamlString(node).value()); + break; + case "metadata": + YamlHelper.assertYamlType(ctx, id, node, YamlNodeType.MAP); + break; + case "spec": + CelPolicy.Rule spec = ctx.parseRule(ctx, policyBuilder, node); + policyBuilder.setRule(spec); + break; + default: + TagVisitor.super.visitPolicyTag(ctx, id, tagName, node, policyBuilder); + break; + } + } + + @Override + public void visitRuleTag( + PolicyParserContext ctx, + long id, + String tagName, + Node node, + CelPolicy.Builder policyBuilder, + CelPolicy.Rule.Builder ruleBuilder) { + switch (tagName) { + case "failurePolicy": + policyBuilder.putMetadata(tagName, ctx.newYamlString(node).value()); + break; + case "matchConstraints": + YamlHelper.assertYamlType(ctx, id, node, YamlNodeType.MAP); + break; + case "validations": + if (!YamlHelper.assertYamlType(ctx, id, node, YamlNodeType.LIST)) { + return; + } + SequenceNode seqNode = (SequenceNode) node; + for (Node valNode : seqNode.getValue()) { + ruleBuilder.addMatches(ctx.parseMatch(ctx, policyBuilder, valNode)); + } + break; + default: + TagVisitor.super.visitRuleTag(ctx, id, tagName, node, policyBuilder, ruleBuilder); + break; + } + } + + @Override + public void visitMatchTag( + PolicyParserContext ctx, + long id, + String tagName, + Node node, + CelPolicy.Builder policyBuilder, + CelPolicy.Match.Builder matchBuilder) { + if (!matchBuilder.result().isPresent()) { + matchBuilder.setResult( + Match.Result.ofOutput(ValueString.of(ctx.nextId(), "'invalid admission request'"))); + } + switch (tagName) { + case "expression": + // The K8s expression to validate must return false in order to generate a violation + // message. + ValueString condition = ctx.newSourceString(node); + String invertedCondition = "!(" + condition.value() + ")"; + matchBuilder.setCondition(ValueString.of(condition.id(), invertedCondition)); + break; + case "messageExpression": + matchBuilder.setResult(Match.Result.ofOutput(ctx.newSourceString(node))); + break; + default: + TagVisitor.super.visitMatchTag(ctx, id, tagName, node, policyBuilder, matchBuilder); + break; + } + } +} diff --git a/policy/src/test/java/dev/cel/policy/BUILD.bazel b/policy/src/test/java/dev/cel/policy/BUILD.bazel new file mode 100644 index 000000000..5157e0c74 --- /dev/null +++ b/policy/src/test/java/dev/cel/policy/BUILD.bazel @@ -0,0 +1,65 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob( + ["*.java"], + ), + data = [ + "@cel_policy//conformance:testdata", + ], + resources = [ + "//testing:policy_test_resources", + ], + deps = [ + "//:java_truth", + "//bundle:cel", + "//bundle:environment", + "//bundle:environment_yaml_parser", + "//common:cel_ast", + "//common:options", + "//common/formats:value_string", + "//common/internal", + "//common/resources/testdata/proto3:standalone_global_enum_java_proto", + "//common/types", + "//compiler", + "//extensions:optional_library", + "//parser:macro", + "//parser:parser_factory", + "//parser:unparser", + "//policy", + "//policy:compiled_rule", + "//policy:compiler_factory", + "//policy:parser", + "//policy:parser_factory", + "//policy:rule_composer", + "//policy:source", + "//policy:validation_exception", + "//policy/testing:k8s_test_tag_handler", + "//runtime", + "//runtime:function_binding", + "//testing:cel_runtime_flavor", + "//testing/protos:single_file_java_proto", + "@bazel_tools//tools/java/runfiles", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + "@maven//:org_yaml_snakeyaml", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/policy/src/test/java/dev/cel/policy/CelPolicyCompilerFactoryTest.java b/policy/src/test/java/dev/cel/policy/CelPolicyCompilerFactoryTest.java new file mode 100644 index 000000000..1f323256b --- /dev/null +++ b/policy/src/test/java/dev/cel/policy/CelPolicyCompilerFactoryTest.java @@ -0,0 +1,47 @@ +// Copyright 2024 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.policy; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelParserFactory; +import dev.cel.runtime.CelRuntimeFactory; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelPolicyCompilerFactoryTest { + + @Test + public void newPolicyCompiler_compilerRuntimeCombined() { + assertThat( + CelPolicyCompilerFactory.newPolicyCompiler( + CelCompilerFactory.standardCelCompilerBuilder().build(), + CelRuntimeFactory.standardCelRuntimeBuilder().build())) + .isNotNull(); + } + + @Test + public void newPolicyCompiler_parserCheckerRuntimeCombined() { + assertThat( + CelPolicyCompilerFactory.newPolicyCompiler( + CelParserFactory.standardCelParserBuilder().build(), + CelCompilerFactory.standardCelCheckerBuilder().build(), + CelRuntimeFactory.standardCelRuntimeBuilder().build())) + .isNotNull(); + } +} diff --git a/policy/src/test/java/dev/cel/policy/CelPolicyCompilerImplTest.java b/policy/src/test/java/dev/cel/policy/CelPolicyCompilerImplTest.java new file mode 100644 index 000000000..73950069f --- /dev/null +++ b/policy/src/test/java/dev/cel/policy/CelPolicyCompilerImplTest.java @@ -0,0 +1,588 @@ +// Copyright 2024 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.policy; + +import static com.google.common.base.Strings.isNullOrEmpty; +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.policy.PolicyTestHelper.readFromYaml; +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.io.Resources; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameterValue; +import com.google.testing.junit.testparameterinjector.TestParameterValuesProvider; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelBuilder; +import dev.cel.bundle.CelEnvironment; +import dev.cel.bundle.CelEnvironmentYamlParser; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.common.formats.ValueString; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.parser.CelStandardMacro; +import dev.cel.parser.CelUnparserFactory; +import dev.cel.policy.PolicyTestHelper.PolicyTestSuite; +import dev.cel.policy.PolicyTestHelper.PolicyTestSuite.PolicyTestSection; +import dev.cel.policy.PolicyTestHelper.PolicyTestSuite.PolicyTestSection.PolicyTestCase; +import dev.cel.policy.PolicyTestHelper.PolicyTestSuite.PolicyTestSection.PolicyTestCase.PolicyTestInput; +import dev.cel.policy.PolicyTestHelper.TestYamlPolicy; +import dev.cel.policy.testing.K8sTagHandler; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelLateFunctionBindings; +import dev.cel.testing.CelRuntimeFlavor; +import dev.cel.testing.testdata.SingleFile; +import dev.cel.testing.testdata.proto3.StandaloneGlobalEnum; +import java.io.IOException; +import java.net.URL; +import java.util.Map; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelPolicyCompilerImplTest { + + private static final CelPolicyParser POLICY_PARSER = + CelPolicyParserFactory.newYamlParserBuilder().addTagVisitor(new K8sTagHandler()).build(); + private static final CelEnvironmentYamlParser ENVIRONMENT_PARSER = + CelEnvironmentYamlParser.newInstance(); + private static final CelOptions CEL_OPTIONS = + CelOptions.current() + .populateMacroCalls(true) + .enableHeterogeneousNumericComparisons(true) + .build(); + + @TestParameter private CelRuntimeFlavor runtimeFlavor; + + @Test + public void compileYamlPolicy_success(@TestParameter TestYamlPolicy yamlPolicy) throws Exception { + // Read config and produce an environment to compile policies + String configSource = yamlPolicy.readConfigYamlContent(); + CelEnvironment celEnvironment = ENVIRONMENT_PARSER.parse(configSource); + Cel cel = celEnvironment.extend(newCel(), CEL_OPTIONS); + // Read the policy source + String policySource = yamlPolicy.readPolicyYamlContent(); + CelPolicy policy = POLICY_PARSER.parse(policySource); + + CelAbstractSyntaxTree ast = + CelPolicyCompilerFactory.newPolicyCompiler(cel).build().compile(policy); + + assertThat(CelUnparserFactory.newUnparser().unparse(ast)).isEqualTo(yamlPolicy.getUnparsed()); + } + + @Test + public void compileYamlPolicy_withImportsOnNestedRules() throws Exception { + String policySource = + "imports:\n" + + " - name: cel.expr.conformance.proto3.TestAllTypes\n" + + " - name: dev.cel.testing.testdata.SingleFile\n" + + "rule:\n" + + " match:\n" + + " - rule:\n" + + " id: 'nested rule with imports'\n" + + " match:\n" + + " - condition: 'TestAllTypes{}.single_string == SingleFile{}.name'\n" + + " output: 'true'\n"; + Cel cel = newCel(); + CelPolicy policy = POLICY_PARSER.parse(policySource); + + CelAbstractSyntaxTree ast = + CelPolicyCompilerFactory.newPolicyCompiler(cel).build().compile(policy); + + assertThat(ast.getResultType()).isEqualTo(OptionalType.create(SimpleType.BOOL)); + } + + @Test + public void compileYamlPolicy_nestedRuleOptionalFallbackDivergence() throws Exception { + Cel cel = newCel().toCelBuilder().addVar("input_val", SimpleType.INT).build(); + String policySource = + "name: grandparent_policy\n" + + "rule:\n" + + " match:\n" + + " - condition: 'input_val == 2'\n" // conditional grandparent match + + " rule:\n" + + " id: parent_rule\n" + + " match:\n" + + " - condition: 'input_val == 1'\n" // conditional parent match + + " rule:\n" + + " id: nested_rule\n" + + " match:\n" + + " - condition: 'input_val == 3'\n" + + " output: 'true'\n" + + " - output: 'true'\n" // fallback (optional) + + " - output: 'true'\n"; + CelPolicy policy = POLICY_PARSER.parse(policySource); + CelAbstractSyntaxTree ast = + CelPolicyCompilerFactory.newPolicyCompiler(cel).build().compile(policy); + + assertThat(ast.getResultType()).isEqualTo(OptionalType.create(SimpleType.BOOL)); + } + + @Test + public void compileYamlPolicy_containsCompilationError_throws( + @TestParameter TestErrorYamlPolicy testCase) throws Exception { + // Read config and produce an environment to compile policies + Optional configSource = testCase.readConfigYamlContent(); + Cel baseCel = newCel(); + Cel cel = + configSource.isPresent() + ? ENVIRONMENT_PARSER.parse(configSource.get()).extend(baseCel, CEL_OPTIONS) + : baseCel; + // Read the policy source + String policySource = testCase.readPolicyYamlContent(); + CelPolicy policy = POLICY_PARSER.parse(policySource, testCase.getPolicyFilePath()); + + CelPolicyValidationException e = + assertThrows( + CelPolicyValidationException.class, + () -> CelPolicyCompilerFactory.newPolicyCompiler(cel).build().compile(policy)); + + assertThat(e).hasMessageThat().isEqualTo(testCase.readExpectedErrorsBaseline()); + } + + @Test + public void compileYamlPolicy_multilineContainsError_throws( + @TestParameter MultilineErrorTest testCase) throws Exception { + String policyContent = testCase.yaml; + CelPolicy policy = POLICY_PARSER.parse(policyContent); + + CelPolicyValidationException e = + assertThrows( + CelPolicyValidationException.class, + () -> CelPolicyCompilerFactory.newPolicyCompiler(newCel()).build().compile(policy)); + + assertThat(e).hasMessageThat().isEqualTo(testCase.expected); + } + + @Test + public void compileYamlPolicy_exceedsDefaultAstDepthLimit_throws() throws Exception { + Cel cel = newCel().toCelBuilder().addVar("msg", SimpleType.DYN).build(); + String longExpr = "msg.b.c.d.e.f"; + String policyContent = + String.format( + "name: deeply_nested_ast\n" + "rule:\n" + " match:\n" + " - output: %s", longExpr); + CelPolicy policy = POLICY_PARSER.parse(policyContent); + + CelPolicyValidationException e = + assertThrows( + CelPolicyValidationException.class, + () -> + CelPolicyCompilerFactory.newPolicyCompiler(cel) + .setAstDepthLimit(5) + .build() + .compile(policy)); + + assertThat(e) + .hasMessageThat() + .isEqualTo("ERROR: :-1:0: AST's depth exceeds the configured limit: 5."); + } + + @Test + public void compileYamlPolicy_constantFoldingFailure_throwsDuringComposition() throws Exception { + String policyContent = + "name: ast_with_div_by_zero\n" // + + "rule:\n" // + + " match:\n" // + + " - output: 1 / 0"; + CelPolicy policy = POLICY_PARSER.parse(policyContent); + + CelPolicyValidationException e = + assertThrows( + CelPolicyValidationException.class, + () -> CelPolicyCompilerFactory.newPolicyCompiler(newCel()).build().compile(policy)); + assertThat(e) + .hasMessageThat() + .isEqualTo( + "Failed to optimize the composed policy. Reason: Constant folding failure. Failed to" + + " evaluate subtree due to: evaluation error: / by zero"); + } + + @Test + public void compileYamlPolicy_astDepthLimitCheckDisabled_doesNotThrow() throws Exception { + String longExpr = + "0+1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20+21+22+23+24+25+26+27+28+29+30+31+32+33+34+35+36+37+38+39+40+41+42+43+44+45+46+47+48+49+50"; + String policyContent = + String.format( + "name: deeply_nested_ast\n" + "rule:\n" + " match:\n" + " - output: %s", longExpr); + CelPolicy policy = POLICY_PARSER.parse(policyContent); + + CelAbstractSyntaxTree ast = + CelPolicyCompilerFactory.newPolicyCompiler(newCel()) + .setAstDepthLimit(-1) + .build() + .compile(policy); + assertThat(ast).isNotNull(); + } + + @Test + @SuppressWarnings("unchecked") + public void evaluateYamlPolicy_withCanonicalTestData( + @TestParameter(valuesProvider = EvaluablePolicyTestDataProvider.class) + EvaluablePolicyTestData testData) + throws Exception { + // Setup + // Read config and produce an environment to compile policies + String configSource = testData.yamlPolicy.readConfigYamlContent(); + CelEnvironment celEnvironment = ENVIRONMENT_PARSER.parse(configSource); + Cel cel = celEnvironment.extend(newCel(), CEL_OPTIONS); + // Read the policy source + String policySource = testData.yamlPolicy.readPolicyYamlContent(); + CelPolicy policy = POLICY_PARSER.parse(policySource); + Object outputObj = testData.testCase.getOutput(); + String exprToCompile; + if (outputObj instanceof String) { + exprToCompile = (String) outputObj; + } else if (outputObj instanceof Map) { + @SuppressWarnings("unchecked") // Test only + Map outputMap = (Map) outputObj; + if (outputMap.containsKey("value")) { + Object value = outputMap.get("value"); + if (value instanceof String) { + String escapedValue = ((String) value).replace("\"", "\\\""); + exprToCompile = "\"" + escapedValue + "\""; // Quote string literals + } else { + exprToCompile = String.valueOf(value); + } + } else if (outputMap.containsKey("expr")) { + exprToCompile = (String) outputMap.get("expr"); + } else { + throw new IllegalArgumentException("Invalid output format: " + outputObj); + } + } else { + throw new IllegalArgumentException("Invalid output format: " + outputObj); + } + CelAbstractSyntaxTree expectedOutputAst = cel.compile(exprToCompile).getAst(); + Object expectedOutput = cel.createProgram(expectedOutputAst).eval(); + + // Act + // Compile then evaluate the policy + CelAbstractSyntaxTree compiledPolicyAst = + CelPolicyCompilerFactory.newPolicyCompiler(cel).build().compile(policy); + ImmutableMap.Builder inputBuilder = ImmutableMap.builder(); + for (Map.Entry entry : testData.testCase.getInput().entrySet()) { + String exprInput = entry.getValue().getExpr(); + if (isNullOrEmpty(exprInput)) { + inputBuilder.put(entry.getKey(), entry.getValue().getValue()); + } else { + CelAbstractSyntaxTree exprInputAst = cel.compile(exprInput).getAst(); + inputBuilder.put(entry.getKey(), cel.createProgram(exprInputAst).eval()); + } + } + Object evalResult = cel.createProgram(compiledPolicyAst).eval(inputBuilder.buildOrThrow()); + + // Assert + // Note that policies may either produce an optional or a non-optional result, + // if all the rules included nested ones can always produce a default result when none of the + // condition matches + if (testData.yamlPolicy.producesOptionalResult()) { + Optional policyOutput = (Optional) evalResult; + if (policyOutput.isPresent()) { + assertThat(policyOutput).hasValue(expectedOutput); + } else { + assertThat(policyOutput).isEmpty(); + } + } else { + assertThat(evalResult).isEqualTo(expectedOutput); + } + } + + @Test + @SuppressWarnings("unchecked") + public void evaluateYamlPolicy_nestedRuleProducesOptionalOutput() throws Exception { + Cel cel = newCel(); + String policySource = + "name: nested_rule_with_optional_result\n" + + "rule:\n" + + " match:\n" + + " - rule:\n" + + " match:\n" + + " - condition: 'true'\n" + + " output: 'optional.of(true)'\n"; + CelPolicy policy = POLICY_PARSER.parse(policySource); + CelAbstractSyntaxTree compiledPolicyAst = + CelPolicyCompilerFactory.newPolicyCompiler(cel).build().compile(policy); + Optional evalResult = (Optional) cel.createProgram(compiledPolicyAst).eval(); + + // Result is Optional containing true + assertThat(evalResult).hasValue(true); + } + + @Test + public void evaluateYamlPolicy_lateBoundFunction() throws Exception { + String configSource = + "name: late_bound_function_config\n" + + "functions:\n" + + " - name: 'lateBoundFunc'\n" + + " overloads:\n" + + " - id: 'lateBoundFunc_string'\n" + + " args:\n" + + " - type_name: 'string'\n" + + " return:\n" + + " type_name: 'string'\n"; + CelEnvironment celEnvironment = ENVIRONMENT_PARSER.parse(configSource); + CelBuilder celBuilder = newCel().toCelBuilder(); + if (runtimeFlavor == CelRuntimeFlavor.PLANNER) { + celBuilder.addLateBoundFunctions("lateBoundFunc"); + } + Cel cel = celEnvironment.extend(celBuilder.build(), CEL_OPTIONS); + + String policySource = + "name: late_bound_function_policy\n" + + "rule:\n" + + " match:\n" + + " - output: |\n" + + " lateBoundFunc('foo')\n"; + CelPolicy policy = POLICY_PARSER.parse(policySource); + CelAbstractSyntaxTree compiledPolicyAst = + CelPolicyCompilerFactory.newPolicyCompiler(cel).build().compile(policy); + String exampleValue = "bar"; + CelLateFunctionBindings lateFunctionBindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from( + "lateBoundFunc_string", String.class, arg -> arg + exampleValue)); + + String evalResult = + (String) + cel.createProgram(compiledPolicyAst) + .eval((unused) -> Optional.empty(), lateFunctionBindings); + assertThat(evalResult).isEqualTo("foo" + exampleValue); + } + + @Test + public void evaluateYamlPolicy_withSimpleVariable() throws Exception { + Cel cel = newCel(); + String policySource = + "name: shorthand_variables_policy\n" + + "rule:\n" + + " variables:\n" + + " - first: 'true'\n" + + " - second: 'false'\n" + + " match:\n" + + " - output: 'variables.first && variables.second'"; + CelPolicyParser parser = + CelPolicyParserFactory.newYamlParserBuilder().enableSimpleVariables(true).build(); + CelPolicy policy = parser.parse(policySource); + + CelAbstractSyntaxTree compiledPolicyAst = + CelPolicyCompilerFactory.newPolicyCompiler(cel).build().compile(policy); + boolean evalResult = (boolean) cel.createProgram(compiledPolicyAst).eval(); + + assertThat(evalResult).isFalse(); + } + + @Test + public void compose_ruleWithNoOutputs_throws() throws Exception { + Cel cel = newCel(); + CelCompiledRule emptyRule = + CelCompiledRule.create( + 1L, + Optional.of(ValueString.of(2L, "empty_rule")), + ImmutableList.of(), + ImmutableList.of(), + cel); + RuleComposer composer = RuleComposer.newInstance(emptyRule, "variables.", 1000); + CelAbstractSyntaxTree ast = cel.compile("true").getAst(); + + IllegalStateException e = + assertThrows(IllegalStateException.class, () -> composer.optimize(ast, cel)); + assertThat(e).hasMessageThat().isEqualTo("Policy contains no outputs."); + } + + private static final class EvaluablePolicyTestData { + private final TestYamlPolicy yamlPolicy; + private final PolicyTestCase testCase; + + private EvaluablePolicyTestData(TestYamlPolicy yamlPolicy, PolicyTestCase testCase) { + this.yamlPolicy = yamlPolicy; + this.testCase = testCase; + } + } + + private static final class EvaluablePolicyTestDataProvider extends TestParameterValuesProvider { + + @Override + protected ImmutableList provideValues(Context context) throws Exception { + ImmutableList.Builder builder = ImmutableList.builder(); + for (TestYamlPolicy yamlPolicy : TestYamlPolicy.values()) { + PolicyTestSuite testSuite = yamlPolicy.readTestYamlContent(); + for (PolicyTestSection testSection : testSuite.getSection()) { + for (PolicyTestCase testCase : testSection.getTests()) { + String testName = + String.format( + "%s %s %s", + yamlPolicy.getPolicyName(), testSection.getName(), testCase.getName()); + builder.add( + value(new EvaluablePolicyTestData(yamlPolicy, testCase)).withName(testName)); + } + } + } + + return builder.build(); + } + } + + private Cel newCel() { + return runtimeFlavor + .builder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addCompilerLibraries(CelOptionalLibrary.INSTANCE) + .addRuntimeLibraries(CelOptionalLibrary.INSTANCE) + .addFileTypes(StandaloneGlobalEnum.getDescriptor().getFile()) + .addMessageTypes(TestAllTypes.getDescriptor(), SingleFile.getDescriptor()) + .setOptions(CEL_OPTIONS) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "locationCode", + CelFunctionBinding.from( + "locationCode_string", + String.class, + (ip) -> { + switch (ip) { + case "10.0.0.1": + return "us"; + case "10.0.0.2": + return "de"; + default: + return "ir"; + } + }))) + .build(); + } + + private enum MultilineErrorTest { + SINGLE_FOLDED( + "name: \"errors\"\n" + + "rule:\n" + + " match:\n" + + " - output: >\n" + + " 'test'.format(variables.missing])", + "ERROR: :5:40: extraneous input ']' expecting ')'\n" + + " | 'test'.format(variables.missing])\n" + + " | .......................................^"), + DOUBLE_FOLDED( + "name: \"errors\"\n" + + "rule:\n" + + " match:\n" + + " - output: >\n" + + " 'test'.format(\n" + + " variables.missing])", + "ERROR: :6:26: extraneous input ']' expecting ')'\n" + + " | variables.missing])\n" + + " | .........................^"), + TRIPLE_FOLDED( + "name: \"errors\"\n" + + "rule:\n" + + " match:\n" + + " - output: >\n" + + " 'test'.\n" + + " format(\n" + + " variables.missing])", + "ERROR: :7:26: extraneous input ']' expecting ')'\n" + + " | variables.missing])\n" + + " | .........................^"), + SINGLE_LITERAL( + "name: \"errors\"\n" + + "rule:\n" + + " match:\n" + + " - output: |\n" + + " 'test'.format(variables.missing])", + "ERROR: :5:40: extraneous input ']' expecting ')'\n" + + " | 'test'.format(variables.missing])\n" + + " | .......................................^"), + DOUBLE_LITERAL( + "name: \"errors\"\n" + + "rule:\n" + + " match:\n" + + " - output: |\n" + + " 'test'.format(\n" + + " variables.missing])", + "ERROR: :6:26: extraneous input ']' expecting ')'\n" + + " | variables.missing])\n" + + " | .........................^"), + TRIPLE_LITERAL( + "name: \"errors\"\n" + + "rule:\n" + + " match:\n" + + " - output: |\n" + + " 'test'.\n" + + " format(\n" + + " variables.missing])", + "ERROR: :7:26: extraneous input ']' expecting ')'\n" + + " | variables.missing])\n" + + " | .........................^"), + ; + + private final String yaml; + private final String expected; + + MultilineErrorTest(String yaml, String expected) { + this.yaml = yaml; + this.expected = expected; + } + } + + private enum TestErrorYamlPolicy { + COMPOSE_ERRORS_CONFLICTING_OUTPUT("compose_conflicting_output"), + COMPOSE_ERRORS_CONFLICTING_SUBRULE("compose_conflicting_subrule"), + ERRORS_UNREACHABLE("unreachable"), + DUPLICATE_VARIABLE("duplicate_variable"), + IMPORT("import"), + INCOMPATIBLE_OUTPUTS("incompatible_outputs"), + SYNTAX("syntax"), + UNDECLARED_REFERENCE("undeclared_reference"); + + private final String name; + private final String policyFilePath; + + private String getPolicyFilePath() { + return policyFilePath; + } + + private String readPolicyYamlContent() throws IOException { + return readFromYaml( + String.format( + "cel_policy/conformance/testdata/compile_errors/%s/policy.yaml", + name)); + } + + private Optional readConfigYamlContent() throws IOException { + String rlocationPath = + String.format( + "cel_policy/conformance/testdata/compile_errors/%s/config.yaml", + name); + if (PolicyTestHelper.hasRunfile(rlocationPath)) { + return Optional.of(readFromYaml(rlocationPath)); + } + return Optional.empty(); + } + + private String readExpectedErrorsBaseline() throws IOException { + URL url = Resources.getResource(String.format("policy/%s/expected_errors.baseline", name)); + return Resources.toString(url, UTF_8).trim(); + } + + TestErrorYamlPolicy(String name) { + this.name = name; + this.policyFilePath = String.format("%s/policy.yaml", name); + } + } +} diff --git a/policy/src/test/java/dev/cel/policy/CelPolicySourceTest.java b/policy/src/test/java/dev/cel/policy/CelPolicySourceTest.java new file mode 100644 index 000000000..9aa73ee6c --- /dev/null +++ b/policy/src/test/java/dev/cel/policy/CelPolicySourceTest.java @@ -0,0 +1,54 @@ +// Copyright 2024 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.policy; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.internal.CelCodePointArray; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelPolicySourceTest { + + @Test + public void constructPolicySource_success() { + CelPolicySource policySource = + CelPolicySource.newBuilder(CelCodePointArray.fromString("hello world")) + .setDescription("") + .build(); + + assertThat(policySource.getContent().toString()).isEqualTo("hello world"); + assertThat(policySource.getDescription()).isEqualTo(""); + } + + @Test + public void getSnippet_success() { + CelPolicySource policySource = + CelPolicySource.newBuilder(CelCodePointArray.fromString("hello\nworld")).build(); + + assertThat(policySource.getSnippet(1)).hasValue("hello"); + assertThat(policySource.getSnippet(2)).hasValue("world"); + } + + @Test + public void getSnippet_returnsEmpty() { + CelPolicySource policySource = + CelPolicySource.newBuilder(CelCodePointArray.fromString("hello\nworld")).build(); + + assertThat(policySource.getSnippet(3)).isEmpty(); + } +} diff --git a/policy/src/test/java/dev/cel/policy/CelPolicyYamlParserTest.java b/policy/src/test/java/dev/cel/policy/CelPolicyYamlParserTest.java new file mode 100644 index 000000000..2a2c47a98 --- /dev/null +++ b/policy/src/test/java/dev/cel/policy/CelPolicyYamlParserTest.java @@ -0,0 +1,413 @@ +// Copyright 2024 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.policy; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.Iterables; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.formats.ValueString; +import dev.cel.policy.CelPolicy.Import; +import dev.cel.policy.PolicyTestHelper.TestYamlPolicy; +import dev.cel.policy.testing.K8sTagHandler; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelPolicyYamlParserTest { + + private static final CelPolicyParser POLICY_PARSER = + CelPolicyParserFactory.newYamlParserBuilder().addTagVisitor(new K8sTagHandler()).build(); + + @Test + public void parseYamlPolicy_success(@TestParameter TestYamlPolicy yamlPolicy) throws Exception { + String policySource = yamlPolicy.readPolicyYamlContent(); + String description = yamlPolicy.getPolicyName(); + + CelPolicy policy = POLICY_PARSER.parse(policySource, description); + + assertThat(policy.name().value()).isEqualTo(yamlPolicy.getPolicyName()); + assertThat(policy.policySource().getContent().toString()).isEqualTo(policySource); + assertThat(policy.policySource().getDescription()).isEqualTo(description); + } + + @Test + public void parser_setEmpty() throws Exception { + assertThrows(CelPolicyValidationException.class, () -> POLICY_PARSER.parse("", "")); + } + + @Test + public void parseYamlPolicy_withDescription_atPolicyLevel() throws Exception { + String policySource = + "name: 'policy_with_description'\n" + + "description: 'this is a description of the policy'\n" + + "rule:\n" + + " variables:\n" + + " - name: 'variable_with_description'\n" + + " description: 'this is a description of the variable'\n" + + " expression: 'true'"; + + CelPolicy policy = POLICY_PARSER.parse(policySource); + + assertThat(policy.description()) + .hasValue(ValueString.of(5, "this is a description of the policy")); + } + + @Test + public void parseYamlPolicy_withDisplayName_atPolicyLevel() throws Exception { + String policySource = + "name: 'policy_with_description'\n" + + "display_name: 'display name of the policy'\n" + + "rule:\n" + + " variables:\n" + + " - name: 'variable_with_description'\n" + + " description: 'this is a description of the variable'\n" + + " expression: 'true'"; + + CelPolicy policy = POLICY_PARSER.parse(policySource); + + assertThat(policy.displayName()).hasValue(ValueString.of(5, "display name of the policy")); + } + + @Test + public void parseYamlPolicy_withDescription() throws Exception { + String policySource = + "rule:\n" + + " variables:\n" + + " - name: 'variable_with_description'\n" + + " description: 'this is a description of the variable'\n" + + " expression: 'true'"; + + CelPolicy policy = POLICY_PARSER.parse(policySource); + + assertThat(policy.rule().variables()).hasSize(1); + assertThat(Iterables.getOnlyElement(policy.rule().variables()).description()) + .hasValue(ValueString.of(10, "this is a description of the variable")); + } + + @Test + public void parseYamlPolicy_withDescription_foldedStyle() throws Exception { + String policySource = + "name: 'policy_name'\n" + + "description: >-\n" + + " this is a multiline string\n" + + " that gets folded into a single line"; + + CelPolicy policy = POLICY_PARSER.parse(policySource); + + assertThat(policy.description().map(ValueString::value)) + .hasValue("this is a multiline string that gets folded into a single line"); + } + + @Test + public void parseYamlPolicy_withDisplayName() throws Exception { + String policySource = + "rule:\n" + + " variables:\n" + + " - name: 'variable_with_description'\n" + + " display_name: 'Display Name'\n" + + " expression: 'true'"; + + CelPolicy policy = POLICY_PARSER.parse(policySource); + + assertThat(policy.rule().variables()).hasSize(1); + assertThat(Iterables.getOnlyElement(policy.rule().variables()).displayName()) + .hasValue(ValueString.of(10, "Display Name")); + } + + @Test + public void parseYamlPolicy_withExplanation() throws Exception { + String policySource = + "rule:\n" + + " match:\n" + + " - output: 'true'\n" + + " explanation: \"'custom explanation'\""; + + CelPolicy policy = POLICY_PARSER.parse(policySource); + + assertThat(policy.rule().matches()).hasSize(1); + assertThat(Iterables.getOnlyElement(policy.rule().matches()).explanation()) + .hasValue(ValueString.of(11, "'custom explanation'")); + } + + @Test + public void parseYamlPolicy_withImports() throws Exception { + String policySource = + "name: 'policy_with_imports'\n" + + "imports:\n" + + "- name: foo\n" + + "- name: >\n" + + " bar"; + + CelPolicy policy = POLICY_PARSER.parse(policySource); + + assertThat(policy.imports()) + .containsExactly( + Import.create(8L, ValueString.of(9L, "foo")), + Import.create(12L, ValueString.of(13L, "bar"))) + .inOrder(); + } + + @Test + public void parseYamlPolicy_withSimpleVariable_multipleInlinedVariables() { + String policySource = + "name: shorthand_variables_policy\n" + + "rule:\n" + + " variables:\n" + + " - first: 'true'\n" + + " second: 'false'\n" + + " match:\n" + + " - condition: 'variables.my_var'\n" + + " output: 'true'\n"; + CelPolicyParser parser = + CelPolicyParserFactory.newYamlParserBuilder().enableSimpleVariables(true).build(); + + CelPolicyValidationException e = + assertThrows(CelPolicyValidationException.class, () -> parser.parse(policySource)); + assertThat(e) + .hasMessageThat() + .contains( + "ERROR: :5:7: Only one variable may be defined inline\n" + + " | second: 'false'\n" + + " | ......^"); + } + + @Test + public void parseYamlPolicy_errors(@TestParameter PolicyParseErrorTestCase testCase) { + CelPolicyValidationException e = + assertThrows( + CelPolicyValidationException.class, () -> POLICY_PARSER.parse(testCase.yamlPolicy)); + assertThat(e).hasMessageThat().isEqualTo(testCase.expectedErrorMessage); + } + + private enum PolicyParseErrorTestCase { + MALFORMED_YAML_DOCUMENT( + "a:\na", + "YAML document is malformed: while scanning a simple key\n" + + " in 'reader', line 2, column 1:\n" + + " a\n" + + " ^\n" + + "could not find expected ':'\n" + + " in 'reader', line 2, column 2:\n" + + " a\n" + + " ^\n"), + ILLEGAL_YAML_TYPE_POLICY_KEY( + "1: test", + "ERROR: :1:1: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | 1: test\n" + + " | ^"), + ILLEGAL_YAML_TYPE_ON_NAME_VALUE( + "name: \n" + " illegal: yaml-type", + "ERROR: :2:3: Got yaml node type tag:yaml.org,2002:map, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | illegal: yaml-type\n" + + " | ..^"), + ILLEGAL_YAML_TYPE_ON_RULE_VALUE( + "rule: illegal", + "ERROR: :1:7: Got yaml node type tag:yaml.org,2002:str, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | rule: illegal\n" + + " | ......^"), + ILLEGAL_YAML_TYPE_ON_RULE_MAP_KEY( + "rule: \n" + " 1: foo", + "ERROR: :2:3: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | 1: foo\n" + + " | ..^"), + ILLEGAL_YAML_TYPE_ON_MATCHES_VALUE( + "rule:\n" + " match: illegal\n", + "ERROR: :2:10: Got yaml node type tag:yaml.org,2002:str, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | match: illegal\n" + + " | .........^"), + ILLEGAL_YAML_TYPE_ON_MATCHES_LIST( + "rule:\n" + " match:\n" + " - illegal", + "ERROR: :3:7: Got yaml node type tag:yaml.org,2002:str, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - illegal\n" + + " | ......^"), + ILLEGAL_YAML_TYPE_ON_MATCH_MAP_KEY( + "rule:\n" + " match:\n" + " - 1 : foo\n" + " output: 'hi'", + "ERROR: :3:7: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | - 1 : foo\n" + + " | ......^"), + ILLEGAL_YAML_TYPE_ON_VARIABLE_VALUE( + "rule:\n" + " variables: illegal\n", + "ERROR: :2:14: Got yaml node type tag:yaml.org,2002:str, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | variables: illegal\n" + + " | .............^"), + ILLEGAL_YAML_TYPE_ON_VARIABLE_MAP_KEY( + "rule:\n" + " variables:\n" + " - illegal", + "ERROR: :3:7: Got yaml node type tag:yaml.org,2002:str, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - illegal\n" + + " | ......^"), + MULTIPLE_YAML_DOCS( + "name: foo\n" + "---\n" + "name: bar", + "YAML document is malformed: expected a single document in the stream\n" + + " in 'reader', line 1, column 1:\n" + + " name: foo\n" + + " ^\n" + + "but found another document\n" + + " in 'reader', line 2, column 1:\n" + + " ---\n" + + " ^\n"), + UNSUPPORTED_RULE_TAG( + "rule:\n" + " custom: yaml-type", + "ERROR: :2:3: Unsupported rule tag: custom\n" + + " | custom: yaml-type\n" + + " | ..^"), + UNSUPPORTED_POLICY_TAG( + "inputs:\n" + " - name: a\n" + " - name: b", + "ERROR: :1:1: Unsupported policy tag: inputs\n" + " | inputs:\n" + " | ^"), + UNSUPPORTED_VARIABLE_TAG( + "rule:\n" // + + " variables:\n" // + + " - name: 'hello'\n" // + + " expression: 'true'\n" // + + " alt_name: 'bool_true'", + "ERROR: :5:7: Unsupported variable tag: alt_name\n" + + " | alt_name: 'bool_true'\n" + + " | ......^"), + MISSING_VARIABLE_NAME( + "rule:\n" // + + " variables:\n" // + + " - expression: 'true'", // + "ERROR: :3:7: Missing required attribute(s): name\n" + + " | - expression: 'true'\n" + + " | ......^"), + MISSING_VARIABLE_EXPRESSION( + "rule:\n" // + + " variables:\n" // + + " - name: 'hello'", // + "ERROR: :3:7: Missing required attribute(s): expression\n" + + " | - name: 'hello'\n" + + " | ......^"), + UNSUPPORTED_MATCH_TAG( + "rule:\n" + + " match:\n" + + " - name: 'true'\n" + + " output: 'hi'\n" + + " alt_name: 'bool_true'", + "ERROR: :3:7: Unsupported match tag: name\n" + + " | - name: 'true'\n" + + " | ......^\n" + + "ERROR: :5:7: Unsupported match tag: alt_name\n" + + " | alt_name: 'bool_true'\n" + + " | ......^"), + MATCH_MISSING_OUTPUT_AND_RULE( + "rule:\n" // + + " match:\n" // + + " - condition: 'true'", + "ERROR: :3:7: Missing required attribute(s): output or a rule\n" + + " | - condition: 'true'\n" + + " | ......^"), + MATCH_OUTPUT_SET_THEN_RULE( + "rule:\n" + + " match:\n" + + " - condition: \"true\"\n" + + " output: \"world\"\n" + + " rule:\n" + + " match:\n" + + " - output: \"hello\"", + "ERROR: :5:7: Only the rule or the output may be set\n" + + " | rule:\n" + + " | ......^"), + MATCH_RULE_SET_THEN_OUTPUT( + "rule:\n" + + " match:\n" + + " - condition: \"true\"\n" + + " rule:\n" + + " match:\n" + + " - output: \"hello\"\n" + + " output: \"world\"", + "ERROR: :7:7: Only the rule or the output may be set\n" + + " | output: \"world\"\n" + + " | ......^"), + MATCH_NESTED_RULE_SET_THEN_EXPLANATION( + "rule:\n" + + " match:\n" + + " - condition: \"true\"\n" + + " rule:\n" + + " match:\n" + + " - output: \"hello\"\n" + + " explanation: \"foo\"", + "ERROR: :7:7: Explanation can only be set on output match cases, not nested rules\n" + + " | explanation: \"foo\"\n" + + " | ......^"), + MATCH_EXPLANATION_SET_THEN_NESTED_RULE( + "rule:\n" + + " match:\n" + + " - condition: \"true\"\n" + + " explanation: \"foo\"\n" + + " rule:\n" + + " match:\n" + + " - output: \"hello\"\n", + "ERROR: :4:21: Explanation can only be set on output match cases, not nested rules\n" + + " | explanation: \"foo\"\n" + + " | ....................^"), + INVALID_ROOT_NODE_TYPE( + "- rule:\n" + " id: a", + "ERROR: :1:1: Got yaml node type tag:yaml.org,2002:seq, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - rule:\n" + + " | ^"), + ILLEGAL_RULE_DESCRIPTION_TYPE( + "rule:\n" + " description: 1", + "ERROR: :2:16: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | description: 1\n" + + " | ...............^"), + ILLEGAL_YAML_TYPE_IMPORT_EXPECTED_LIST( + "imports: foo", + "ERROR: :1:10: Got yaml node type tag:yaml.org,2002:str, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | imports: foo\n" + + " | .........^"), + ILLEGAL_YAML_TYPE_IMPORT_ELEMENT_EXPECTED_MAP( + "imports:\n" // + + "- foo", + "ERROR: :2:3: Got yaml node type tag:yaml.org,2002:str, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - foo\n" + + " | ..^"), + ILLEGAL_YAML_TYPE_IMPORT_ELEMENT_MAP_INVALID_KEY( + "imports:\n" // + + "- 1: 2", + "ERROR: :2:3: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | - 1: 2\n" + + " | ..^"), + ILLEGAL_YAML_TYPE_IMPORT_ELEMENT_MAP_INVALID_VALUE_NAME( + "imports:\n" // + + "- foo: bar", + "ERROR: :2:3: Invalid import key: foo, expected 'name'\n" + + " | - foo: bar\n" + + " | ..^"); + + private final String yamlPolicy; + private final String expectedErrorMessage; + + PolicyParseErrorTestCase(String yamlPolicy, String expectedErrorMessage) { + this.yamlPolicy = yamlPolicy; + this.expectedErrorMessage = expectedErrorMessage; + } + } +} diff --git a/policy/src/test/java/dev/cel/policy/PolicyTestHelper.java b/policy/src/test/java/dev/cel/policy/PolicyTestHelper.java new file mode 100644 index 000000000..3fe2e3322 --- /dev/null +++ b/policy/src/test/java/dev/cel/policy/PolicyTestHelper.java @@ -0,0 +1,312 @@ +// Copyright 2024 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.policy; + +import static java.nio.charset.StandardCharsets.UTF_8; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Ascii; +import com.google.common.io.Files; +import com.google.devtools.build.runfiles.AutoBazelRepository; +import com.google.devtools.build.runfiles.Runfiles; +import java.io.File; +import java.io.IOException; +import java.util.List; +import java.util.Map; +import org.yaml.snakeyaml.LoaderOptions; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.constructor.Constructor; + +/** Package-private class to assist with policy testing. */ +@AutoBazelRepository +final class PolicyTestHelper { + + private static final Runfiles runfiles = createRunfiles(); + + enum TestYamlPolicy { + NESTED_RULE( + "nested_rule", + false, + "cel.@block([resource.origin, @index0 in [\"us\", \"uk\", \"es\"], {\"banned\": true}]," + + " ((@index0 in {\"us\": false, \"ru\": false, \"ir\": false} && !@index1) ?" + + " optional.of(@index2) : optional.none()).orValue(@index1 ? {\"banned\":" + + " false} : @index2))"), + NESTED_RULE2( + "nested_rule2", + false, + "cel.@block([resource.origin, !(@index0 in [\"us\", \"uk\", \"es\"])]," + + " resource.?user.orValue(\"\").startsWith(\"bad\") ? ((@index0 in {\"us\": false," + + " \"ru\": false, \"ir\": false} && @index1) ? {\"banned\": \"restricted_region\"} :" + + " {\"banned\": \"bad_actor\"}) : (@index1 ? {\"banned\": \"unconfigured_region\"} :" + + " {}))"), + NESTED_RULE3( + "nested_rule3", + true, + "cel.@block([resource.origin, !(@index0 in [\"us\", \"uk\", \"es\"])]," + + " resource.?user.orValue(\"\").startsWith(\"bad\") ? optional.of((@index0 in {\"us\":" + + " false, \"ru\": false, \"ir\": false} && @index1) ? {\"banned\":" + + " \"restricted_region\"} : {\"banned\": \"bad_actor\"}) : (@index1 ?" + + " optional.of({\"banned\": \"unconfigured_region\"}) : optional.none()))"), + NESTED_RULE4("nested_rule4", false, "(x > 0) ? true : false"), + NESTED_RULE5( + "nested_rule5", + true, + "cel.@block([optional.of(true), optional.none()], (x > 0) ? ((x > 2) ? @index0 : @index1) :" + + " ((x > 1) ? ((x >= 2) ? @index0 : @index1) : optional.of(false)))"), + NESTED_RULE6( + "nested_rule6", + false, + "cel.@block([optional.of(true), optional.none()], ((x > 2) ? @index0 : @index1).orValue(((x" + + " > 3) ? @index0 : @index1).orValue(false)))"), + NESTED_RULE7( + "nested_rule7", + true, + "cel.@block([optional.of(true), optional.none()], ((x > 2) ? @index0 : @index1).or(((x > 3)" + + " ? @index0 : @index1).or((x > 1) ? optional.of(false) : @index1)))"), + REQUIRED_LABELS( + "required_labels", + true, + "cel.@block([spec.labels.filter(@it:0:0, !(@it:0:0 in resource.labels)), spec.labels," + + " resource.labels.transformList(@it:0:1, @it2:0:1, @it:0:1 in @index1 && @it2:0:1 !=" + + " @index1[@it:0:1], @it:0:1)], (@index0.size() > 0) ? optional.of(\"missing one or" + + " more required labels: [\"\" + @index0.join(\"\", \"\") + \"\"]\") :" + + " ((@index2.size() > 0) ? optional.of(\"invalid values provided on one or more" + + " labels: [\"\" + @index2.join(\"\", \"\") + \"\"]\") : optional.none()))"), + RESTRICTED_DESTINATIONS( + "restricted_destinations", + false, + "cel.@block([request.auth.claims, has(@index0.nationality), resource.labels.location in" + + " spec.restricted_destinations], (@index1 && @index0.nationality == spec.origin &&" + + " (locationCode(destination.ip) in spec.restricted_destinations || @index2)) ? true :" + + " ((!@index1 && locationCode(origin.ip) == spec.origin &&" + + " (locationCode(destination.ip) in spec.restricted_destinations || @index2)) ? true :" + + " false))"), + K8S( + "k8s", + true, + "cel.@block([resource.labels.?environment.orValue(\"prod\")]," + + " !(resource.labels.?break_glass.orValue(\"false\") == \"true\" ||" + + " resource.containers.all(@it:0:0, @it:0:0.startsWith(@index0 + \".\"))) ?" + + " optional.of(\"only \" + @index0 + \" containers are allowed in namespace \" +" + + " resource.namespace) : optional.none())"), + PB( + "pb", + true, + "cel.@block([spec.single_int32], (@index0 > 10) ? optional.of(\"invalid spec, got" + + " single_int32=\" + string(@index0) + \", wanted <= 10\") : ((spec.standalone_enum ==" + + " cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAR ||" + + " cel.expr.conformance.proto3.TestAllTypes.NestedEnum.BAZ in" + + " spec.repeated_nested_enum || cel.expr.conformance.proto3.GlobalEnum.GAR ==" + + " cel.expr.conformance.proto3.GlobalEnum.GOO) ? optional.of(\"invalid spec, neither" + + " nested nor repeated enums may refer to BAR or BAZ\") : optional.none()))"), + LIMITS( + "limits", + true, + "cel.@block([now.getHours()], (@index0 >= 20) ? ((@index0 < 21) ? optional.of(\"goodbye," + + " me!\") : ((@index0 < 22) ? optional.of(\"goodbye, me!!\") : ((@index0 < 24) ?" + + " optional.of(\"goodbye, me!!!\") : optional.none()))) : optional.of(\"hello," + + " me\"))"); + + private final String name; + private final boolean producesOptionalResult; + private final String unparsed; + + TestYamlPolicy(String name, boolean producesOptionalResult, String unparsed) { + this.name = name; + this.producesOptionalResult = producesOptionalResult; + this.unparsed = unparsed; + } + + String getPolicyName() { + return name; + } + + boolean producesOptionalResult() { + return this.producesOptionalResult; + } + + String getUnparsed() { + return unparsed; + } + + String readPolicyYamlContent() throws IOException { + return readFromYaml( + String.format( + "cel_policy/conformance/testdata/%s/policy.yaml", name)); + } + + String readConfigYamlContent() throws IOException { + return readFromYaml( + String.format( + "cel_policy/conformance/testdata/%s/config.yaml", name)); + } + + PolicyTestSuite readTestYamlContent() throws IOException { + Yaml yaml = new Yaml(new Constructor(PolicyTestSuite.class, new LoaderOptions())); + String testContent = + readFile( + String.format( + "cel_policy/conformance/testdata/%s/tests.yaml", name)); + + return yaml.load(testContent); + } + } + + static String readFromYaml(String yamlPath) throws IOException { + return readFile(yamlPath); + } + + /** + * TestSuite describes a set of tests divided by section. + * + *

Visibility must be public for YAML deserialization to work. This is effectively + * package-private since the outer class is. + */ + @VisibleForTesting + public static final class PolicyTestSuite { + private String name; + private String description; + private List section; + + public void setName(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + public void setDescription(String description) { + this.description = description; + } + + public void setSection(List section) { + this.section = section; + } + + public String getDescription() { + return description; + } + + public List getSection() { + return section; + } + + @VisibleForTesting + public static final class PolicyTestSection { + private String name; + private List tests; + + public void setName(String name) { + this.name = name; + } + + public void setTests(List tests) { + this.tests = tests; + } + + public String getName() { + return name; + } + + public List getTests() { + return tests; + } + + @VisibleForTesting + public static final class PolicyTestCase { + private String name; + private Map input; + private Object output; + + public void setName(String name) { + this.name = name; + } + + public void setInput(Map input) { + this.input = input; + } + + public void setOutput(Object output) { + this.output = output; + } + + public String getName() { + return name; + } + + public Map getInput() { + return input; + } + + public Object getOutput() { + return output; + } + + @VisibleForTesting + public static final class PolicyTestInput { + private Object value; + private String expr; + + public Object getValue() { + return value; + } + + public void setValue(Object value) { + this.value = value; + } + + public String getExpr() { + return expr; + } + + public void setExpr(String expr) { + this.expr = expr; + } + } + } + } + } + + private static String readFile(String rlocationPath) throws IOException { + String resolvedPath = runfiles.rlocation(Ascii.toLowerCase(rlocationPath)); + if (resolvedPath == null) { + throw new IOException("Unmapped runfile path: " + rlocationPath); + } + File file = new File(resolvedPath); + if (!file.exists()) { + throw new IOException( + String.format( + "Runfile not found on disk at '%s' (unresolved path: '%s')", + resolvedPath, rlocationPath)); + } + return Files.asCharSource(file, UTF_8).read(); + } + + static boolean hasRunfile(String rlocationPath) { + String resolvedPath = runfiles.rlocation(Ascii.toLowerCase(rlocationPath)); + return resolvedPath != null && new File(resolvedPath).exists(); + } + + private static Runfiles createRunfiles() { + try { + return Runfiles.preload().withSourceRepository(AutoBazelRepository_PolicyTestHelper.NAME); + } catch (IOException e) { + throw new RuntimeException("Failed to initialize Runfiles", e); + } + } + + private PolicyTestHelper() {} +} diff --git a/policy/testing/BUILD.bazel b/policy/testing/BUILD.bazel new file mode 100644 index 000000000..898368c3c --- /dev/null +++ b/policy/testing/BUILD.bazel @@ -0,0 +1,12 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//:internal"], +) + +java_library( + name = "k8s_test_tag_handler", + exports = ["//policy/src/main/java/dev/cel/policy/testing:k8s_tag_handler"], +) diff --git a/protobuf/BUILD.bazel b/protobuf/BUILD.bazel new file mode 100644 index 000000000..29b4b4f14 --- /dev/null +++ b/protobuf/BUILD.bazel @@ -0,0 +1,40 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//:internal"], +) + +java_library( + name = "cel_lite_descriptor", + # used_by_android + visibility = ["//:android_allow_list"], + exports = ["//protobuf/src/main/java/dev/cel/protobuf:cel_lite_descriptor"], +) + +java_library( + name = "proto_descriptor_collector", + testonly = 1, + visibility = ["//:internal"], + exports = ["//protobuf/src/main/java/dev/cel/protobuf:proto_descriptor_collector"], +) + +java_library( + name = "debug_printer", + testonly = 1, + visibility = ["//:internal"], + exports = ["//protobuf/src/main/java/dev/cel/protobuf:debug_printer"], +) + +java_library( + name = "lite_descriptor_codegen_metadata", + testonly = 1, + visibility = ["//:internal"], + exports = ["//protobuf/src/main/java/dev/cel/protobuf:lite_descriptor_codegen_metadata"], +) + +alias( + name = "cel_lite_descriptor_generator", + actual = "//protobuf/src/main/java/dev/cel/protobuf:cel_lite_descriptor_generator", + visibility = ["//:internal"], +) diff --git a/protobuf/src/main/java/dev/cel/protobuf/BUILD.bazel b/protobuf/src/main/java/dev/cel/protobuf/BUILD.bazel new file mode 100644 index 000000000..b2dac98e7 --- /dev/null +++ b/protobuf/src/main/java/dev/cel/protobuf/BUILD.bazel @@ -0,0 +1,102 @@ +load("@rules_java//java:defs.bzl", "java_binary", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//protobuf:__pkg__", + "//publish:__pkg__", + ], +) + +java_binary( + name = "cel_lite_descriptor_generator", + srcs = ["CelLiteDescriptorGenerator.java"], + main_class = "dev.cel.protobuf.CelLiteDescriptorGenerator", + runtime_deps = [ + # Prevent Classloader from picking protolite. We need full version to access descriptors to codegen CelLiteDescriptor. + "@maven//:com_google_protobuf_protobuf_java", + ], + deps = [ + ":debug_printer", + ":java_file_generator", + ":proto_descriptor_collector", + "//common:cel_descriptor_util", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:info_picocli_picocli", + ], +) + +java_library( + name = "cel_lite_descriptor", + srcs = ["CelLiteDescriptor.java"], + # used_by_android + tags = [ + ], + deps = [ + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "proto_descriptor_collector", + srcs = ["ProtoDescriptorCollector.java"], + tags = [ + ], + deps = [ + ":cel_lite_descriptor", + ":debug_printer", + ":lite_descriptor_codegen_metadata", + "//common/internal:well_known_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +filegroup( + name = "cel_lite_descriptor_template_file", + srcs = ["templates/cel_lite_descriptor_template.txt"], + visibility = ["//visibility:private"], +) + +java_library( + name = "java_file_generator", + srcs = ["JavaFileGenerator.java"], + resources = [ + ":cel_lite_descriptor_template_file", + ], + visibility = ["//visibility:private"], + deps = [ + ":lite_descriptor_codegen_metadata", + "//:auto_value", + "@maven//:com_google_guava_guava", + "@maven//:org_freemarker_freemarker", + ], +) + +java_library( + name = "debug_printer", + srcs = ["DebugPrinter.java"], + tags = [ + ], + deps = [ + "@maven//:info_picocli_picocli", + ], +) + +java_library( + name = "lite_descriptor_codegen_metadata", + srcs = ["LiteDescriptorCodegenMetadata.java"], + tags = [ + ], + deps = [ + ":cel_lite_descriptor", + "//:auto_value", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) diff --git a/protobuf/src/main/java/dev/cel/protobuf/CelLiteDescriptor.java b/protobuf/src/main/java/dev/cel/protobuf/CelLiteDescriptor.java new file mode 100644 index 000000000..c066bb18e --- /dev/null +++ b/protobuf/src/main/java/dev/cel/protobuf/CelLiteDescriptor.java @@ -0,0 +1,304 @@ +// Copyright 2025 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.protobuf; + +import static java.lang.Math.ceil; + +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.MessageLite; +import dev.cel.common.annotations.Internal; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; +import java.util.function.Supplier; + +/** + * Base class for code generated CEL lite descriptors to extend from. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +@Immutable +public abstract class CelLiteDescriptor { + @SuppressWarnings("Immutable") // Copied to unmodifiable map + private final Map protoFqnToDescriptors; + + private final String version; + + public Map getProtoTypeNamesToDescriptors() { + return protoFqnToDescriptors; + } + + /** Retrieves the CEL-Java version this descriptor was generated with */ + public String getVersion() { + return version; + } + + /** + * Contains a collection of classes which describe protobuf messagelite types. + * + *

CEL Library Internals. Do Not Use. + */ + @Internal + @Immutable + public static final class MessageLiteDescriptor { + private final String fullyQualifiedProtoTypeName; + + @SuppressWarnings("Immutable") // Copied to an unmodifiable list + private final List fieldLiteDescriptors; + + @SuppressWarnings("Immutable") // Copied to an unmodifiable map + private final Map fieldNameToFieldDescriptors; + + @SuppressWarnings("Immutable") // Copied to an unmodifiable map + private final Map fieldNumberToFieldDescriptors; + + @SuppressWarnings("Immutable") // Does not alter the descriptor content + private final Supplier messageBuilderSupplier; + + public String getProtoTypeName() { + return fullyQualifiedProtoTypeName; + } + + public List getFieldDescriptors() { + return fieldLiteDescriptors; + } + + public Optional findByFieldNumber(int fieldNumber) { + return Optional.ofNullable(fieldNumberToFieldDescriptors.get(fieldNumber)); + } + + public FieldLiteDescriptor getByFieldNameOrThrow(String fieldName) { + return Objects.requireNonNull(fieldNameToFieldDescriptors.get(fieldName)); + } + + public FieldLiteDescriptor getByFieldNumberOrThrow(int fieldNumber) { + return findByFieldNumber(fieldNumber) + .orElseThrow( + () -> new NoSuchElementException("Could not find field number: " + fieldNumber)); + } + + /** Gets the builder for the message. Returns null for maps. */ + public MessageLite.Builder newMessageBuilder() { + return messageBuilderSupplier.get(); + } + + /** + * CEL Library Internals. Do not use. + * + *

Public visibility due to codegen. + */ + @Internal + public MessageLiteDescriptor( + String fullyQualifiedProtoTypeName, + List fieldLiteDescriptors, + Supplier messageBuilderSupplier) { + this.fullyQualifiedProtoTypeName = Objects.requireNonNull(fullyQualifiedProtoTypeName); + // This is a cheap operation. View over the existing map with mutators disabled. + this.fieldLiteDescriptors = + Collections.unmodifiableList(Objects.requireNonNull(fieldLiteDescriptors)); + this.messageBuilderSupplier = Objects.requireNonNull(messageBuilderSupplier); + + Map fieldNameMap = + new HashMap<>(getMapInitialCapacity(fieldLiteDescriptors.size())); + Map fieldNumberMap = + new HashMap<>(getMapInitialCapacity(fieldLiteDescriptors.size())); + for (FieldLiteDescriptor fd : fieldLiteDescriptors) { + fieldNameMap.put(fd.fieldName, fd); + fieldNumberMap.put(fd.fieldNumber, fd); + } + this.fieldNameToFieldDescriptors = Collections.unmodifiableMap(fieldNameMap); + this.fieldNumberToFieldDescriptors = Collections.unmodifiableMap(fieldNumberMap); + } + } + + /** + * Describes a field of a protobuf messagelite type. + * + *

CEL Library Internals. Do Not Use. + */ + @Internal + @Immutable + public static final class FieldLiteDescriptor { + private final int fieldNumber; + private final String fieldName; + private final JavaType javaType; + private final String fieldProtoTypeName; + private final Type protoFieldType; + private final EncodingType encodingType; + private final boolean isPacked; + + /** + * Enumeration of encoding type. This describes how CEL should deserialize the encoded message + * bytes using protobuf's wire format. This is analogous to the following from field + * descriptors: + * + *

    + *
  • LIST: Repeated Field + *
  • MAP: Map Field + *
  • SINGULAR: Neither of above (scalars, messages) + *
+ */ + public enum EncodingType { + SINGULAR, + LIST, + MAP + } + + /** + * Enumeration of the java type. + * + *

This is exactly the same as com.google.protobuf.Descriptors#JavaType + */ + public enum JavaType { + INT, + LONG, + FLOAT, + DOUBLE, + BOOLEAN, + STRING, + BYTE_STRING, + ENUM, + MESSAGE + } + + /** + * Enumeration of the protobuf type. + * + *

This is exactly the same as com.google.protobuf.Descriptors#Type + */ + public enum Type { + DOUBLE, + FLOAT, + INT64, + UINT64, + INT32, + FIXED64, + FIXED32, + BOOL, + STRING, + GROUP, + MESSAGE, + BYTES, + UINT32, + ENUM, + SFIXED32, + SFIXED64, + SINT32, + SINT64 + } + + public String getFieldName() { + return fieldName; + } + + /** + * Gets the field's java type. + * + *

This is exactly the same as com.google.protobuf.Descriptors#JavaType + */ + public JavaType getJavaType() { + return javaType; + } + + public EncodingType getEncodingType() { + return encodingType; + } + + /** + * Gets the field's protobuf type. + * + *

This is exactly the same as com.google.protobuf.Descriptors#Type + */ + public Type getProtoFieldType() { + return protoFieldType; + } + + /** Checks whether the repeated field is packed. */ + public boolean getIsPacked() { + return isPacked; + } + + /** + * Gets the fully qualified protobuf type name for the field, including its package name (ex: + * cel.expr.conformance.proto3.TestAllTypes.SingleStringWrapper). Returns an empty string for + * primitives. + */ + public String getFieldProtoTypeName() { + return fieldProtoTypeName; + } + + /** + * Must be public, used for codegen only. Do not use. + * + * @param fieldNumber Field index + * @param fieldName Name of the field + * @param javaType Canonical Java type name (ex: Long, Double, Float, Message... see + * com.google.protobuf.Descriptors#JavaType) + * @param encodingType Describes whether the field is a singular (primitives or messages), list + * or a map with respect to CEL. + * @param protoFieldType Protobuf Field Type (ex: INT32, SINT32, GROUP, MESSAGE... see + * com.google.protobuf.Descriptors#Type) + * @param fieldProtoTypeName Fully qualified protobuf type name for the field. Empty if the + * field is a primitive. + */ + @Internal + public FieldLiteDescriptor( + int fieldNumber, + String fieldName, + JavaType javaType, + EncodingType encodingType, // LIST, MAP, SINGULAR + Type protoFieldType, // INT32, SINT32, GROUP, MESSAGE... (See Descriptors#Type) + boolean isPacked, + String fieldProtoTypeName) { + this.fieldNumber = fieldNumber; + this.fieldName = Objects.requireNonNull(fieldName); + this.javaType = javaType; + this.encodingType = encodingType; + this.protoFieldType = protoFieldType; + this.isPacked = isPacked; + this.fieldProtoTypeName = Objects.requireNonNull(fieldProtoTypeName); + } + } + + protected CelLiteDescriptor(String version, List messageInfoList) { + Map protoFqnMap = + new HashMap<>(getMapInitialCapacity(messageInfoList.size())); + for (MessageLiteDescriptor msgInfo : messageInfoList) { + protoFqnMap.put(msgInfo.getProtoTypeName(), msgInfo); + } + + this.version = version; + this.protoFqnToDescriptors = Collections.unmodifiableMap(protoFqnMap); + } + + /** + * Returns a capacity that is sufficient to keep the map from being resized as long as it grows no + * larger than expectedSize and the load factor is β‰₯ its default (0.75). + */ + private static int getMapInitialCapacity(int expectedSize) { + if (expectedSize < 3) { + return expectedSize + 1; + } + + // See https://github.com/openjdk/jdk/commit/3e393047e12147a81e2899784b943923fc34da8e. 0.75 is + // used as a load factor. + return (int) ceil(expectedSize / 0.75); + } +} diff --git a/protobuf/src/main/java/dev/cel/protobuf/CelLiteDescriptorGenerator.java b/protobuf/src/main/java/dev/cel/protobuf/CelLiteDescriptorGenerator.java new file mode 100644 index 000000000..8c4eaea1c --- /dev/null +++ b/protobuf/src/main/java/dev/cel/protobuf/CelLiteDescriptorGenerator.java @@ -0,0 +1,217 @@ +// Copyright 2025 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.protobuf; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.io.Files; +import com.google.protobuf.DescriptorProtos.FileDescriptorProto; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.GeneratorNames; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.protobuf.JavaFileGenerator.GeneratedClass; +import dev.cel.protobuf.JavaFileGenerator.JavaFileGeneratorOption; +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.Callable; +import picocli.CommandLine; +import picocli.CommandLine.Model.OptionSpec; +import picocli.CommandLine.Option; + +final class CelLiteDescriptorGenerator implements Callable { + + private static final String DEFAULT_CEL_LITE_DESCRIPTOR_CLASS_SUFFIX = "CelLiteDescriptor"; + + @Option( + names = {"--out"}, + description = "Outpath for the CelLiteDescriptor") + private String outPath = ""; + + @Option( + names = {"--descriptor_set"}, + split = ",", + description = + "Paths to the descriptor set (from proto_library) that the CelLiteDescriptor is to be" + + " generated from (comma-separated)") + private List targetDescriptorSetPath = new ArrayList<>(); + + @Option( + names = {"--transitive_descriptor_set"}, + split = ",", + description = "Paths to the transitive set of descriptors (comma-separated)") + private List transitiveDescriptorSetPath = new ArrayList<>(); + + @Option( + names = {"--overridden_descriptor_class_suffix"}, + description = "Suffix name for the generated CelLiteDescriptor Java class") + private String overriddenDescriptorClassSuffix = ""; + + @Option( + names = {"--version"}, + description = "CEL-Java version") + private String version = ""; + + @Option( + names = {"--debug"}, + description = "Prints debug output") + private boolean debug = false; + + private DebugPrinter debugPrinter; + + @Override + public Integer call() throws Exception { + Preconditions.checkArgument(!targetDescriptorSetPath.isEmpty()); + + ImmutableList.Builder generatedClassesBuilder = ImmutableList.builder(); + for (String descriptorFilePath : targetDescriptorSetPath) { + debugPrinter.print("Target descriptor file path: " + descriptorFilePath); + String targetDescriptorProtoPath = extractProtoPath(descriptorFilePath); + debugPrinter.print("Target descriptor proto path: " + targetDescriptorProtoPath); + FileDescriptorSet transitiveDescriptorSet = + combineFileDescriptors(transitiveDescriptorSetPath); + + FileDescriptor targetFileDescriptor = null; + ImmutableSet transitiveFileDescriptors = + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(transitiveDescriptorSet); + for (FileDescriptor fd : transitiveFileDescriptors) { + if (fd.getFullName().equals(targetDescriptorProtoPath)) { + targetFileDescriptor = fd; + break; + } + } + + if (targetFileDescriptor == null) { + throw new IllegalArgumentException( + String.format( + "Target descriptor %s not found from transitive set of descriptors!", + targetDescriptorProtoPath)); + } + + ImmutableList generatedClasses = + codegenCelLiteDescriptors(targetFileDescriptor); + generatedClassesBuilder.addAll(generatedClasses); + } + + JavaFileGenerator.writeSrcJar(outPath, generatedClassesBuilder.build()); + + return 0; + } + + private ImmutableList codegenCelLiteDescriptors( + FileDescriptor targetFileDescriptor) throws Exception { + String javaPackageName = GeneratorNames.getFileJavaPackage(targetFileDescriptor.toProto()); + String javaClassName; + + List descriptors = targetFileDescriptor.getMessageTypes(); + if (descriptors.isEmpty()) { + throw new IllegalArgumentException("File descriptor does not contain any messages!"); + } + + ProtoDescriptorCollector descriptorCollector = + ProtoDescriptorCollector.newInstance(debugPrinter); + + ImmutableList.Builder generatedClassBuilder = ImmutableList.builder(); + for (Descriptor messageDescriptor : descriptors) { + javaClassName = messageDescriptor.getName(); + String javaSuffixName = + overriddenDescriptorClassSuffix.isEmpty() + ? DEFAULT_CEL_LITE_DESCRIPTOR_CLASS_SUFFIX + : overriddenDescriptorClassSuffix; + javaClassName += javaSuffixName; + + debugPrinter.print( + String.format( + "Fully qualified descriptor java class name: %s.%s", javaPackageName, javaClassName)); + + generatedClassBuilder.add( + JavaFileGenerator.generateClass( + JavaFileGeneratorOption.newBuilder() + .setVersion(version) + .setDescriptorClassName(javaClassName) + .setPackageName(javaPackageName) + .setDescriptorMetadataList( + descriptorCollector.collectCodegenMetadata(messageDescriptor)) + .build())); + } + + return generatedClassBuilder.build(); + } + + private String extractProtoPath(String descriptorPath) { + FileDescriptorSet fds = load(descriptorPath); + if (fds.getFileList().isEmpty()) { + throw new IllegalArgumentException( + "FileDescriptorSet did not contain any descriptors: " + descriptorPath); + } + + // A direct descriptor set may contain one or more files (ex: extensions), but the first + // argument is always the original .proto file. + FileDescriptorProto fileDescriptorProto = fds.getFile(0); + return fileDescriptorProto.getName(); + } + + private FileDescriptorSet combineFileDescriptors(List descriptorPaths) { + FileDescriptorSet.Builder combinedDescriptorBuilder = FileDescriptorSet.newBuilder(); + + for (String descriptorPath : descriptorPaths) { + FileDescriptorSet loadedFds = load(descriptorPath); + combinedDescriptorBuilder.addAllFile(loadedFds.getFileList()); + } + + return combinedDescriptorBuilder.build(); + } + + private static FileDescriptorSet load(String descriptorSetPath) { + try { + byte[] descriptorBytes = Files.toByteArray(new File(descriptorSetPath)); + return FileDescriptorSet.parseFrom(descriptorBytes, ExtensionRegistry.getEmptyRegistry()); + } catch (IOException e) { + throw new IllegalArgumentException( + "Failed to load FileDescriptorSet from path: " + descriptorSetPath, e); + } + } + + private void printAllFlags(CommandLine cmd) { + debugPrinter.print("Flag values:"); + debugPrinter.print("-------------------------------------------------------------"); + for (OptionSpec option : cmd.getCommandSpec().options()) { + debugPrinter.print(option.longestName() + ": " + option.getValue()); + } + debugPrinter.print("-------------------------------------------------------------"); + } + + private void initializeDebugPrinter() { + this.debugPrinter = DebugPrinter.newInstance(debug); + } + + public static void main(String[] args) { + CelLiteDescriptorGenerator celLiteDescriptorGenerator = new CelLiteDescriptorGenerator(); + CommandLine cmd = new CommandLine(celLiteDescriptorGenerator); + cmd.parseArgs(args); + celLiteDescriptorGenerator.initializeDebugPrinter(); + celLiteDescriptorGenerator.printAllFlags(cmd); + + int exitCode = cmd.execute(args); + System.exit(exitCode); + } + + CelLiteDescriptorGenerator() {} +} diff --git a/protobuf/src/main/java/dev/cel/protobuf/DebugPrinter.java b/protobuf/src/main/java/dev/cel/protobuf/DebugPrinter.java new file mode 100644 index 000000000..34a09ce98 --- /dev/null +++ b/protobuf/src/main/java/dev/cel/protobuf/DebugPrinter.java @@ -0,0 +1,36 @@ +// Copyright 2025 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.protobuf; + +import picocli.CommandLine.Help.Ansi; + +final class DebugPrinter { + + private final boolean debug; + + static DebugPrinter newInstance(boolean debug) { + return new DebugPrinter(debug); + } + + void print(String message) { + if (debug) { + System.out.println(Ansi.ON.string("@|cyan [CelLiteDescriptorGenerator] |@" + message)); + } + } + + private DebugPrinter(boolean debug) { + this.debug = debug; + } +} diff --git a/protobuf/src/main/java/dev/cel/protobuf/JavaFileGenerator.java b/protobuf/src/main/java/dev/cel/protobuf/JavaFileGenerator.java new file mode 100644 index 000000000..0eb177a96 --- /dev/null +++ b/protobuf/src/main/java/dev/cel/protobuf/JavaFileGenerator.java @@ -0,0 +1,139 @@ +// Copyright 2025 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.protobuf; + +import static java.nio.charset.StandardCharsets.UTF_8; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.io.ByteStreams; +// CEL-Internal-3 +import freemarker.template.Configuration; +import freemarker.template.DefaultObjectWrapperBuilder; +import freemarker.template.Template; +import freemarker.template.TemplateException; +import freemarker.template.Version; +import java.io.ByteArrayInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.StringWriter; +import java.io.Writer; +import java.util.Collection; +import java.util.Locale; +import java.util.zip.ZipEntry; +import java.util.zip.ZipOutputStream; + +final class JavaFileGenerator { + + private static final String HELPER_CLASS_TEMPLATE_FILE = "cel_lite_descriptor_template.txt"; + + static GeneratedClass generateClass(JavaFileGeneratorOption option) + throws IOException, TemplateException { + Version version = Configuration.VERSION_2_3_32; + Configuration cfg = new Configuration(version); + cfg.setClassForTemplateLoading(JavaFileGenerator.class, "templates/"); + cfg.setDefaultEncoding("UTF-8"); + cfg.setBooleanFormat("c"); + cfg.setAPIBuiltinEnabled(true); + cfg.setNumberFormat("#"); // Prevent thousandth separator in numbers (eg: 1000 instead of 1,000) + DefaultObjectWrapperBuilder wrapperBuilder = new DefaultObjectWrapperBuilder(version); + wrapperBuilder.setExposeFields(true); + cfg.setObjectWrapper(wrapperBuilder.build()); + + Template template = cfg.getTemplate(HELPER_CLASS_TEMPLATE_FILE); + Writer out = new StringWriter(); + template.process(option.getTemplateMap(), out); + + return GeneratedClass.create( + /* packageName= */ option.packageName(), + /* className= */ option.descriptorClassName(), + /* code= */ out.toString()); + } + + static void writeSrcJar(String srcjarFilePath, Collection generatedClasses) + throws IOException { + if (!srcjarFilePath.toLowerCase(Locale.getDefault()).endsWith(".srcjar")) { + throw new IllegalArgumentException("File must end with .srcjar, provided: " + srcjarFilePath); + } + try (FileOutputStream fos = new FileOutputStream(srcjarFilePath); + ZipOutputStream zos = new ZipOutputStream(fos)) { + for (GeneratedClass generatedClass : generatedClasses) { + // Replace com.foo.bar to com/foo/bar.java in order to conform with package location + String javaFileName = generatedClass.fullyQualifiedClassName().replace('.', '/') + ".java"; + ZipEntry entry = new ZipEntry(javaFileName); + zos.putNextEntry(entry); + + try (InputStream inputStream = + new ByteArrayInputStream(generatedClass.code().getBytes(UTF_8))) { + ByteStreams.copy(inputStream, zos); + } + } + + zos.closeEntry(); + } + } + + @AutoValue + abstract static class GeneratedClass { + abstract String fullyQualifiedClassName(); + + abstract String code(); + + static GeneratedClass create(String packageName, String className, String code) { + return new AutoValue_JavaFileGenerator_GeneratedClass(packageName + "." + className, code); + } + } + + @AutoValue + abstract static class JavaFileGeneratorOption { + abstract String packageName(); + + abstract String descriptorClassName(); + + abstract String version(); + + abstract ImmutableList descriptorMetadataList(); + + ImmutableMap getTemplateMap() { + return ImmutableMap.of( + "package_name", packageName(), + "descriptor_class_name", descriptorClassName(), + "version", version(), + "descriptor_metadata_list", descriptorMetadataList()); + } + + @AutoValue.Builder + abstract static class Builder { + abstract Builder setPackageName(String packageName); + + abstract Builder setDescriptorClassName(String className); + + abstract Builder setVersion(String version); + + abstract Builder setDescriptorMetadataList( + ImmutableList messageInfo); + + abstract JavaFileGeneratorOption build(); + } + + static Builder newBuilder() { + return new AutoValue_JavaFileGenerator_JavaFileGeneratorOption.Builder(); + } + } + + private JavaFileGenerator() {} +} diff --git a/protobuf/src/main/java/dev/cel/protobuf/LiteDescriptorCodegenMetadata.java b/protobuf/src/main/java/dev/cel/protobuf/LiteDescriptorCodegenMetadata.java new file mode 100644 index 000000000..19372b9b4 --- /dev/null +++ b/protobuf/src/main/java/dev/cel/protobuf/LiteDescriptorCodegenMetadata.java @@ -0,0 +1,142 @@ +// Copyright 2025 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.protobuf; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.common.annotations.Internal; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.EncodingType; +import org.jspecify.annotations.Nullable; + +/** + * LiteDescriptorCodegenMetadata holds metadata collected from a full protobuf descriptor pertinent + * for generating a {@link CelLiteDescriptor}. + * + *

The class properties here are almost identical to CelLiteDescriptor, except it contains + * extraneous information such as the fully qualified class names to support codegen, which do not + * need to be present on a CelLiteDescriptor instance. + * + *

Note: Properties must be of primitive types. + * + *

Note: JavaBeans prefix (e.g: getFoo) is required for compatibility with freemarker. + * + *

CEL Library Internals. Do Not Use. + */ +@AutoValue +@Internal +public abstract class LiteDescriptorCodegenMetadata { + + public abstract String getProtoTypeName(); + + public abstract ImmutableList getFieldDescriptors(); + + // @Nullable note: A java class name is not populated for maps, even though it behaves like a + // message. + public abstract @Nullable String getJavaClassName(); + + @AutoValue.Builder + abstract static class Builder { + + abstract Builder setProtoTypeName(String protoTypeName); + + abstract Builder setJavaClassName(String javaClassName); + + abstract ImmutableList.Builder fieldDescriptorsBuilder(); + + @CanIgnoreReturnValue + Builder addFieldDescriptor(FieldLiteDescriptorMetadata fieldDescriptor) { + this.fieldDescriptorsBuilder().add(fieldDescriptor); + return this; + } + + abstract LiteDescriptorCodegenMetadata build(); + } + + static Builder newBuilder() { + return new AutoValue_LiteDescriptorCodegenMetadata.Builder(); + } + + /** + * Metadata collected from a protobuf message's FieldDescriptor. This is used to codegen {@link + * FieldLiteDescriptor}. + */ + @AutoValue + public abstract static class FieldLiteDescriptorMetadata { + + public abstract int getFieldNumber(); + + public abstract String getFieldName(); + + // Fully-qualified name to the Java Type enumeration (ex: + // dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.INT) + public String getJavaTypeEnumName() { + return getFullyQualifiedEnumName(getJavaType()); + } + + // Fully-qualified name to the EncodingType enumeration (ex: + // dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.SINGULAR) + public String getEncodingTypeEnumName() { + return getFullyQualifiedEnumName(getEncodingType()); + } + + // Fully-qualified name to the Proto Type enumeration (ex: + // dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.INT) + public String getProtoFieldTypeEnumName() { + return getFullyQualifiedEnumName(getProtoFieldType()); + } + + public abstract boolean getIsPacked(); + + public abstract String getFieldProtoTypeName(); + + abstract FieldLiteDescriptor.JavaType getJavaType(); + + abstract FieldLiteDescriptor.Type getProtoFieldType(); + + abstract EncodingType getEncodingType(); + + private static String getFullyQualifiedEnumName(Object enumValue) { + String enumClassName = enumValue.getClass().getName(); + return (enumClassName + "." + enumValue).replace('$', '.'); + } + + @AutoValue.Builder + abstract static class Builder { + + abstract Builder setFieldNumber(int fieldNumber); + + abstract Builder setFieldName(String fieldName); + + abstract Builder setJavaType(FieldLiteDescriptor.JavaType javaTypeEnum); + + abstract Builder setEncodingType(EncodingType encodingTypeEnum); + + abstract Builder setProtoFieldType(FieldLiteDescriptor.Type protoFieldTypeEnum); + + abstract Builder setIsPacked(boolean isPacked); + + abstract Builder setFieldProtoTypeName(String fieldProtoTypeName); + + abstract FieldLiteDescriptorMetadata build(); + } + + static FieldLiteDescriptorMetadata.Builder newBuilder() { + return new AutoValue_LiteDescriptorCodegenMetadata_FieldLiteDescriptorMetadata.Builder() + .setFieldProtoTypeName(""); + } + } +} diff --git a/protobuf/src/main/java/dev/cel/protobuf/ProtoDescriptorCollector.java b/protobuf/src/main/java/dev/cel/protobuf/ProtoDescriptorCollector.java new file mode 100644 index 000000000..c2fe20557 --- /dev/null +++ b/protobuf/src/main/java/dev/cel/protobuf/ProtoDescriptorCollector.java @@ -0,0 +1,196 @@ +// Copyright 2025 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.protobuf; + +import static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Descriptors; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor.JavaType; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.GeneratorNames; +import dev.cel.common.internal.WellKnownProto; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.EncodingType; +import dev.cel.protobuf.LiteDescriptorCodegenMetadata.FieldLiteDescriptorMetadata; + +/** + * ProtoDescriptorCollector inspects a {@link FileDescriptor} to collect message information into + * {@link LiteDescriptorCodegenMetadata}. This is later utilized to create an instance of {@code + * MessageLiteDescriptor}. + */ +final class ProtoDescriptorCollector { + + private final DebugPrinter debugPrinter; + + ImmutableList collectCodegenMetadata(Descriptor descriptor) { + ImmutableList.Builder descriptorListBuilder = + ImmutableList.builder(); + ImmutableList descriptorList = + collectNested(descriptor).stream() + // Don't collect WKTs. They are included in the default descriptor pool. + .filter(d -> !WellKnownProto.getByTypeName(d.getFullName()).isPresent()) + .collect(toImmutableList()); + + for (Descriptor messageDescriptor : descriptorList) { + LiteDescriptorCodegenMetadata.Builder descriptorCodegenBuilder = + LiteDescriptorCodegenMetadata.newBuilder(); + for (Descriptors.FieldDescriptor fieldDescriptor : messageDescriptor.getFields()) { + FieldLiteDescriptorMetadata.Builder fieldDescriptorCodegenBuilder = + FieldLiteDescriptorMetadata.newBuilder() + .setFieldNumber(fieldDescriptor.getNumber()) + .setFieldName(fieldDescriptor.getName()) + .setIsPacked(fieldDescriptor.isPacked()) + .setJavaType(adaptJavaType(fieldDescriptor.getJavaType())) + .setProtoFieldType(adaptFieldProtoType(fieldDescriptor.getType())); + + switch (fieldDescriptor.getJavaType()) { + case ENUM: + fieldDescriptorCodegenBuilder.setFieldProtoTypeName( + fieldDescriptor.getEnumType().getFullName()); + break; + case MESSAGE: + fieldDescriptorCodegenBuilder.setFieldProtoTypeName( + fieldDescriptor.getMessageType().getFullName()); + break; + default: + break; + } + + if (fieldDescriptor.isMapField()) { + fieldDescriptorCodegenBuilder.setEncodingType(EncodingType.MAP); + } else if (fieldDescriptor.isRepeated()) { + fieldDescriptorCodegenBuilder.setEncodingType(EncodingType.LIST); + } else { + fieldDescriptorCodegenBuilder.setEncodingType(EncodingType.SINGULAR); + } + + descriptorCodegenBuilder.addFieldDescriptor(fieldDescriptorCodegenBuilder.build()); + + debugPrinter.print( + String.format( + "Collecting message %s, for field %s, type: %s", + messageDescriptor.getFullName(), + fieldDescriptor.getFullName(), + fieldDescriptor.getType())); + } + + descriptorCodegenBuilder.setProtoTypeName(messageDescriptor.getFullName()); + // Maps are resolved as an actual Java map, and doesn't have a MessageLite.Builder associated. + if (!messageDescriptor.getOptions().getMapEntry()) { + String sanitizedJavaClassName = + GeneratorNames.getBytecodeClassName(messageDescriptor).replace('$', '.'); + descriptorCodegenBuilder.setJavaClassName(sanitizedJavaClassName); + } + + descriptorListBuilder.add(descriptorCodegenBuilder.build()); + } + + return descriptorListBuilder.build(); + } + + static ProtoDescriptorCollector newInstance(DebugPrinter debugPrinter) { + return new ProtoDescriptorCollector(debugPrinter); + } + + private static FieldLiteDescriptor.Type adaptFieldProtoType( + Descriptors.FieldDescriptor.Type type) { + switch (type) { + case DOUBLE: + return FieldLiteDescriptor.Type.DOUBLE; + case FLOAT: + return FieldLiteDescriptor.Type.FLOAT; + case INT64: + return FieldLiteDescriptor.Type.INT64; + case UINT64: + return FieldLiteDescriptor.Type.UINT64; + case INT32: + return FieldLiteDescriptor.Type.INT32; + case FIXED64: + return FieldLiteDescriptor.Type.FIXED64; + case FIXED32: + return FieldLiteDescriptor.Type.FIXED32; + case BOOL: + return FieldLiteDescriptor.Type.BOOL; + case STRING: + return FieldLiteDescriptor.Type.STRING; + case MESSAGE: + return FieldLiteDescriptor.Type.MESSAGE; + case BYTES: + return FieldLiteDescriptor.Type.BYTES; + case UINT32: + return FieldLiteDescriptor.Type.UINT32; + case ENUM: + return FieldLiteDescriptor.Type.ENUM; + case SFIXED32: + return FieldLiteDescriptor.Type.SFIXED32; + case SFIXED64: + return FieldLiteDescriptor.Type.SFIXED64; + case SINT32: + return FieldLiteDescriptor.Type.SINT32; + case SINT64: + return FieldLiteDescriptor.Type.SINT64; + case GROUP: + return FieldLiteDescriptor.Type.GROUP; + } + + throw new IllegalArgumentException("Unknown Type: " + type); + } + + private static FieldLiteDescriptor.JavaType adaptJavaType(JavaType javaType) { + switch (javaType) { + case INT: + return FieldLiteDescriptor.JavaType.INT; + case LONG: + return FieldLiteDescriptor.JavaType.LONG; + case FLOAT: + return FieldLiteDescriptor.JavaType.FLOAT; + case DOUBLE: + return FieldLiteDescriptor.JavaType.DOUBLE; + case BOOLEAN: + return FieldLiteDescriptor.JavaType.BOOLEAN; + case STRING: + return FieldLiteDescriptor.JavaType.STRING; + case BYTE_STRING: + return FieldLiteDescriptor.JavaType.BYTE_STRING; + case ENUM: + return FieldLiteDescriptor.JavaType.ENUM; + case MESSAGE: + return FieldLiteDescriptor.JavaType.MESSAGE; + } + + throw new IllegalArgumentException("Unknown JavaType: " + javaType); + } + + private static ImmutableSet collectNested(Descriptor descriptor) { + ImmutableSet.Builder builder = ImmutableSet.builder(); + collectNested(builder, descriptor); + return builder.build(); + } + + private static void collectNested( + ImmutableSet.Builder builder, Descriptor descriptor) { + builder.add(descriptor); + for (Descriptor nested : descriptor.getNestedTypes()) { + collectNested(builder, nested); + } + } + + private ProtoDescriptorCollector(DebugPrinter debugPrinter) { + this.debugPrinter = debugPrinter; + } +} diff --git a/protobuf/src/main/java/dev/cel/protobuf/templates/cel_lite_descriptor_template.txt b/protobuf/src/main/java/dev/cel/protobuf/templates/cel_lite_descriptor_template.txt new file mode 100644 index 000000000..2d8515146 --- /dev/null +++ b/protobuf/src/main/java/dev/cel/protobuf/templates/cel_lite_descriptor_template.txt @@ -0,0 +1,76 @@ +// Copyright 2025 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. + +/** + * Generated by CEL-Java library. DO NOT EDIT! + * Version: ${version} + */ + +package ${package_name}; + +import dev.cel.common.annotations.Generated; +import dev.cel.protobuf.CelLiteDescriptor; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Generated("dev.cel.protobuf.CelLiteDescriptorGenerator") +public final class ${descriptor_class_name} extends CelLiteDescriptor { + + private static final ${descriptor_class_name} DESCRIPTOR = new ${descriptor_class_name}(); + + public static ${descriptor_class_name} getDescriptor() { + return DESCRIPTOR; + } + + private static List newDescriptors() { + List descriptors = new ArrayList<>(${descriptor_metadata_list?size}); + List fieldDescriptors; + <#list descriptor_metadata_list as descriptor_metadata> + + fieldDescriptors = new ArrayList<>(${descriptor_metadata.fieldDescriptors?size}); + <#list descriptor_metadata.fieldDescriptors as field_descriptor> + fieldDescriptors.add(new FieldLiteDescriptor( + ${field_descriptor.fieldNumber}, + "${field_descriptor.fieldName}", + ${field_descriptor.javaTypeEnumName}, + ${field_descriptor.encodingTypeEnumName}, + ${field_descriptor.protoFieldTypeEnumName}, + ${field_descriptor.isPacked}, + "${field_descriptor.fieldProtoTypeName}" + )); + + + descriptors.add( + new MessageLiteDescriptor( + "${descriptor_metadata.protoTypeName}", + fieldDescriptors, + <#if descriptor_metadata.javaClassName??> + ${descriptor_metadata.javaClassName}::newBuilder + <#else> + () -> null + + ) + ); + + + return Collections.unmodifiableList(descriptors); + } + + private ${descriptor_class_name}() { + super("${version}", newDescriptors()); + } +} \ No newline at end of file diff --git a/protobuf/src/test/java/dev/cel/protobuf/BUILD.bazel b/protobuf/src/test/java/dev/cel/protobuf/BUILD.bazel new file mode 100644 index 000000000..58e298b29 --- /dev/null +++ b/protobuf/src/test/java/dev/cel/protobuf/BUILD.bazel @@ -0,0 +1,38 @@ +load("@rules_java//java:defs.bzl", "java_test") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, +) + +java_test( + name = "cel_lite_descriptor_test", + srcs = ["CelLiteDescriptorTest.java"], + test_class = "dev.cel.protobuf.CelLiteDescriptorTest", + deps = [ + "//:java_truth", + "//protobuf:cel_lite_descriptor", + "//testing/protos:test_all_types_cel_java_proto3_lite", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto_lite", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "proto_descriptor_collector_test", + srcs = ["ProtoDescriptorCollectorTest.java"], + test_class = "dev.cel.protobuf.ProtoDescriptorCollectorTest", + runtime_deps = ["@maven//:com_google_protobuf_protobuf_java"], + deps = [ + "//:java_truth", + "//protobuf:debug_printer", + "//protobuf:lite_descriptor_codegen_metadata", + "//protobuf:proto_descriptor_collector", + "//testing/protos:multi_file_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) diff --git a/protobuf/src/test/java/dev/cel/protobuf/CelLiteDescriptorTest.java b/protobuf/src/test/java/dev/cel/protobuf/CelLiteDescriptorTest.java new file mode 100644 index 000000000..1ceed29bb --- /dev/null +++ b/protobuf/src/test/java/dev/cel/protobuf/CelLiteDescriptorTest.java @@ -0,0 +1,149 @@ +// Copyright 2025 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.protobuf; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.expr.conformance.proto3.TestAllTypesCelLiteDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.EncodingType; +import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.JavaType; +import dev.cel.protobuf.CelLiteDescriptor.MessageLiteDescriptor; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelLiteDescriptorTest { + + private static final TestAllTypesCelLiteDescriptor TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR = + TestAllTypesCelLiteDescriptor.getDescriptor(); + + @Test + public void getProtoTypeNamesToDescriptors_containsAllMessages() { + Map protoNamesToDescriptors = + TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR.getProtoTypeNamesToDescriptors(); + + assertThat(protoNamesToDescriptors).containsKey("cel.expr.conformance.proto3.TestAllTypes"); + assertThat(protoNamesToDescriptors) + .containsKey("cel.expr.conformance.proto3.TestAllTypes.NestedMessage"); + } + + @Test + public void testAllTypesMessageLiteDescriptor_fullyQualifiedNames() { + MessageLiteDescriptor testAllTypesDescriptor = + TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR + .getProtoTypeNamesToDescriptors() + .get("cel.expr.conformance.proto3.TestAllTypes"); + + assertThat(testAllTypesDescriptor.getProtoTypeName()) + .isEqualTo("cel.expr.conformance.proto3.TestAllTypes"); + } + + @Test + public void fieldDescriptor_getByFieldNumber() { + MessageLiteDescriptor testAllTypesDescriptor = + TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR + .getProtoTypeNamesToDescriptors() + .get("cel.expr.conformance.proto3.TestAllTypes"); + + FieldLiteDescriptor fieldLiteDescriptor = testAllTypesDescriptor.getByFieldNumberOrThrow(14); + + assertThat(fieldLiteDescriptor.getFieldName()).isEqualTo("single_string"); + } + + @Test + public void fieldDescriptor_scalarField() { + MessageLiteDescriptor testAllTypesDescriptor = + TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR + .getProtoTypeNamesToDescriptors() + .get("cel.expr.conformance.proto3.TestAllTypes"); + FieldLiteDescriptor fieldLiteDescriptor = + testAllTypesDescriptor.getByFieldNameOrThrow("single_string"); + + assertThat(fieldLiteDescriptor.getEncodingType()).isEqualTo(EncodingType.SINGULAR); + assertThat(fieldLiteDescriptor.getJavaType()).isEqualTo(JavaType.STRING); + assertThat(fieldLiteDescriptor.getProtoFieldType()).isEqualTo(FieldLiteDescriptor.Type.STRING); + } + + @Test + public void fieldDescriptor_primitiveField_fullyQualifiedNames() { + MessageLiteDescriptor testAllTypesDescriptor = + TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR + .getProtoTypeNamesToDescriptors() + .get("cel.expr.conformance.proto3.TestAllTypes"); + FieldLiteDescriptor fieldLiteDescriptor = + testAllTypesDescriptor.getByFieldNameOrThrow("single_string"); + + assertThat(fieldLiteDescriptor.getFieldProtoTypeName()).isEmpty(); + } + + @Test + public void fieldDescriptor_mapField() { + MessageLiteDescriptor testAllTypesDescriptor = + TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR + .getProtoTypeNamesToDescriptors() + .get("cel.expr.conformance.proto3.TestAllTypes"); + FieldLiteDescriptor fieldLiteDescriptor = + testAllTypesDescriptor.getByFieldNameOrThrow("map_bool_string"); + + assertThat(fieldLiteDescriptor.getEncodingType()).isEqualTo(EncodingType.MAP); + assertThat(fieldLiteDescriptor.getJavaType()).isEqualTo(JavaType.MESSAGE); + assertThat(fieldLiteDescriptor.getProtoFieldType()).isEqualTo(FieldLiteDescriptor.Type.MESSAGE); + } + + @Test + public void fieldDescriptor_repeatedField() { + MessageLiteDescriptor testAllTypesDescriptor = + TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR + .getProtoTypeNamesToDescriptors() + .get("cel.expr.conformance.proto3.TestAllTypes"); + FieldLiteDescriptor fieldLiteDescriptor = + testAllTypesDescriptor.getByFieldNameOrThrow("repeated_int64"); + + assertThat(fieldLiteDescriptor.getEncodingType()).isEqualTo(EncodingType.LIST); + assertThat(fieldLiteDescriptor.getJavaType()).isEqualTo(JavaType.LONG); + assertThat(fieldLiteDescriptor.getIsPacked()).isTrue(); + assertThat(fieldLiteDescriptor.getProtoFieldType()).isEqualTo(FieldLiteDescriptor.Type.INT64); + } + + @Test + public void fieldDescriptor_nestedMessage() { + MessageLiteDescriptor testAllTypesDescriptor = + TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR + .getProtoTypeNamesToDescriptors() + .get("cel.expr.conformance.proto3.TestAllTypes"); + FieldLiteDescriptor fieldLiteDescriptor = + testAllTypesDescriptor.getByFieldNameOrThrow("standalone_message"); + + assertThat(fieldLiteDescriptor.getEncodingType()).isEqualTo(EncodingType.SINGULAR); + assertThat(fieldLiteDescriptor.getJavaType()).isEqualTo(JavaType.MESSAGE); + assertThat(fieldLiteDescriptor.getProtoFieldType()).isEqualTo(FieldLiteDescriptor.Type.MESSAGE); + } + + @Test + public void fieldDescriptor_nestedMessage_fullyQualifiedNames() { + MessageLiteDescriptor testAllTypesDescriptor = + TEST_ALL_TYPES_CEL_LITE_DESCRIPTOR + .getProtoTypeNamesToDescriptors() + .get("cel.expr.conformance.proto3.TestAllTypes"); + FieldLiteDescriptor fieldLiteDescriptor = + testAllTypesDescriptor.getByFieldNameOrThrow("standalone_message"); + + assertThat(fieldLiteDescriptor.getFieldProtoTypeName()) + .isEqualTo("cel.expr.conformance.proto3.TestAllTypes.NestedMessage"); + } +} diff --git a/protobuf/src/test/java/dev/cel/protobuf/ProtoDescriptorCollectorTest.java b/protobuf/src/test/java/dev/cel/protobuf/ProtoDescriptorCollectorTest.java new file mode 100644 index 000000000..9e1e30005 --- /dev/null +++ b/protobuf/src/test/java/dev/cel/protobuf/ProtoDescriptorCollectorTest.java @@ -0,0 +1,75 @@ +// Copyright 2025 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.protobuf; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.expr.conformance.proto3.NestedTestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.testing.testdata.MultiFile; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class ProtoDescriptorCollectorTest { + + @Test + public void collectCodegenMetadata_containsAllDescriptors() { + ProtoDescriptorCollector collector = + ProtoDescriptorCollector.newInstance(DebugPrinter.newInstance(false)); + + ImmutableList testAllTypesDescriptors = + collector.collectCodegenMetadata(TestAllTypes.getDescriptor()); + ImmutableList nestedTestAllTypesDescriptors = + collector.collectCodegenMetadata(NestedTestAllTypes.getDescriptor()); + + // All proto messages, including transitive ones + maps + assertThat(testAllTypesDescriptors).hasSize(165); + assertThat(nestedTestAllTypesDescriptors).hasSize(1); + } + + @Test + public void collectCodegenMetadata_withProtoDependencies_containsAllDescriptors() { + ProtoDescriptorCollector collector = + ProtoDescriptorCollector.newInstance(DebugPrinter.newInstance(false)); + + ImmutableList descriptors = + collector.collectCodegenMetadata(MultiFile.getDescriptor()); + + assertThat(descriptors).hasSize(3); + assertThat( + descriptors.stream() + .filter(d -> d.getProtoTypeName().equals("dev.cel.testing.testdata.MultiFile")) + .findAny()) + .isPresent(); + } + + @Test + public void collectCodegenMetadata_withProtoDependencies_doesNotContainImportedProto() { + ProtoDescriptorCollector collector = + ProtoDescriptorCollector.newInstance(DebugPrinter.newInstance(false)); + + ImmutableList descriptors = + collector.collectCodegenMetadata(MultiFile.getDescriptor()); + + assertThat( + descriptors.stream() + .filter(d -> d.getProtoTypeName().equals("dev.cel.testing.testdata.SingleFile")) + .findAny()) + .isEmpty(); + } +} diff --git a/publish/BUILD.bazel b/publish/BUILD.bazel new file mode 100644 index 000000000..69622aada --- /dev/null +++ b/publish/BUILD.bazel @@ -0,0 +1,318 @@ +load("@bazel_common//tools/maven:pom_file.bzl", "pom_file") +load("@rules_jvm_external//:defs.bzl", "java_export") +load("//publish:cel_version.bzl", "CEL_VERSION") + +# Note: These targets must reference the build targets in `src` directly in +# order to properly generate the maven dependencies in pom.xml. + +# keep sorted +COMMON_TARGETS = [ + "//common/src/main/java/dev/cel/common:cel_ast", + "//common/src/main/java/dev/cel/common:cel_descriptor_util", + "//common/src/main/java/dev/cel/common:cel_exception", + "//common/src/main/java/dev/cel/common:cel_source", + "//common/src/main/java/dev/cel/common:container", + "//common/src/main/java/dev/cel/common:error_codes", + "//common/src/main/java/dev/cel/common:operator", + "//common/src/main/java/dev/cel/common:options", + "//common/src/main/java/dev/cel/common:source", + "//common/src/main/java/dev/cel/common/internal", + "//common/src/main/java/dev/cel/common/internal:cel_descriptor_pools", + "//common/src/main/java/dev/cel/common/internal:file_descriptor_converter", + "//common/src/main/java/dev/cel/common/internal:safe_string_formatter", + "//common/src/main/java/dev/cel/common/types:cel_types", + "//common/src/main/java/dev/cel/common/types:message_type_provider", + "//common/src/main/java/dev/cel/common/values", + "//common/src/main/java/dev/cel/common/values:cel_value", +] + +# keep sorted +RUNTIME_TARGETS = [ + "//runtime/src/main/java/dev/cel/runtime", + "//runtime/src/main/java/dev/cel/runtime:base", + "//runtime/src/main/java/dev/cel/runtime:interpreter", + "//runtime/src/main/java/dev/cel/runtime:late_function_binding", + "//runtime/src/main/java/dev/cel/runtime:runtime_factory", + "//runtime/src/main/java/dev/cel/runtime:runtime_helpers", + "//runtime/src/main/java/dev/cel/runtime:runtime_legacy_impl", + "//runtime/src/main/java/dev/cel/runtime:standard_functions", + "//runtime/src/main/java/dev/cel/runtime:unknown_attributes", +] + +# keep sorted +LITE_RUNTIME_TARGETS = [ + "//common/src/main/java/dev/cel/common:proto_ast_android", # Note: included due to generated protos requiring protolite dependency + "//common/src/main/java/dev/cel/common/values:proto_message_lite_value_provider_android", + "//protobuf/src/main/java/dev/cel/protobuf:cel_lite_descriptor", + "//runtime/src/main/java/dev/cel/runtime:lite_runtime_android", + "//runtime/src/main/java/dev/cel/runtime:lite_runtime_factory_android", + "//runtime/src/main/java/dev/cel/runtime:lite_runtime_library_android", + "//runtime/src/main/java/dev/cel/runtime:standard_functions_android", +] + +# keep sorted +COMPILER_TARGETS = [ + "//checker/src/main/java/dev/cel/checker:checker", + "//checker/src/main/java/dev/cel/checker:checker_builder", + "//checker/src/main/java/dev/cel/checker:proto_expr_visitor", + "//checker/src/main/java/dev/cel/checker:proto_type_mask", + "//compiler/src/main/java/dev/cel/compiler", + "//compiler/src/main/java/dev/cel/compiler:compiler_builder", + "//parser/src/main/java/dev/cel/parser", + "//parser/src/main/java/dev/cel/parser:parser_builder", + "//parser/src/main/java/dev/cel/parser:parser_factory", + "//parser/src/main/java/dev/cel/parser:unparser", +] + +# keep sorted +VALIDATOR_TARGETS = [ + "//validator/src/main/java/dev/cel/validator", + "//validator/src/main/java/dev/cel/validator:ast_validator", + "//validator/src/main/java/dev/cel/validator:validator_builder", + "//validator/src/main/java/dev/cel/validator:validator_impl", + "//validator/src/main/java/dev/cel/validator/validators:duration", + "//validator/src/main/java/dev/cel/validator/validators:homogeneous_literal", + "//validator/src/main/java/dev/cel/validator/validators:regex", + "//validator/src/main/java/dev/cel/validator/validators:timestamp", +] + +# keep sorted +OPTIMIZER_TARGETS = [ + "//optimizer/src/main/java/dev/cel/optimizer", + "//optimizer/src/main/java/dev/cel/optimizer:ast_optimizer", + "//optimizer/src/main/java/dev/cel/optimizer:mutable_ast", + "//optimizer/src/main/java/dev/cel/optimizer:optimization_exception", + "//optimizer/src/main/java/dev/cel/optimizer:optimizer_builder", + "//optimizer/src/main/java/dev/cel/optimizer:optimizer_impl", + "//optimizer/src/main/java/dev/cel/optimizer/optimizers:common_subexpression_elimination", + "//optimizer/src/main/java/dev/cel/optimizer/optimizers:constant_folding", + "//optimizer/src/main/java/dev/cel/optimizer/optimizers:inlining", +] + +# keep sorted +POLICY_COMPILER_TARGETS = [ + "//policy/src/main/java/dev/cel/policy:compiled_rule", + "//policy/src/main/java/dev/cel/policy:compiler", + "//policy/src/main/java/dev/cel/policy:compiler_builder", + "//policy/src/main/java/dev/cel/policy:compiler_factory", + "//policy/src/main/java/dev/cel/policy:parser", + "//policy/src/main/java/dev/cel/policy:parser_builder", + "//policy/src/main/java/dev/cel/policy:parser_factory", + "//policy/src/main/java/dev/cel/policy:policy", + "//policy/src/main/java/dev/cel/policy:policy_parser_context", + "//policy/src/main/java/dev/cel/policy:source", + "//policy/src/main/java/dev/cel/policy:validation_exception", + "//policy/src/main/java/dev/cel/policy:yaml_parser", +] + +# keep sorted +V1ALPHA1_AST_TARGETS = [ + "//common/src/main/java/dev/cel/common:proto_v1alpha1_ast", +] + +# keep sorted +CANONICAL_AST_TARGETS = [ + "//common/src/main/java/dev/cel/common:proto_ast", +] + +# keep sorted +EXTENSION_TARGETS = [ + "//extensions/src/main/java/dev/cel/extensions", + "//extensions/src/main/java/dev/cel/extensions:optional_library", +] + +# keep sorted +BUNDLE_TARGETS = [ + "//bundle/src/main/java/dev/cel/bundle:cel", + "//bundle/src/main/java/dev/cel/bundle:environment", + "//bundle/src/main/java/dev/cel/bundle:environment_yaml_parser", +] + +CEL_MISC_TARGETS = BUNDLE_TARGETS + EXTENSION_TARGETS + OPTIMIZER_TARGETS + VALIDATOR_TARGETS + POLICY_COMPILER_TARGETS + +# Excluded from the JAR as their source of truth is elsewhere +EXCLUDED_TARGETS = [ + "@com_google_googleapis//google/api/expr/v1alpha1:expr_java_proto", +] + +JAVA_DOC_OPTIONS = [ + "-Xdoclint:none", + "--ignore-source-errors", +] + +pom_file( + name = "cel_common_pom", + substitutions = { + "CEL_VERSION": CEL_VERSION, + "CEL_ARTIFACT_ID": "common", + "PACKAGE_NAME": "CEL Java Common", + "PACKAGE_DESC": "Common dependencies for Common Expression Language for Java.", + }, + targets = COMMON_TARGETS, + template_file = "pom_template.xml", +) + +java_export( + name = "cel_common", + deploy_env = EXCLUDED_TARGETS, + javadocopts = JAVA_DOC_OPTIONS, + maven_coordinates = "dev.cel:common:%s" % CEL_VERSION, + pom_template = ":cel_common_pom", + exports = COMMON_TARGETS, +) + +pom_file( + name = "cel_pom", + substitutions = { + "CEL_VERSION": CEL_VERSION, + "CEL_ARTIFACT_ID": "cel", + "PACKAGE_NAME": "CEL Java", + "PACKAGE_DESC": "Common Expression Language for Java. This include both the compilation and runtime packages.", + }, + targets = [ + ":cel_common", + ":cel_protobuf", + ":cel_compiler", + ":cel_runtime", + ":cel_v1alpha1", + ] + CEL_MISC_TARGETS, + template_file = "pom_template.xml", +) + +java_export( + name = "cel", + deploy_env = EXCLUDED_TARGETS, + javadocopts = JAVA_DOC_OPTIONS, + maven_coordinates = "dev.cel:cel:%s" % CEL_VERSION, + pom_template = ":cel_pom", + exports = [ + ":cel_common", + ":cel_compiler", + ":cel_protobuf", + ":cel_runtime", + ":cel_v1alpha1", + ] + CEL_MISC_TARGETS, +) + +pom_file( + name = "cel_compiler_pom", + substitutions = { + "CEL_VERSION": CEL_VERSION, + "CEL_ARTIFACT_ID": "compiler", + "PACKAGE_NAME": "CEL Java Compiler", + "PACKAGE_DESC": "Common Expression Language Compiler for Java", + }, + targets = [ + ":cel_common", + ":cel_protobuf", + ] + COMPILER_TARGETS, + template_file = "pom_template.xml", +) + +java_export( + name = "cel_compiler", + deploy_env = EXCLUDED_TARGETS, + javadocopts = JAVA_DOC_OPTIONS, + maven_coordinates = "dev.cel:compiler:%s" % CEL_VERSION, + pom_template = ":cel_compiler_pom", + exports = [ + ":cel_common", + ":cel_protobuf", + ] + COMPILER_TARGETS, +) + +pom_file( + name = "cel_runtime_pom", + substitutions = { + "CEL_VERSION": CEL_VERSION, + "CEL_ARTIFACT_ID": "runtime", + "PACKAGE_NAME": "CEL Java Runtime", + "PACKAGE_DESC": "Common Expression Language Runtime for Java", + }, + targets = [ + ":cel_common", + ] + RUNTIME_TARGETS, + template_file = "pom_template.xml", +) + +java_export( + name = "cel_runtime", + deploy_env = EXCLUDED_TARGETS, + javadocopts = JAVA_DOC_OPTIONS, + maven_coordinates = "dev.cel:runtime:%s" % CEL_VERSION, + pom_template = ":cel_runtime_pom", + exports = [ + ":cel_common", + ] + RUNTIME_TARGETS, +) + +pom_file( + name = "cel_v1alpha1_pom", + substitutions = { + "CEL_VERSION": CEL_VERSION, + "CEL_ARTIFACT_ID": "v1alpha1", + "PACKAGE_NAME": "CEL Java v1alpha1 Utility", + "PACKAGE_DESC": "Common Expression Language Utility for supporting v1alpha1 protobuf definitions", + }, + targets = [ + ":cel_common", + ] + V1ALPHA1_AST_TARGETS, + template_file = "pom_template.xml", +) + +java_export( + name = "cel_v1alpha1", + deploy_env = EXCLUDED_TARGETS, + javadocopts = JAVA_DOC_OPTIONS, + maven_coordinates = "dev.cel:v1alpha1:%s" % CEL_VERSION, + pom_template = ":cel_v1alpha1_pom", + exports = [ + ":cel_common", + ] + V1ALPHA1_AST_TARGETS, +) + +pom_file( + name = "cel_protobuf_pom", + substitutions = { + "CEL_VERSION": CEL_VERSION, + "CEL_ARTIFACT_ID": "protobuf", + "PACKAGE_NAME": "CEL Java Protobuf adapter", + "PACKAGE_DESC": "Common Expression Language Adapter for converting canonical cel.expr protobuf definitions", + }, + targets = [ + ":cel_common", + ] + CANONICAL_AST_TARGETS, + template_file = "pom_template.xml", +) + +java_export( + name = "cel_protobuf", + deploy_env = EXCLUDED_TARGETS, + javadocopts = JAVA_DOC_OPTIONS, + maven_coordinates = "dev.cel:protobuf:%s" % CEL_VERSION, + pom_template = ":cel_protobuf_pom", + exports = [ + ":cel_common", + ] + CANONICAL_AST_TARGETS, +) + +pom_file( + name = "cel_runtime_android_pom", + substitutions = { + "CEL_VERSION": CEL_VERSION, + "CEL_ARTIFACT_ID": "runtime-android", + "PACKAGE_NAME": "CEL Java Runtime for Android", + "PACKAGE_DESC": "Common Expression Language Lite Runtime for Java (Suitable for Android)", + }, + targets = LITE_RUNTIME_TARGETS, + template_file = "pom_template.xml", +) + +java_export( + name = "cel_runtime_android", + deploy_env = EXCLUDED_TARGETS, + javadocopts = JAVA_DOC_OPTIONS, + maven_coordinates = "dev.cel:runtime-android:%s" % CEL_VERSION, + pom_template = ":cel_runtime_android_pom", + exports = LITE_RUNTIME_TARGETS, +) diff --git a/publish/cel_version.bzl b/publish/cel_version.bzl new file mode 100644 index 000000000..4ceb4bfa4 --- /dev/null +++ b/publish/cel_version.bzl @@ -0,0 +1,15 @@ +# Copyright 2022 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. +"""Maven artifact version for CEL.""" +CEL_VERSION = "0.13.1" diff --git a/publish/pom_template.xml b/publish/pom_template.xml new file mode 100644 index 000000000..ec5c08be6 --- /dev/null +++ b/publish/pom_template.xml @@ -0,0 +1,64 @@ + + + + + + + + + + + + + + + + + CEL_ARTIFACT_ID + + + {dependencies} + + + + PACKAGE_DESC + + + + cel-dev@google.com + CEL Dev Team + Google + https://google.com + + + dev.cel + + + Apache License, Version 2.0 + https://www.apache.org/licenses/LICENSE-2.0.txt + + + + 4.0.0 + PACKAGE_NAME + jar + + + oss-parent + org.sonatype.oss + 7 + + + + scm:git:git://github.com/cel-expr/cel-java.git + + https://github.com/cel-expr/cel-java/tree/main + + + https://github.com/cel-expr/cel-java + + CEL_VERSION + diff --git a/publish/publish.sh b/publish/publish.sh new file mode 100755 index 000000000..28d0f0f53 --- /dev/null +++ b/publish/publish.sh @@ -0,0 +1,116 @@ +#!/bin/bash +# Copyright 2022 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. + +# +# Publishes CEL to a Maven repository. +# +# To push locally, just run the script. On MacOS by default, the artifact lives in ~/.m2/repository +# To publish a SNAPSHOT version, run with -snapshot (-s) flag: "publish.sh --snapshot". Snapshots can be found in https://s01.oss.sonatype.org/#nexus-search;quick~dev.cel +# To publish a RELEASE version remotely, run with -release (-r) flag: "publish.sh --release". Note that released maven artifacts are permanent and can never be deleted under any circumstances. + +# Note, to publish remotely: +# 1. You must create a pgp certificate and upload it to keyserver.ubuntu.com. See https://blog.sonatype.com/2010/01/how-to-generate-pgp-signatures-with-maven/ +# 2. You will need to enter the key's password. The prompt appears in GUI, not in terminal. The publish operation will eventually timeout if the password is not entered. + +# Note, to run script: Bazel and jq are required + +ALL_TARGETS=("//publish:cel_common.publish" "//publish:cel.publish" "//publish:cel_compiler.publish" "//publish:cel_runtime.publish" "//publish:cel_v1alpha1.publish" "//publish:cel_protobuf.publish" "//publish:cel_runtime_android.publish") +JDK8_FLAGS="--java_language_version=8 --java_runtime_version=8" + +function publish_maven_remote() { + maven_repo_url=$1 + # Credentials should be read from maven config (settings.xml) once it + # is supported by bazelbuild: + # https://github.com/bazelbuild/rules_jvm_external/issues/679 + read -p "maven_user: " maven_user + read -s -p "maven_password: " maven_password + + # Upload artifacts to staging repository + for PUBLISH_TARGET in "${ALL_TARGETS[@]}" + do + bazel run --stamp \ + --define "maven_repo=$maven_repo_url" \ + --define gpg_sign=true \ + --define "maven_user=$maven_user" \ + --define "maven_password=$maven_password" \ + $PUBLISH_TARGET \ + $JDK8_FLAGS + done + + # Begin creating a staging deployment in central maven + auth_token=$(printf "%s:%s" "$maven_user" "$maven_password" | base64) + repository_key=$(curl -s -X GET \ + -H "Authorization:Bearer $auth_token" \ + "https://ossrh-staging-api.central.sonatype.com/manual/search/repositories?ip=any&profile_id=dev.cel" | \ + jq -r '.repositories[] | select(.state=="open") | .key' | head -n 1) + echo "" + if [[ -n "$repository_key" ]]; then + echo "Open repository key:" + echo "$repository_key" + + echo "Creating deployment..." + post_response=$(curl -s -w "\n%{http_code}" -X POST \ + -H "Authorization: Bearer $auth_token" \ + "https://ossrh-staging-api.central.sonatype.com/manual/upload/repository/$repository_key") + + http_code=$(tail -n1 <<< "$post_response") + response_body=$(sed '$ d' <<< "$post_response") + + echo "----------------------------------------" + echo "Deployment API Response (HTTP Status: $http_code):" + echo "$response_body" + echo "----------------------------------------" + echo "" + echo "Proceed to https://central.sonatype.com/publishing/deployments to finalize publishing." + else + echo "No open repository was found. Likely an indication that artifacts were not uploaded." + fi +} + +version=$(CEL Library Internals. Do Not Use. + */ +@Internal +public final class AccumulatedUnknowns { + private static final int MAX_UNKNOWN_ATTRIBUTE_SIZE = 500_000; + private final Set exprIds; + private final Set attributes; + + Set exprIds() { + return exprIds; + } + + Set attributes() { + return attributes; + } + + /** + * Evaluates if the right hand side is an accumulated unknown, and if so, merges it into the + * accumulator. + */ + public static @Nullable AccumulatedUnknowns maybeMerge( + @Nullable AccumulatedUnknowns accumulator, Object newValue) { + if (newValue instanceof AccumulatedUnknowns) { + AccumulatedUnknowns newUnknowns = (AccumulatedUnknowns) newValue; + return accumulator == null ? newUnknowns : accumulator.merge(newUnknowns); + } + return accumulator; + } + + @CanIgnoreReturnValue + public AccumulatedUnknowns merge(AccumulatedUnknowns arg) { + enforceMaxAttributeSize(this.attributes, arg.attributes); + this.exprIds.addAll(arg.exprIds); + this.attributes.addAll(arg.attributes); + return this; + } + + static AccumulatedUnknowns create(Long... ids) { + return create(Arrays.asList(ids)); + } + + static AccumulatedUnknowns create(Collection ids) { + return create(ids, new ArrayList<>()); + } + + public static AccumulatedUnknowns create( + Collection exprIds, Collection attributes) { + return new AccumulatedUnknowns(new HashSet<>(exprIds), new HashSet<>(attributes)); + } + + private static void enforceMaxAttributeSize( + Set lhsAttributes, Set rhsAttributes) { + if (lhsAttributes.size() + rhsAttributes.size() > MAX_UNKNOWN_ATTRIBUTE_SIZE) { + throw new IllegalArgumentException( + String.format( + "Exceeded maximum allowed unknown attributes when merging: %s, %s", + lhsAttributes.size(), rhsAttributes.size())); + } + } + + private AccumulatedUnknowns(Set exprIds, Set attributes) { + this.exprIds = exprIds; + this.attributes = attributes; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/Activation.java b/runtime/src/main/java/dev/cel/runtime/Activation.java new file mode 100644 index 000000000..074a461a2 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/Activation.java @@ -0,0 +1,151 @@ +// Copyright 2022 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 static com.google.common.collect.ImmutableMap.toImmutableMap; + +import com.google.common.base.Supplier; +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.ByteString; +import com.google.protobuf.ByteString.ByteIterator; +import dev.cel.common.annotations.Internal; +import java.util.Map; +import org.jspecify.annotations.Nullable; + +/** + * An object which allows to bind names to values. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public abstract class Activation implements GlobalResolver { + + /** Resolves the given name to its value. Returns null if resolution fails. */ + @Override + public abstract @Nullable Object resolve(String name); + + /** An empty binder which resolves everything to null. */ + public static final Activation EMPTY = + new Activation() { + + @Override + public @Nullable Object resolve(String name) { + return GlobalResolver.EMPTY.resolve(name); + } + + @Override + public String toString() { + return GlobalResolver.EMPTY.toString(); + } + }; + + /** Creates a binder which binds the given name to the value. */ + public static Activation of(final String name, Object value) { + return new Activation() { + + @Override + public @Nullable Object resolve(String theName) { + if (theName.equals(name)) { + return RuntimeHelpers.maybeAdaptPrimitive(value); + } + return null; + } + + @Override + public String toString() { + if (value instanceof ByteString) { + ByteString bs = (ByteString) value; + StringBuilder val = new StringBuilder(); + val.append("["); + for (ByteIterator i = bs.iterator(); i.hasNext(); ) { + byte b = i.nextByte(); + val.append(b); + if (i.hasNext()) { + val.append(", "); + } + } + val.append("]"); + return String.format("{%s=%s}", name, val); + } + return String.format("{%s=%s}", name, value); + } + }; + } + + /** Creates a binder which binds the given name to the supplier. */ + public static Activation of(final String name, final Supplier supplier) { + return new Activation() { + + @Override + public @Nullable Object resolve(String theName) { + if (theName.equals(name)) { + return RuntimeHelpers.maybeAdaptPrimitive(supplier.get()); + } + return null; + } + + @Override + public String toString() { + return String.format("{%s=%s}", name, supplier.get()); + } + }; + } + + /** Creates a binder backed up by a map. */ + public static Activation copyOf(Map map) { + @SuppressWarnings("unchecked") + final ImmutableMap copy = + (map instanceof ImmutableMap) + ? (ImmutableMap) map + : map.entrySet().stream() + // ImmutableMaps are null-hostile, but the Activation is not, so make sure that null + // values and entries are skipped. + .filter(entry -> entry.getKey() != null && entry.getValue() != null) + .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)); + return new Activation() { + + @Override + public @Nullable Object resolve(String name) { + return RuntimeHelpers.maybeAdaptPrimitive(copy.get(name)); + } + + @Override + public String toString() { + return copy.toString(); + } + }; + } + + /** + * Extends this binder by another binder. Names will be attempted to first resolve in the other + * binder, then in this binder. + */ + public Activation extend(final Activation activation) { + final Activation outer = this; + return new Activation() { + + @Override + public @Nullable Object resolve(String name) { + Object value = activation.resolve(name); + return value != null ? value : outer.resolve(name); + } + + @Override + public String toString() { + return activation + " +> " + outer; + } + }; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/BUILD.bazel b/runtime/src/main/java/dev/cel/runtime/BUILD.bazel new file mode 100644 index 000000000..17160e346 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/BUILD.bazel @@ -0,0 +1,1427 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//publish:__pkg__", + "//runtime:__pkg__", + ], +) + +# keep sorted +BASE_SOURCES = [ + "DefaultMetadata.java", + "MessageProvider.java", + "Registrar.java", +] + +# keep sorted +INTERPRETER_SOURCES = [ + "CallArgumentChecker.java", + "DefaultInterpreter.java", + "Interpreter.java", + "RuntimeUnknownResolver.java", + "UnknownTrackingInterpretable.java", +] + +# keep sorted +DESCRIPTOR_MESSAGE_PROVIDER_SOURCES = [ + "DescriptorMessageProvider.java", + "DynamicMessageFactory.java", + "MessageFactory.java", +] + +# keep sorted +LITE_RUNTIME_SOURCES = [ + "CelLiteRuntime.java", + "CelLiteRuntimeBuilder.java", + "CelLiteRuntimeLibrary.java", +] + +# keep sorted +LITE_RUNTIME_IMPL_SOURCES = [ + "LiteRuntimeImpl.java", +] + +# keep sorted +LITE_PROGRAM_IMPL_SOURCES = [ + "LiteProgramImpl.java", +] + +# keep sorted +FUNCTION_BINDING_SOURCES = [ + "CelFunctionBinding.java", + "FunctionBindingImpl.java", + "InternalCelFunctionBinding.java", +] + +# keep sorted +INTERPRABLE_SOURCES = [ + "GlobalResolver.java", + "Interpretable.java", +] + +# keep sorted +DISPATCHER_SOURCES = [ + "DefaultDispatcher.java", +] + +java_library( + name = "runtime_type_provider", + srcs = ["RuntimeTypeProvider.java"], + tags = [ + ], + deps = [ + ":base", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "runtime_type_provider_android", + srcs = ["RuntimeTypeProvider.java"], + visibility = ["//visibility:private"], + deps = [ + ":base_android", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "descriptor_message_provider", + srcs = DESCRIPTOR_MESSAGE_PROVIDER_SOURCES, + tags = [ + ], + deps = [ + ":runtime_type_provider", + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "//common:options", + "//common/annotations", + "//common/exceptions:attribute_not_found", + "//common/internal:cel_descriptor_pools", + "//common/internal:default_message_factory", + "//common/internal:dynamic_proto", + "//common/internal:proto_message_factory", + "//common/types:cel_types", + "//common/values:cel_byte_string", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "dispatcher", + srcs = DISPATCHER_SOURCES, + tags = [ + ], + deps = [ + ":evaluation_exception", + ":evaluation_exception_builder", + ":function_binding", + ":function_overload", + ":function_resolver", + ":resolved_overload", + "//:auto_value", + "//common:error_codes", + "//common/annotations", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "dispatcher_android", + srcs = DISPATCHER_SOURCES, + tags = [ + ], + deps = [ + ":evaluation_exception", + ":evaluation_exception_builder", + ":function_binding_android", + ":function_overload_android", + ":function_resolver_android", + ":resolved_overload_android", + "//:auto_value", + "//common:error_codes", + "//common/annotations", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "activation", + srcs = ["Activation.java"], + tags = [ + ], + deps = [ + ":interpretable", + ":runtime_helpers", + "//common/annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +cel_android_library( + name = "activation_android", + srcs = ["Activation.java"], + tags = [ + ], + deps = [ + ":interpretable_android", + ":runtime_helpers_android", + "//common/annotations", + "@maven//:org_jspecify_jspecify", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "proto_message_activation_factory", + srcs = ["ProtoMessageActivationFactory.java"], + tags = [ + ], + deps = [ + ":activation", + ":evaluation_exception_builder", + "//common:options", + "//common/internal:default_message_factory", + "//common/internal:dynamic_proto", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "type_resolver", + srcs = ["TypeResolver.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/types", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_byte_string", + "//common/values:cel_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "type_resolver_android", + srcs = ["TypeResolver.java"], + tags = [ + ], + deps = [ + "//common/annotations", + "//common/types:type_providers_android", + "//common/types:types_android", + "//common/values:cel_byte_string", + "//common/values:cel_value_android", + "//common/values:values_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "descriptor_type_resolver", + srcs = ["DescriptorTypeResolver.java"], + tags = [ + ], + deps = [ + ":type_resolver", + "//common/annotations", + "//common/types", + "//common/types:type_providers", + "//common/values", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "base", + srcs = BASE_SOURCES, + tags = [ + ], + deps = [ + ":function_overload", + ":metadata", + "//common:cel_ast", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "base_android", + srcs = BASE_SOURCES, + visibility = ["//visibility:private"], + deps = [ + ":function_overload_android", + ":metadata", + "//common:cel_ast_android", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "interpreter", + srcs = INTERPRETER_SOURCES, + tags = [ + ], + exports = [":base"], + deps = [ + ":accumulated_unknowns", + ":base", + ":concatenated_list_view", + ":dispatcher", + ":evaluation_exception", + ":evaluation_exception_builder", + ":evaluation_listener", + ":function_resolver", + ":interpretable", + ":interpreter_util", + ":metadata", + ":resolved_overload", + ":runtime_helpers", + ":runtime_type_provider", + ":type_resolver", + ":unknown_attributes", + "//:auto_value", + "//common:cel_ast", + "//common:error_codes", + "//common:options", + "//common/annotations", + "//common/ast", + "//common/exceptions:runtime_exception", + "//common/types", + "//common/types:type_providers", + "//common/values:cel_byte_string", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "interpreter_android", + srcs = INTERPRETER_SOURCES, + visibility = ["//visibility:private"], + deps = [ + ":accumulated_unknowns_android", + ":base_android", + ":concatenated_list_view", + ":dispatcher_android", + ":evaluation_exception", + ":evaluation_exception_builder", + ":evaluation_listener_android", + ":function_resolver_android", + ":interpretable_android", + ":interpreter_util_android", + ":metadata", + ":resolved_overload_android", + ":runtime_helpers_android", + ":runtime_type_provider_android", + ":type_resolver_android", + ":unknown_attributes_android", + "//:auto_value", + "//common:cel_ast_android", + "//common:error_codes", + "//common:options", + "//common/annotations", + "//common/ast:ast_android", + "//common/exceptions:runtime_exception", + "//common/types:type_providers_android", + "//common/types:types_android", + "//common/values:cel_byte_string", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "runtime_equality", + srcs = [ + "RuntimeEquality.java", + ], + tags = [ + ], + deps = [ + ":runtime_helpers", + "//common:options", + "//common/annotations", + "//common/exceptions:attribute_not_found", + "//common/internal:comparison_functions", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "runtime_equality_android", + srcs = ["RuntimeEquality.java"], + tags = [ + ], + deps = [ + ":runtime_helpers_android", + "//common:options", + "//common/annotations", + "//common/exceptions:attribute_not_found", + "//common/internal:comparison_functions_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "proto_message_runtime_equality", + srcs = [ + "ProtoMessageRuntimeEquality.java", + ], + tags = [ + ], + deps = [ + ":proto_message_runtime_helpers", + ":runtime_equality", + "//common:options", + "//common/annotations", + "//common/internal:dynamic_proto", + "//common/internal:proto_equality", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "runtime_helpers_android", + srcs = ["RuntimeHelpers.java"], + tags = [ + ], + deps = [ + ":concatenated_list_view", + "//common:options", + "//common/annotations", + "//common/exceptions:divide_by_zero", + "//common/exceptions:index_out_of_bounds", + "//common/exceptions:numeric_overflow", + "//common/internal:converter", + "//common/values:values_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_re2j_re2j", + "@maven//:org_threeten_threeten_extra", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "runtime_helpers", + srcs = [ + "RuntimeHelpers.java", + ], + tags = [ + ], + deps = [ + ":concatenated_list_view", + "//common:options", + "//common/annotations", + "//common/exceptions:divide_by_zero", + "//common/exceptions:index_out_of_bounds", + "//common/exceptions:numeric_overflow", + "//common/internal:converter", + "//common/values", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_re2j_re2j", + "@maven//:org_threeten_threeten_extra", + ], +) + +java_library( + name = "proto_message_runtime_helpers", + srcs = [ + "ProtoMessageRuntimeHelpers.java", + ], + tags = [ + ], + deps = [ + ":runtime_helpers", + "//common:options", + "//common/annotations", + "//common/internal:dynamic_proto", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +# keep sorted +RUNTIME_SOURCES = [ + "CelInternalRuntimeLibrary.java", + "CelRuntime.java", + "CelRuntimeBuilder.java", + "CelRuntimeLibrary.java", + "ProgramImpl.java", + "UnknownContext.java", +] + +LATE_FUNCTION_BINDING_SOURCES = [ + "CelLateFunctionBindings.java", +] + +java_library( + name = "late_function_binding", + srcs = LATE_FUNCTION_BINDING_SOURCES, + tags = [ + ], + deps = [ + ":dispatcher", + ":evaluation_exception", + ":function_binding", + ":function_resolver", + ":resolved_overload", + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "late_function_binding_android", + srcs = LATE_FUNCTION_BINDING_SOURCES, + tags = [ + ], + deps = [ + ":dispatcher_android", + ":evaluation_exception", + ":function_binding_android", + ":function_resolver_android", + ":resolved_overload_android", + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "lite_runtime_library", + srcs = ["CelLiteRuntimeLibrary.java"], + deps = [":lite_runtime"], +) + +cel_android_library( + name = "lite_runtime_library_android", + srcs = ["CelLiteRuntimeLibrary.java"], + deps = [":lite_runtime_android"], +) + +java_library( + name = "evaluation_exception", + srcs = [ + "CelEvaluationException.java", + ], + # used_by_android + tags = [ + ], + deps = [ + "//common:cel_exception", + "//common:error_codes", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "evaluation_exception_builder", + srcs = ["CelEvaluationExceptionBuilder.java"], + # used_by_android + tags = [ + ], + deps = [ + ":evaluation_exception", + ":metadata", + "//common:error_codes", + "//common/annotations", + "//common/exceptions:runtime_exception", + "//common/internal:safe_string_formatter", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "metadata", + srcs = ["Metadata.java"], + # used_by_android + tags = [ + ], + deps = [ + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "interpretable", + srcs = INTERPRABLE_SOURCES, + tags = [ + ], + deps = [ + ":evaluation_exception", + ":evaluation_listener", + ":function_resolver", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +cel_android_library( + name = "interpretable_android", + srcs = INTERPRABLE_SOURCES, + tags = [ + ], + deps = [ + ":evaluation_exception", + ":evaluation_listener_android", + ":function_resolver_android", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "standard_functions", + srcs = ["CelStandardFunctions.java"], + tags = [ + ], + deps = [ + ":function_binding", + ":runtime_equality", + "//common:operator", + "//common:options", + "//common/annotations", + "//runtime/standard:add", + "//runtime/standard:bool", + "//runtime/standard:bytes", + "//runtime/standard:contains", + "//runtime/standard:divide", + "//runtime/standard:double", + "//runtime/standard:duration", + "//runtime/standard:dyn", + "//runtime/standard:ends_with", + "//runtime/standard:equals", + "//runtime/standard:get_date", + "//runtime/standard:get_day_of_month", + "//runtime/standard:get_day_of_week", + "//runtime/standard:get_day_of_year", + "//runtime/standard:get_full_year", + "//runtime/standard:get_hours", + "//runtime/standard:get_milliseconds", + "//runtime/standard:get_minutes", + "//runtime/standard:get_month", + "//runtime/standard:get_seconds", + "//runtime/standard:greater", + "//runtime/standard:greater_equals", + "//runtime/standard:in", + "//runtime/standard:index", + "//runtime/standard:int", + "//runtime/standard:less", + "//runtime/standard:less_equals", + "//runtime/standard:logical_not", + "//runtime/standard:matches", + "//runtime/standard:modulo", + "//runtime/standard:multiply", + "//runtime/standard:negate", + "//runtime/standard:not_equals", + "//runtime/standard:not_strictly_false", + "//runtime/standard:size", + "//runtime/standard:standard_function", + "//runtime/standard:standard_overload", + "//runtime/standard:starts_with", + "//runtime/standard:string", + "//runtime/standard:subtract", + "//runtime/standard:timestamp", + "//runtime/standard:uint", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "standard_functions_android", + srcs = ["CelStandardFunctions.java"], + tags = [ + ], + deps = [ + ":function_binding_android", + ":runtime_equality_android", + "//common:operator_android", + "//common:options", + "//common/annotations", + "//runtime/standard:add_android", + "//runtime/standard:bool_android", + "//runtime/standard:bytes_android", + "//runtime/standard:contains_android", + "//runtime/standard:divide_android", + "//runtime/standard:double_android", + "//runtime/standard:duration_android", + "//runtime/standard:dyn_android", + "//runtime/standard:ends_with_android", + "//runtime/standard:equals_android", + "//runtime/standard:get_date_android", + "//runtime/standard:get_day_of_month_android", + "//runtime/standard:get_day_of_week_android", + "//runtime/standard:get_day_of_year_android", + "//runtime/standard:get_full_year_android", + "//runtime/standard:get_hours_android", + "//runtime/standard:get_milliseconds_android", + "//runtime/standard:get_minutes_android", + "//runtime/standard:get_month_android", + "//runtime/standard:get_seconds_android", + "//runtime/standard:greater_android", + "//runtime/standard:greater_equals_android", + "//runtime/standard:in_android", + "//runtime/standard:index_android", + "//runtime/standard:int_android", + "//runtime/standard:less_android", + "//runtime/standard:less_equals_android", + "//runtime/standard:logical_not_android", + "//runtime/standard:matches_android", + "//runtime/standard:modulo_android", + "//runtime/standard:multiply_android", + "//runtime/standard:negate_android", + "//runtime/standard:not_equals_android", + "//runtime/standard:not_strictly_false_android", + "//runtime/standard:size_android", + "//runtime/standard:standard_function_android", + "//runtime/standard:standard_overload_android", + "//runtime/standard:starts_with_android", + "//runtime/standard:string_android", + "//runtime/standard:subtract_android", + "//runtime/standard:timestamp_android", + "//runtime/standard:uint_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "function_binding", + srcs = FUNCTION_BINDING_SOURCES, + tags = [ + ], + deps = [ + ":evaluation_exception", + ":function_overload", + "//common/annotations", + "//common/exceptions:overload_not_found", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "function_binding_android", + srcs = FUNCTION_BINDING_SOURCES, + tags = [ + ], + 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", + ], +) + +java_library( + name = "function_resolver", + srcs = ["CelFunctionResolver.java"], + tags = [ + ], + deps = [ + ":evaluation_exception", + ":resolved_overload", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "function_resolver_android", + srcs = ["CelFunctionResolver.java"], + deps = [ + ":evaluation_exception", + ":resolved_overload_android", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "function_overload", + srcs = [ + "CelFunctionOverload.java", + "OptimizedFunctionOverload.java", + ], + tags = [ + ], + deps = [ + ":evaluation_exception", + ":unknown_attributes", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "function_overload_android", + srcs = [ + "CelFunctionOverload.java", + "OptimizedFunctionOverload.java", + ], + deps = [ + ":evaluation_exception", + ":unknown_attributes_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "runtime_planner_impl", + srcs = ["CelRuntimeImpl.java"], + tags = [ + ], + deps = [ + ":descriptor_type_resolver", + ":dispatcher", + ":evaluation_exception", + ":evaluation_listener", + ":function_binding", + ":function_resolver", + ":partial_vars", + ":program", + ":proto_message_runtime_equality", + ":runtime", + ":runtime_equality", + ":standard_functions", + ":variable_resolver", + "//:auto_value", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "//common:container", + "//common:options", + "//common/annotations", + "//common/internal:cel_descriptor_pools", + "//common/internal:default_message_factory", + "//common/internal:dynamic_proto", + "//common/types:default_type_provider", + "//common/types:message_type_provider", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_value_provider", + "//common/values:combined_cel_value_provider", + "//common/values:proto_message_value_provider", + "//runtime:activation", + "//runtime:interpretable", + "//runtime:proto_message_activation_factory", + "//runtime:resolved_overload", + "//runtime/planner:planned_program", + "//runtime/planner:program_planner", + "//runtime/standard:type", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "runtime_legacy_impl", + srcs = ["CelRuntimeLegacyImpl.java"], + tags = [ + ], + deps = [ + ":cel_value_runtime_type_provider", + ":descriptor_message_provider", + ":descriptor_type_resolver", + ":dispatcher", + ":function_binding", + ":interpreter", + ":proto_message_runtime_equality", + ":runtime", + ":runtime_equality", + ":runtime_type_provider", + ":standard_functions", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "//common:container", + "//common:options", + "//common/annotations", + "//common/internal:cel_descriptor_pools", + "//common/internal:default_message_factory", + "//common/internal:dynamic_proto", + "//common/internal:proto_message_factory", + "//common/types:cel_types", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_value_provider", + "//common/values:proto_message_value_provider", + "//runtime/standard:int", + "//runtime/standard:timestamp", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "runtime_factory", + srcs = ["CelRuntimeFactory.java"], + tags = [ + ], + deps = [ + ":runtime", + ":runtime_legacy_impl", + ":runtime_planner_impl", + "//common:options", + ], +) + +java_library( + name = "runtime", + srcs = RUNTIME_SOURCES, + tags = [ + ], + deps = [ + ":activation", + ":evaluation_exception", + ":evaluation_listener", + ":function_binding", + ":function_resolver", + ":interpretable", + ":interpreter", + ":partial_vars", + ":program", + ":proto_message_activation_factory", + ":runtime_equality", + ":standard_functions", + ":unknown_attributes", + ":variable_resolver", + "//:auto_value", + "//common:cel_ast", + "//common:container", + "//common:options", + "//common/annotations", + "//common/types:type_providers", + "//common/values:cel_value_provider", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "lite_runtime", + srcs = LITE_RUNTIME_SOURCES, + tags = [ + ], + deps = [ + ":evaluation_exception", + ":function_binding", + ":program", + "//:auto_value", + "//common:cel_ast", + "//common:options", + "//common/annotations", + "//common/values:cel_value_provider", + "//runtime/standard:standard_function", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "lite_runtime_impl", + srcs = LITE_RUNTIME_IMPL_SOURCES, + tags = [ + ], + deps = [ + ":cel_value_runtime_type_provider", + ":dispatcher", + ":function_binding", + ":interpreter", + ":lite_program_impl", + ":lite_runtime", + ":program", + ":runtime_equality", + ":runtime_helpers", + ":type_resolver", + "//:auto_value", + "//common:cel_ast", + "//common:options", + "//common/values:cel_value_provider", + "//runtime/standard:standard_function", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "lite_program_impl", + srcs = LITE_PROGRAM_IMPL_SOURCES, + deps = [ + ":activation", + ":evaluation_exception", + ":function_resolver", + ":interpretable", + ":partial_vars", + ":program", + ":variable_resolver", + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "lite_program_impl_android", + srcs = LITE_PROGRAM_IMPL_SOURCES, + deps = [ + ":activation_android", + ":evaluation_exception", + ":function_resolver_android", + ":interpretable_android", + ":partial_vars_android", + ":program_android", + ":variable_resolver", + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "lite_runtime_impl_android", + srcs = LITE_RUNTIME_IMPL_SOURCES, + tags = [ + ], + deps = [ + ":cel_value_runtime_type_provider_android", + ":dispatcher_android", + ":function_binding_android", + ":interpreter_android", + ":lite_program_impl_android", + ":lite_runtime_android", + ":program_android", + ":runtime_equality_android", + ":runtime_helpers_android", + ":type_resolver_android", + "//:auto_value", + "//common:cel_ast_android", + "//common:options", + "//common/values:cel_value_provider_android", + "//runtime/standard:standard_function_android", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "lite_runtime_factory", + srcs = [ + "CelLiteRuntimeFactory.java", + ], + tags = [ + ], + deps = [ + ":lite_runtime", + ":lite_runtime_impl", + "//common/annotations", + ], +) + +cel_android_library( + name = "lite_runtime_factory_android", + srcs = [ + "CelLiteRuntimeFactory.java", + ], + tags = [ + ], + deps = [ + ":lite_runtime_android", + ":lite_runtime_impl_android", + "//common/annotations", + ], +) + +# keep sorted +UNKNOWN_ATTRIBUTE_SOURCES = [ + "CelAttribute.java", + "CelAttributePattern.java", + "CelAttributeResolver.java", + "CelUnknownSet.java", +] + +# keep sorted +UNKNOWN_OPTIONS_SOURCES = [ + "CelAttributeParser.java", +] + +java_library( + name = "unknown_options", + srcs = UNKNOWN_OPTIONS_SOURCES, + tags = [ + ], + deps = [ + ":unknown_attributes", + "//common:cel_ast", + "//common:compiler_common", + "//common:operator", + "//common/ast", + "//parser:parser_builder", + "//parser:parser_factory", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "unknown_attributes", + srcs = UNKNOWN_ATTRIBUTE_SOURCES, + tags = [ + ], + deps = [ + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_re2j_re2j", + ], +) + +cel_android_library( + name = "unknown_attributes_android", + srcs = UNKNOWN_ATTRIBUTE_SOURCES, + tags = [ + ], + deps = [ + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_re2j_re2j", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "cel_value_runtime_type_provider", + srcs = ["CelValueRuntimeTypeProvider.java"], + deps = [ + ":runtime_type_provider", + ":unknown_attributes", + "//common/annotations", + "//common/exceptions:attribute_not_found", + "//common/values", + "//common/values:base_proto_cel_value_converter", + "//common/values:base_proto_message_value_provider", + "//common/values:cel_value", + "//common/values:cel_value_provider", + "//common/values:combined_cel_value_provider", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "cel_value_runtime_type_provider_android", + srcs = ["CelValueRuntimeTypeProvider.java"], + deps = [ + ":runtime_type_provider_android", + ":unknown_attributes_android", + "//common/annotations", + "//common/exceptions:attribute_not_found", + "//common/values:base_proto_cel_value_converter_android", + "//common/values:base_proto_message_value_provider_android", + "//common/values:cel_value_android", + "//common/values:cel_value_provider_android", + "//common/values:combined_cel_value_provider_android", + "//common/values:values_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "interpreter_util", + srcs = ["InterpreterUtil.java"], + tags = [ + ], + deps = [ + ":accumulated_unknowns", + ":evaluation_exception", + ":unknown_attributes", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +cel_android_library( + name = "interpreter_util_android", + srcs = ["InterpreterUtil.java"], + visibility = ["//visibility:private"], + deps = [ + ":accumulated_unknowns_android", + ":evaluation_exception", + ":unknown_attributes_android", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "evaluation_listener", + srcs = ["CelEvaluationListener.java"], + tags = [ + ], + deps = [ + "//common/ast", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "evaluation_listener_android", + srcs = ["CelEvaluationListener.java"], + visibility = ["//visibility:private"], + deps = [ + "//common/ast:ast_android", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "lite_runtime_android", + srcs = LITE_RUNTIME_SOURCES, + tags = [ + ], + deps = [ + ":evaluation_exception", + ":function_binding_android", + ":program_android", + "//:auto_value", + "//common:cel_ast_android", + "//common:options", + "//common/annotations", + "//common/values:cel_value_provider_android", + "//runtime/standard:standard_function_android", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "concatenated_list_view", + srcs = ["ConcatenatedListView.java"], + # used_by_android + tags = [ + ], + deps = ["//common/annotations"], +) + +java_library( + name = "accumulated_unknowns", + srcs = ["AccumulatedUnknowns.java"], + tags = [ + ], + deps = [ + ":unknown_attributes", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +cel_android_library( + name = "accumulated_unknowns_android", + srcs = ["AccumulatedUnknowns.java"], + visibility = ["//visibility:private"], + deps = [ + ":unknown_attributes_android", + "//common/annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "resolved_overload", + srcs = ["CelResolvedOverload.java"], + tags = [ + ], + deps = [ + ":evaluation_exception", + ":function_binding", + ":function_overload", + "//:auto_value", + "//common/annotations", + "//common/exceptions:overload_not_found", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "resolved_overload_android", + srcs = ["CelResolvedOverload.java"], + tags = [ + ], + deps = [ + ":evaluation_exception", + ":function_binding_android", + ":function_overload_android", + "//:auto_value", + "//common/annotations", + "//common/exceptions:overload_not_found", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "partial_vars", + srcs = ["PartialVars.java"], + tags = [ + ], + deps = [ + ":variable_resolver", + "//:auto_value", + "//runtime:unknown_attributes", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "partial_vars_android", + srcs = ["PartialVars.java"], + tags = [ + ], + deps = [ + ":variable_resolver", + "//:auto_value", + "//runtime:unknown_attributes_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "program", + srcs = ["Program.java"], + tags = [ + ], + deps = [ + ":evaluation_exception", + ":function_resolver", + ":partial_vars", + ":variable_resolver", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "program_android", + srcs = ["Program.java"], + tags = [ + ], + deps = [ + ":evaluation_exception", + ":function_resolver_android", + ":partial_vars_android", + ":variable_resolver", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "internal_function_binder", + srcs = ["InternalFunctionBinder.java"], + tags = [ + ], + deps = [ + ":function_binding", + ":function_overload", + "//common/annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "internal_function_binder_andriod", + srcs = ["InternalFunctionBinder.java"], + tags = [ + ], + deps = [ + ":function_binding_android", + ":function_overload_android", + "//common/annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "variable_resolver", + srcs = [ + "CelVariableResolver.java", + "HierarchicalVariableResolver.java", + ], + # used_by_android + tags = [ + ], +) diff --git a/runtime/src/main/java/dev/cel/runtime/CallArgumentChecker.java b/runtime/src/main/java/dev/cel/runtime/CallArgumentChecker.java new file mode 100644 index 000000000..76a942927 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CallArgumentChecker.java @@ -0,0 +1,108 @@ +// Copyright 2022 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 dev.cel.common.annotations.Internal; +import java.util.ArrayList; +import java.util.Optional; + +/** + * Package private utility class for collecting CelUnknownSets from an argument list in a call-like + * expression. + * + *

Accumulates arguments via {@link #checkArg(DefaultInterpreter.IntermediateResult)}. After all + * args are checked, the result is provided by {@link #maybeUnknowns()} + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +class CallArgumentChecker { + private final ArrayList exprIds; + private final RuntimeUnknownResolver resolver; + private final boolean acceptPartial; + private Optional unknowns; + + private CallArgumentChecker(RuntimeUnknownResolver resolver, boolean acceptPartial) { + this.exprIds = new ArrayList<>(); + this.unknowns = Optional.empty(); + this.resolver = resolver; + this.acceptPartial = acceptPartial; + } + + /** + * Creates a CallArgumentChecker that only permits 'completeData'. + * + *

Arguments that are determined as partially unknown (have a subfield that is unknown) are + * treated as unknown and added to the accumulated UnknownSet. + */ + static CallArgumentChecker create(RuntimeUnknownResolver resolver) { + return new CallArgumentChecker(resolver, false); + } + + /** + * Creates a CallArgumentChecker that permits partial data (e.g. container accesses). + * + *

Arguments that are determined as unknown (match an unknown type) are treated as unknown and + * added to the accumulated UnknownSet. + */ + static CallArgumentChecker createAcceptingPartial(RuntimeUnknownResolver resolver) { + return new CallArgumentChecker(resolver, true); + } + + private static Optional mergeOptionalUnknowns( + Optional lhs, Optional rhs) { + return lhs.isPresent() ? rhs.isPresent() ? Optional.of(lhs.get().merge(rhs.get())) : lhs : rhs; + } + + /** Determine if the call argument is unknown and accumulate if so. */ + void checkArg(DefaultInterpreter.IntermediateResult arg) { + // Handle attribute tracked unknowns. + Optional argUnknowns = maybeUnknownFromArg(arg); + unknowns = mergeOptionalUnknowns(unknowns, argUnknowns); + + // support for ExprValue unknowns. + if (InterpreterUtil.isAccumulatedUnknowns(arg.value())) { + AccumulatedUnknowns unknownSet = (AccumulatedUnknowns) arg.value(); + exprIds.addAll(unknownSet.exprIds()); + } + } + + private Optional maybeUnknownFromArg( + DefaultInterpreter.IntermediateResult arg) { + if (arg.value() instanceof AccumulatedUnknowns) { + AccumulatedUnknowns celUnknownSet = (AccumulatedUnknowns) arg.value(); + if (!celUnknownSet.attributes().isEmpty()) { + return Optional.of((AccumulatedUnknowns) arg.value()); + } + } + if (!acceptPartial) { + return resolver.maybePartialUnknown(arg.attribute()); + } + return Optional.empty(); + } + + /** Returns the accumulated unknown if any. */ + Optional maybeUnknowns() { + if (unknowns.isPresent()) { + return Optional.of(unknowns.get()); + } + + if (!exprIds.isEmpty()) { + return Optional.of(AccumulatedUnknowns.create(exprIds)); + } + + return Optional.empty(); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelAttribute.java b/runtime/src/main/java/dev/cel/runtime/CelAttribute.java new file mode 100644 index 000000000..f04418e0c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelAttribute.java @@ -0,0 +1,234 @@ +// Copyright 2022 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.auto.value.AutoOneOf; +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import com.google.re2j.Pattern; + +/** + * CelAttribute represents the select path from the root (.) to a single leaf value that may be + * derived from the activation (e.g. .com.google.Attribute['index']) + * + *

This includes fully qualified identifiers and the selection path to a member field or element. + * + *

CelAttributes are represented as a list of qualifiers (select/index operations) from the root, + * e.g. identifier[2].field is represented as string:identifier, int:2, string:field. + */ +@Immutable +@AutoValue +public abstract class CelAttribute { + /** + * Empty attribute. Represents a value that doesn't have a corresponding attribute (e.g. the + * result of a function). + */ + public static final CelAttribute EMPTY = new AutoValue_CelAttribute(ImmutableList.of()); + + /** Representation of a single select qualifier or index. */ + @Immutable + @AutoOneOf(Qualifier.Kind.class) + public abstract static class Qualifier { + private static final Pattern IDENT_PATTERN = Pattern.compile("[A-Za-z_][A-Za-z_0-9]*"); + + /** Legal attribute qualifier kinds. */ + public enum Kind { + AS_STRING, + AS_INT, + AS_UINT, + AS_BOOL, + WILD_CARD + }; + + public static Qualifier ofString(String value) { + return AutoOneOf_CelAttribute_Qualifier.asString(value); + } + + public static Qualifier ofInt(long value) { + return AutoOneOf_CelAttribute_Qualifier.asInt(value); + } + + public static Qualifier ofUint(UnsignedLong value) { + return AutoOneOf_CelAttribute_Qualifier.asUint(value); + } + + /** Overload for integer literals. Value must be non-negative. */ + public static Qualifier ofUint(long value) { + Preconditions.checkArgument(value >= 0L, "uint qualifier must be non-negative."); + return ofUint(UnsignedLong.valueOf(value)); + } + + public static Qualifier ofBool(boolean value) { + return AutoOneOf_CelAttribute_Qualifier.asBool(value); + } + + public static Qualifier ofWildCard() { + return AutoOneOf_CelAttribute_Qualifier.wildCard(); + } + + public abstract Kind kind(); + + public abstract String asString(); + + public abstract Long asInt(); + + public abstract UnsignedLong asUint(); + + public abstract Boolean asBool(); + + public abstract void wildCard(); + + /** + * Creates a Qualifier from a generic object. + * + * @throws IllegalArgumentException if the value can't be interpreted as a field selection or an + * index. + */ + public static Qualifier fromGeneric(Object value) { + if (value instanceof UnsignedLong) { + return ofUint((UnsignedLong) value); + } else if (value instanceof Long) { + return ofInt((Long) value); + } else if (value instanceof Boolean) { + return ofBool((boolean) value); + } else if (value instanceof String) { + return ofString((String) value); + } + throw new IllegalArgumentException("Unsupported attribute qualifier kind"); + } + + public String toIndexFormat() { + String key = ""; + switch (kind()) { + case AS_STRING: + key = "'" + asString() + "'"; + break; + case AS_INT: + key = asInt().toString(); + break; + case AS_UINT: + key = asUint().toString() + "u"; + break; + case AS_BOOL: + key = asBool() ? "true" : "false"; + break; + default: + throw new IllegalStateException( + String.format("Unsupported CEL attribute qualifier for index: %s", kind())); + } + return String.format("[%s]", key); + } + + /** + * Simple test that an identifier segment is a legal CEL identifier. This does not check for + * reserved names. + */ + public static boolean isLegalIdentifier(String identifier) { + return IDENT_PATTERN.matches(identifier); + } + + public static boolean isLegalIdentifier(Qualifier identifier) { + return identifier.kind() == Kind.AS_STRING && isLegalIdentifier(identifier.asString()); + } + } + + /** Creates a CelAttribute. */ + public static CelAttribute create(ImmutableList qualifiers) { + Preconditions.checkArgument(!qualifiers.isEmpty(), "qualifiers must be non-empty"); + Preconditions.checkArgument( + Qualifier.isLegalIdentifier(qualifiers.get(0)), + "'%s' is not a legal CEL identifier", + qualifiers.get(0)); + + qualifiers.forEach( + q -> + Preconditions.checkArgument( + q.kind() != Qualifier.Kind.WILD_CARD, + "Wildcards are not permitted in CelAttributes.")); + + return new AutoValue_CelAttribute(qualifiers); + } + + /** Creates a CelAttribute from a single root identifier. */ + public static CelAttribute create(String rootIdentifier) { + Preconditions.checkArgument( + Qualifier.isLegalIdentifier(rootIdentifier), + "'%s' is not a legal CEL identifier", + rootIdentifier); + + return new AutoValue_CelAttribute(ImmutableList.of(Qualifier.ofString(rootIdentifier))); + } + + /** + * Attempts to parse a dot qualified identifier into a CEL attribute. + * + * @throws IllegalArgumentException if qualifiedIdentifier isn't a legal qualified identifier. + * Note: this is intended for use with reference names in a checked CEL expression -- it does + * not check for some edge cases (e.g. reserved words). + */ + public static CelAttribute fromQualifiedIdentifier(String qualifiedIdentifier) { + ImmutableList.Builder qualifiers = ImmutableList.builder(); + int start = 0; + int next; + while ((next = qualifiedIdentifier.indexOf('.', start)) != -1) { + qualifiers.add(Qualifier.ofString(qualifiedIdentifier.substring(start, next))); + start = next + 1; + } + qualifiers.add(Qualifier.ofString(qualifiedIdentifier.substring(start))); + return new AutoValue_CelAttribute(qualifiers.build()); + } + + /** The list of qualifiers representing the select path for this attribute. */ + public abstract ImmutableList qualifiers(); + + /** + * Creates a new attribute that is more qualified (has an additional select or index operation) + * than the receiver. + */ + public CelAttribute qualify(Qualifier qualifier) { + Preconditions.checkArgument( + qualifier.kind() != Qualifier.Kind.WILD_CARD, + "Wildcards are not permitted for attributes."); + // To simplify client code, qualifying the empty singleton is still empty. + if (qualifiers().isEmpty()) { + return EMPTY; + } + return new AutoValue_CelAttribute( + ImmutableList.builderWithExpectedSize(qualifiers().size() + 1).addAll(qualifiers()).add(qualifier).build()); + } + + @Override + public final String toString() { + if (this.equals(EMPTY)) { + return ""; + } + Preconditions.checkState( + !qualifiers().isEmpty() && qualifiers().get(0).kind() == Qualifier.Kind.AS_STRING, + "CelAttribute must have a root qualifier that is a legal identifier"); + + StringBuilder cname = new StringBuilder(qualifiers().get(0).asString()); + for (Qualifier qualifier : qualifiers().subList(1, qualifiers().size())) { + if (qualifier.kind() == Qualifier.Kind.AS_STRING && Qualifier.isLegalIdentifier(qualifier)) { + cname.append(".").append(qualifier.asString()); + } else { + cname.append(qualifier.toIndexFormat()); + } + } + return cname.toString(); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelAttributeParser.java b/runtime/src/main/java/dev/cel/runtime/CelAttributeParser.java new file mode 100644 index 000000000..c64250e4c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelAttributeParser.java @@ -0,0 +1,174 @@ +// Copyright 2023 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 static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.common.base.Joiner; +import com.google.common.collect.ImmutableList; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.Operator; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.parser.CelParser; +import dev.cel.parser.CelParserFactory; +import java.util.ArrayDeque; + +/** + * Helper class for parsing human-readable attributes into either {@link CelAttribute} or {@link + * CelAttributePattern} instances. + */ +public class CelAttributeParser { + private static final CelParser PARSER = CelParserFactory.standardCelParserBuilder().build(); + private static final String WILDCARD_ESCAPE = "wildcard"; + private static final char ESCAPE = '_'; + + private CelAttributeParser() {} + + private static String escape(String s) { + // escape the escape character + String escapeStr = String.valueOf(ESCAPE); + s = s.replace(escapeStr, escapeStr + escapeStr); + return s.replace("*", ESCAPE + WILDCARD_ESCAPE); + } + + private static String unescape(String s) { + StringBuilder b = new StringBuilder(); + boolean inEscape = false; + for (int index = 0; index < s.length(); index++) { + char c = s.charAt(index); + + if (!inEscape && c == ESCAPE) { + inEscape = true; + continue; + } + + if (inEscape) { + if (c == ESCAPE) { + b.append(c); + inEscape = false; + continue; + } else if (s.startsWith(WILDCARD_ESCAPE, index)) { + b.append("*"); + index += WILDCARD_ESCAPE.length() - 1; + inEscape = false; + continue; + } + throw new IllegalArgumentException("invalid escape sequence: " + ESCAPE + c); + } + + b.append(c); + } + return b.toString(); + } + + private static CelAttribute.Qualifier parseConst(CelConstant constExpr) { + switch (constExpr.getKind()) { + case BOOLEAN_VALUE: + return CelAttribute.Qualifier.ofBool(constExpr.booleanValue()); + case INT64_VALUE: + return CelAttribute.Qualifier.ofInt(constExpr.int64Value()); + case UINT64_VALUE: + return CelAttribute.Qualifier.ofUint(constExpr.uint64Value()); + case STRING_VALUE: + return CelAttribute.Qualifier.ofString(unescape(constExpr.stringValue())); + default: + throw new IllegalArgumentException("Unsupported const expr kind: " + constExpr.getKind()); + } + } + + /** + * Parses a string formatted cel attribute pattern into a {@link CelAttribute}. + * + *

Cel Attributes are represented by the fully-qualified cel selection path that would access + * the represented Attribute. As an extension, wild card qualifiers '.*' are supported to indicate + * that all fields or elements of the parent are unknown. + * + * @param attribute the string representation of the attribute. for example + * namespace.object.field['index']. + * @throws IllegalArgumentException if the provided string isn't a legal attribute representation. + */ + public static CelAttributePattern parsePattern(String attribute) { + String qAttribute = escape(attribute); + CelValidationResult result = PARSER.parse(qAttribute); + try { + CelAbstractSyntaxTree ast = result.getAst(); + ArrayDeque qualifiers = new ArrayDeque<>(); + CelExpr node = ast.getExpr(); + while (node != null) { + switch (node.getKind()) { + case IDENT: + qualifiers.addFirst(CelAttribute.Qualifier.ofString(node.ident().name())); + node = null; + break; + case CALL: + CelCall callExpr = node.call(); + if (!callExpr.function().equals(Operator.INDEX.getFunction()) + || callExpr.args().size() != 2 + || !callExpr.args().get(1).getKind().equals(Kind.CONSTANT)) { + throw new IllegalArgumentException( + String.format( + "Unsupported call expr: %s(%s)", + callExpr.function(), + Joiner.on(", ") + .join( + callExpr.args().stream() + .map(CelExpr::getKind) + .collect(toImmutableList())))); + } + qualifiers.addFirst(parseConst(callExpr.args().get(1).constant())); + node = callExpr.args().get(0); + break; + case SELECT: + String field = node.select().field(); + node = node.select().operand(); + if (field.equals("_" + WILDCARD_ESCAPE)) { + qualifiers.addFirst(CelAttribute.Qualifier.ofWildCard()); + break; + } + qualifiers.addFirst(CelAttribute.Qualifier.ofString(unescape(field))); + break; + default: + throw new IllegalArgumentException( + "Unsupported expr kind in attribute: " + node.exprKind()); + } + } + return CelAttributePattern.create(ImmutableList.copyOf(qualifiers)); + } catch (CelValidationException e) { + throw new IllegalArgumentException("Illegal CEL attribute", e); + } + } + + /** + * Parses a string formatted cel attribute into a {@link CelAttribute}. + * + *

Cel Attributes are represented by the fully-qualified cel selection path that would access + * the represented Attribute. As an extension, wild card qualifiers '.*' are supported to indicate + * that all fields or elements of the parent are unknown. + * + * @param attribute the string representation of the attribute. for example + * namespace.object.field['index']. + * @throws IllegalArgumentException if the provided string isn't a legal attribute representation. + */ + public static CelAttribute parse(String attribute) { + // Patterns are a super set of attributes. Create throws an + // IllegalArgumentException if a wildcard was used. + return CelAttribute.create(parsePattern(attribute).qualifiers()); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelAttributePattern.java b/runtime/src/main/java/dev/cel/runtime/CelAttributePattern.java new file mode 100644 index 000000000..ff5f3f5bf --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelAttributePattern.java @@ -0,0 +1,182 @@ +// Copyright 2022 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 static java.lang.Math.min; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; + +/** + * A Pattern for matching against {@link CelAttribute}s. + * + *

CelAttributePatterns are structured the same as attributes, but permit some qualifiers be + * replaced with wildcards. + */ +@Immutable +@AutoValue +public abstract class CelAttributePattern { + /** Constructs a CelAttributePattern from a list of qualifiers. */ + public static CelAttributePattern create(ImmutableList qualifiers) { + Preconditions.checkArgument(!qualifiers.isEmpty(), "qualifiers must be non-empty"); + Preconditions.checkArgument( + CelAttribute.Qualifier.isLegalIdentifier(qualifiers.get(0)), + "'%s' is not a legal CEL identifier", + qualifiers.get(0)); + + return new AutoValue_CelAttributePattern(qualifiers); + } + + /** Constructs a pattern from a single root identifier (single string qualifier). */ + public static CelAttributePattern create(String rootIdentifier) { + Preconditions.checkArgument( + CelAttribute.Qualifier.isLegalIdentifier(rootIdentifier), + "'%s' is not a legal CEL identifier", + rootIdentifier); + + return new AutoValue_CelAttributePattern( + ImmutableList.of(CelAttribute.Qualifier.ofString(rootIdentifier))); + } + + /** + * Attempts to parse a dot qualified identifier into a CEL attribute. + * + * @throws IllegalArgumentException if qualifiedIdentifier isn't a legal qualified identifier. + * Note: this is intended for use with reference names in a checked CEL expression -- it does + * not check for some edge cases (e.g. reserved words). + */ + public static CelAttributePattern fromQualifiedIdentifier(String qualifiedIdentifier) { + ImmutableList.Builder qualifiers = ImmutableList.builder(); + int start = 0; + int next; + while ((next = qualifiedIdentifier.indexOf('.', start)) != -1) { + qualifiers.add(CelAttribute.Qualifier.ofString(qualifiedIdentifier.substring(start, next))); + start = next + 1; + } + qualifiers.add(CelAttribute.Qualifier.ofString(qualifiedIdentifier.substring(start))); + return new AutoValue_CelAttributePattern(qualifiers.build()); + } + + /** The list of qualifiers representing the select paths this pattern matches. */ + public abstract ImmutableList qualifiers(); + + /** Create a new attribute pattern that specifies a subfield of this pattern. */ + public CelAttributePattern qualify(CelAttribute.Qualifier qualifier) { + return new AutoValue_CelAttributePattern( + ImmutableList.builderWithExpectedSize(qualifiers().size() + 1) + .addAll(qualifiers()) + .add(qualifier) + .build()); + } + + @Override + public final String toString() { + Preconditions.checkState( + !qualifiers().isEmpty() + && qualifiers().get(0).kind() == CelAttribute.Qualifier.Kind.AS_STRING, + "CelAttribute must have a root qualifier that is a legal identifier"); + + StringBuilder cname = new StringBuilder(qualifiers().get(0).asString()); + for (CelAttribute.Qualifier qualifier : qualifiers().subList(1, qualifiers().size())) { + switch (qualifier.kind()) { + case WILD_CARD: + cname.append(".*"); + break; + case AS_STRING: + if (CelAttribute.Qualifier.isLegalIdentifier(qualifier)) { + cname.append(".").append(qualifier.asString()); + } else { + cname.append(qualifier.toIndexFormat()); + } + break; + default: + cname.append(qualifier.toIndexFormat()); + break; + } + } + return cname.toString(); + } + + /** + * Return whether this pattern matches the given attribute. + * + *

A pattern matches an attribute if the pattern contains the attribute (e.g. fully matches the + * attribute or one of its parents). + */ + public boolean isMatch(CelAttribute attribute) { + if (attribute.equals(CelAttribute.EMPTY)) { + return false; + } + int qualifierCount = min(qualifiers().size(), attribute.qualifiers().size()); + int i = 0; + for (; i < qualifierCount; i++) { + CelAttribute.Qualifier pattern = qualifiers().get(i); + CelAttribute.Qualifier qualifier = attribute.qualifiers().get(i); + if (pattern.kind() != CelAttribute.Qualifier.Kind.WILD_CARD && !pattern.equals(qualifier)) { + return false; + } + } + // If the end of the loop is reached, either the pattern was exhausted (full match) or + // the attribute was exhausted (partial match / a sub field was matched). + return i >= qualifiers().size(); + } + + /** + * Return whether this pattern matches the given attribute or any of its descendants. + * + *

A partial match indicates that the attribute may contain some missing data, so the complete + * object is may be in an undefined state. For example: + * + *

    + *
  • pattern (this) object.field.list_field + *
  • attribute (arg) object.field + *
+ * + * is not a full match, but is a partial match. + */ + public boolean isPartialMatch(CelAttribute attribute) { + if (attribute.equals(CelAttribute.EMPTY)) { + return false; + } + int qualifierCount = min(qualifiers().size(), attribute.qualifiers().size()); + for (int i = 0; i < qualifierCount; i++) { + CelAttribute.Qualifier pattern = qualifiers().get(i); + CelAttribute.Qualifier qualifier = attribute.qualifiers().get(i); + if (pattern.kind() != CelAttribute.Qualifier.Kind.WILD_CARD && !pattern.equals(qualifier)) { + return false; + } + } + // If the end of the loop is reached, either the pattern was exhausted (full match) or + // the attribute was exhausted (partial match / a sub field was matched). + return true; + } + + /** + * Return an appropriate attribute for a pattern match. + * + *

For a partial match, return the attribute. + * + *

For a full match, return the (possibly parent attribute) + */ + public CelAttribute simplify(CelAttribute candidate) { + int patternLen = this.qualifiers().size(); + if (patternLen < candidate.qualifiers().size()) { + return CelAttribute.create(candidate.qualifiers().subList(0, patternLen)); + } + return candidate; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelAttributeResolver.java b/runtime/src/main/java/dev/cel/runtime/CelAttributeResolver.java new file mode 100644 index 000000000..e54284013 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelAttributeResolver.java @@ -0,0 +1,41 @@ +// Copyright 2022 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 java.util.Optional; + +/** + * Resolver for attribute lookups at runtime. + * + *

Attributes identify resolvable parts of state available in the CEL expression. + */ +public interface CelAttributeResolver { + /** + * Attempts to resolve an attribute exactly. + * + *

May return an UnknownSet if the attribute is unknown, a value if it has been resolved, or + * Optional.empty() if the attribute isn't declared as an unknown. + */ + Optional resolve(CelAttribute attr); + + /** + * Returns an unknown set containing the attribute if it is determined as partially unknown. + * + *

A partial match is defined as an attribute whose sub-elements match an unknown pattern. + * E.g., attribute com.google.container is partially unknown with pattern + * com.google.container.element + */ + Optional maybePartialUnknown(CelAttribute attr); +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelEvaluationException.java b/runtime/src/main/java/dev/cel/runtime/CelEvaluationException.java new file mode 100644 index 000000000..e4c028360 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelEvaluationException.java @@ -0,0 +1,38 @@ +// Copyright 2022 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 dev.cel.common.CelErrorCode; +import dev.cel.common.CelException; +import org.jspecify.annotations.Nullable; + +/** + * CelEvaluationException encapsulates the potential issues which could arise during the + * configuration or evaluation of an expression {@code Program}. + */ +public final class CelEvaluationException extends CelException { + + public CelEvaluationException(String message) { + super(message); + } + + public CelEvaluationException(String message, @Nullable Throwable cause) { + super(message, cause); + } + + CelEvaluationException(String message, @Nullable Throwable cause, CelErrorCode errorCode) { + super(message, cause, errorCode); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelEvaluationExceptionBuilder.java b/runtime/src/main/java/dev/cel/runtime/CelEvaluationExceptionBuilder.java new file mode 100644 index 000000000..986788bac --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelEvaluationExceptionBuilder.java @@ -0,0 +1,102 @@ +// Copyright 2025 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.CanIgnoreReturnValue; +import dev.cel.common.CelErrorCode; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelRuntimeException; +import dev.cel.common.internal.SafeStringFormatter; +import org.jspecify.annotations.Nullable; + +/** CEL Library Internals. Do not use. */ +@Internal +public final class CelEvaluationExceptionBuilder { + + private String message = ""; + private Throwable cause; + private CelErrorCode errorCode; + private String errorLocation; + + @CanIgnoreReturnValue + public CelEvaluationExceptionBuilder setCause(@Nullable Throwable cause) { + this.cause = cause; + return this; + } + + @CanIgnoreReturnValue + public CelEvaluationExceptionBuilder setErrorCode(CelErrorCode errorCode) { + this.errorCode = errorCode; + return this; + } + + @CanIgnoreReturnValue + public CelEvaluationExceptionBuilder setMetadata(Metadata metadata, long exprId) { + if (metadata.hasPosition(exprId)) { + this.errorLocation = + SafeStringFormatter.format( + " at %s:%d", metadata.getLocation(), metadata.getPosition(exprId)); + } + + return this; + } + + /** + * Constructs a new {@link CelEvaluationException} instance. + * + *

CEL Library Internals. Do not use. + */ + @Internal + public CelEvaluationException build() { + return new CelEvaluationException( + SafeStringFormatter.format("evaluation error%s: %s", errorLocation, message), + cause, + errorCode); + } + + /** + * Constructs a new builder for {@link CelEvaluationException} + * + *

CEL Library Internals. Do not use. + */ + @Internal + public static CelEvaluationExceptionBuilder newBuilder(String message, Object... args) { + return new CelEvaluationExceptionBuilder(SafeStringFormatter.format(message, args)); + } + + /** + * Constructs a new builder for {@link CelEvaluationException} + * + *

CEL Library Internals. Do not use. + */ + @Internal + public static CelEvaluationExceptionBuilder newBuilder(CelRuntimeException celRuntimeException) { + // Intercept the cause to prevent including the cause's class name in the exception message. + String message = + celRuntimeException.getCause() == null + ? celRuntimeException.getMessage() + : celRuntimeException.getCause().getMessage(); + + return new CelEvaluationExceptionBuilder(message) + .setErrorCode(celRuntimeException.getErrorCode()) + .setCause(celRuntimeException); + } + + private CelEvaluationExceptionBuilder(String message) { + this.message = message == null ? "" : message; + this.errorCode = CelErrorCode.INTERNAL_ERROR; + this.errorLocation = ""; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelEvaluationListener.java b/runtime/src/main/java/dev/cel/runtime/CelEvaluationListener.java new file mode 100644 index 000000000..0afc1f5e2 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelEvaluationListener.java @@ -0,0 +1,35 @@ +// Copyright 2023 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 javax.annotation.concurrent.ThreadSafe; +import dev.cel.common.ast.CelExpr; + +/** + * Functional interface for a callback method invoked by the runtime. Implementations must ensure + * that its instances are unconditionally thread-safe. + */ +@FunctionalInterface +@ThreadSafe +public interface CelEvaluationListener { + + /** + * Callback method invoked by the CEL runtime as evaluation progresses through the AST. + * + * @param expr CelExpr that was evaluated to produce the evaluated result. + * @param evaluatedResult Evaluated result. + */ + void callback(CelExpr expr, Object evaluatedResult); +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelFunctionBinding.java b/runtime/src/main/java/dev/cel/runtime/CelFunctionBinding.java new file mode 100644 index 000000000..98991d383 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelFunctionBinding.java @@ -0,0 +1,122 @@ +// Copyright 2025 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 static com.google.common.base.Preconditions.checkArgument; + +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import java.util.Collection; + +/** + * Binding consisting of an overload id, a Java-native argument signature, and an overload + * definition. + * + *

While the CEL function has a human-readable {@code camelCase} name, overload ids should use + * the following convention where all {@code } names should be ASCII lower-cased. For types + * prefer the unparameterized simple name of time, or unqualified name of any proto-based type: + * + *

    + *
  • unary member function: _ + *
  • binary member function: __ + *
  • unary global function: _ + *
  • binary global function: __ + *
  • global function: ___ + *
+ * + *

Examples: string_startsWith_string, mathMax_list, lessThan_money_money + */ +@Immutable +public interface CelFunctionBinding { + String getOverloadId(); + + ImmutableList> getArgTypes(); + + CelFunctionOverload getDefinition(); + + boolean isStrict(); + + /** Create a unary function binding from the {@code overloadId}, {@code arg}, and {@code impl}. */ + @SuppressWarnings("unchecked") // Safe from CelFunctionOverload.canHandle check before invocation + static CelFunctionBinding from( + String overloadId, Class arg, CelFunctionOverload.Unary impl) { + return from( + overloadId, + ImmutableList.of(arg), + new OptimizedFunctionOverload() { + @Override + public Object apply(Object[] args) throws CelEvaluationException { + return impl.apply((T) args[0]); + } + + @Override + public Object apply(Object arg1) throws CelEvaluationException { + return impl.apply((T) arg1); + } + }); + } + + /** + * Create a binary function binding from the {@code overloadId}, {@code arg1}, {@code arg2}, and + * {@code impl}. + */ + @SuppressWarnings("unchecked") // Safe from CelFunctionOverload.canHandle check before invocation + static CelFunctionBinding from( + String overloadId, Class arg1, Class arg2, CelFunctionOverload.Binary impl) { + return from( + overloadId, + ImmutableList.of(arg1, arg2), + new OptimizedFunctionOverload() { + @Override + public Object apply(Object[] args) throws CelEvaluationException { + return impl.apply((T1) args[0], (T2) args[1]); + } + + @Override + public Object apply(Object arg1, Object arg2) throws CelEvaluationException { + return impl.apply((T1) arg1, (T2) arg2); + } + }); + } + + /** Create a function binding from the {@code overloadId}, {@code argTypes}, and {@code impl}. */ + static CelFunctionBinding from( + String overloadId, Iterable> argTypes, CelFunctionOverload impl) { + return new FunctionBindingImpl( + overloadId, ImmutableList.copyOf(argTypes), impl, /* isStrict= */ true); + } + + + /** See {@link #fromOverloads(String, Collection)}. */ + static ImmutableSet fromOverloads( + String functionName, CelFunctionBinding... overloadBindings) { + return fromOverloads(functionName, ImmutableList.copyOf(overloadBindings)); + } + + /** + * Creates a set of bindings for a function, enabling dynamic dispatch logic to select the correct + * overload at runtime based on argument types. + */ + static ImmutableSet fromOverloads( + String functionName, Collection overloadBindings) { + checkArgument(!Strings.isNullOrEmpty(functionName), "Function name cannot be null or empty"); + checkArgument(!overloadBindings.isEmpty(), "You must provide at least one binding."); + + return FunctionBindingImpl.groupOverloadsToFunction( + functionName, ImmutableSet.copyOf(overloadBindings)); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelFunctionOverload.java b/runtime/src/main/java/dev/cel/runtime/CelFunctionOverload.java new file mode 100644 index 000000000..c5f75096d --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelFunctionOverload.java @@ -0,0 +1,103 @@ +// Copyright 2024 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.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import java.util.Map; + +/** Interface describing the general signature of all CEL custom function implementations. */ +@Immutable +@FunctionalInterface +public interface CelFunctionOverload { + + /** Evaluate a set of arguments throwing a {@code CelException} on error. */ + Object apply(Object[] args) throws CelEvaluationException; + + + /** + * Helper interface for describing unary functions where the type-parameter is used to improve + * compile-time correctness of function bindings. + */ + @Immutable + @FunctionalInterface + interface Unary { + Object apply(T arg) throws CelEvaluationException; + } + + /** + * Helper interface for describing binary functions where the type parameters are used to improve + * compile-time correctness of function bindings. + */ + @Immutable + @FunctionalInterface + interface Binary { + Object apply(T1 arg1, T2 arg2) throws CelEvaluationException; + } + + /** + * Returns true if the overload's expected argument types match the types of the given arguments. + */ + static boolean canHandle( + Object[] arguments, ImmutableList> parameterTypes, boolean isStrict) { + if (parameterTypes.size() != arguments.length) { + return false; + } + for (int i = 0; i < parameterTypes.size(); i++) { + Class paramType = parameterTypes.get(i); + Object arg = arguments[i]; + boolean result = canHandleArg(arg, paramType, isStrict); + if (!result) { + return false; + } + } + return true; + } + + static boolean canHandle(Object arg, ImmutableList> parameterTypes, boolean isStrict) { + if (parameterTypes.size() != 1) { + return false; + } + return canHandleArg(arg, parameterTypes.get(0), isStrict); + } + + static boolean canHandle( + Object arg1, Object arg2, ImmutableList> parameterTypes, boolean isStrict) { + if (parameterTypes.size() != 2) { + return false; + } + return canHandleArg(arg1, parameterTypes.get(0), isStrict) + && canHandleArg(arg2, parameterTypes.get(1), isStrict); + } + + static boolean canHandleArg(Object arg, Class paramType, boolean isStrict) { + // null can be assigned to messages, maps, and to objects. + // TODO: Remove null special casing + if (arg == null) { + if (paramType != Object.class && !Map.class.isAssignableFrom(paramType)) { + return false; + } + return true; + } + + if (arg instanceof Exception || arg instanceof CelUnknownSet) { + if (!isStrict) { + return true; + } + } + + return paramType.isAssignableFrom(arg.getClass()); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelFunctionResolver.java b/runtime/src/main/java/dev/cel/runtime/CelFunctionResolver.java new file mode 100644 index 000000000..2fb136a1a --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelFunctionResolver.java @@ -0,0 +1,53 @@ +// Copyright 2024 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 javax.annotation.concurrent.ThreadSafe; +import java.util.Collection; +import java.util.Optional; + +/** + * Interface to a resolver for CEL functions based on the function name, overload ids, and + * arguments. + */ +@ThreadSafe +public interface CelFunctionResolver { + + /** + * Finds a specific function overload to invoke based on given parameters. + * + * @param functionName the logical name of the function being invoked. + * @param overloadIds A list of function overload ids. The dispatcher selects the unique overload + * from this list with matching arguments. + * @param args The arguments to pass to the function. + * @return an optional value of the resolved overload. + * @throws CelEvaluationException if the overload resolution is ambiguous, + */ + Optional findOverloadMatchingArgs( + String functionName, Collection overloadIds, Object[] args) + throws CelEvaluationException; + + /** + * Finds a specific function overload to invoke based on given parameters, scanning all available + * overloads if necessary. + * + * @param functionName the logical name of the function being invoked. + * @param args The arguments to pass to the function. + * @return an optional value of the resolved overload. + * @throws CelEvaluationException if the overload resolution is ambiguous. + */ + Optional findOverloadMatchingArgs(String functionName, Object[] args) + throws CelEvaluationException; +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelInternalRuntimeLibrary.java b/runtime/src/main/java/dev/cel/runtime/CelInternalRuntimeLibrary.java new file mode 100644 index 000000000..b6a6f02b2 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelInternalRuntimeLibrary.java @@ -0,0 +1,35 @@ +// Copyright 2025 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 dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; + +/** + * CelInternalRuntimeLibrary defines the interface to extend functionalities beyond the CEL standard + * functions for {@link CelRuntime}, with access to runtime internals. This is not intended for + * general use. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public interface CelInternalRuntimeLibrary extends CelRuntimeLibrary { + + /** + * Configures the runtime to support the library implementation, such as adding function bindings. + */ + void setRuntimeOptions( + CelRuntimeBuilder runtimeBuilder, RuntimeEquality runtimeEquality, CelOptions celOptions); +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelLateFunctionBindings.java b/runtime/src/main/java/dev/cel/runtime/CelLateFunctionBindings.java new file mode 100644 index 000000000..2da08120c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelLateFunctionBindings.java @@ -0,0 +1,77 @@ +// Copyright 2024 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 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; +import java.util.Optional; + +/** + * Collection of {@link CelFunctionBinding} values which are intended to be created once + * per-evaluation, rather than once per-program setup. + */ +@Immutable +public final class CelLateFunctionBindings implements CelFunctionResolver { + + private final ImmutableMap functions; + + private CelLateFunctionBindings(ImmutableMap functions) { + this.functions = functions; + } + + @Override + public Optional findOverloadMatchingArgs( + String functionName, Collection overloadIds, Object[] args) + throws CelEvaluationException { + return DefaultDispatcher.findOverloadMatchingArgs(functionName, overloadIds, functions, args); + } + + @Override + public Optional findOverloadMatchingArgs(String functionName, Object[] args) + throws CelEvaluationException { + return DefaultDispatcher.findOverloadMatchingArgs( + functionName, functions.keySet(), functions, args); + } + + public static CelLateFunctionBindings from(CelFunctionBinding... functions) { + return from(Arrays.asList(functions)); + } + + public static CelLateFunctionBindings from(Collection functions) { + return new CelLateFunctionBindings( + functions.stream() + .collect( + toImmutableMap( + CelFunctionBinding::getOverloadId, + CelLateFunctionBindings::createResolvedOverload))); + } + + 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()); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelLiteRuntime.java b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntime.java new file mode 100644 index 000000000..af8e918f6 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntime.java @@ -0,0 +1,35 @@ +// Copyright 2025 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 javax.annotation.concurrent.ThreadSafe; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.annotations.Beta; + +/** + * CelLiteRuntime creates executable {@link Program} instances from {@link CelAbstractSyntaxTree} + * values. + * + *

CelLiteRuntime supports protolite messages, and does not directly depend on full-version of + * the protobuf, making it suitable for use in Android. + */ +@ThreadSafe +@Beta +public interface CelLiteRuntime { + + Program createProgram(CelAbstractSyntaxTree ast) throws CelEvaluationException; + + CelLiteRuntimeBuilder toRuntimeBuilder(); +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeBuilder.java b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeBuilder.java new file mode 100644 index 000000000..48b51274d --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeBuilder.java @@ -0,0 +1,67 @@ +// Copyright 2025 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.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.CelOptions; +import dev.cel.common.values.CelValueProvider; +import dev.cel.runtime.standard.CelStandardFunction; + +/** Interface for building an instance of {@link CelLiteRuntime} */ +public interface CelLiteRuntimeBuilder { + + /** Set the {@code CelOptions} used to enable fixes and features for this CEL instance. */ + @CanIgnoreReturnValue + CelLiteRuntimeBuilder setOptions(CelOptions options); + + /** + * Set the standard functions to enable in the runtime. These can be found in {@code + * dev.cel.runtime.standard} package. By default, lite runtime does not include any standard + * functions on its own. + */ + @CanIgnoreReturnValue + CelLiteRuntimeBuilder setStandardFunctions(CelStandardFunction... standardFunctions); + + @CanIgnoreReturnValue + CelLiteRuntimeBuilder setStandardFunctions( + Iterable standardFunctions); + + /** Add one or more {@link CelFunctionBinding} objects to the CEL runtime. */ + @CanIgnoreReturnValue + CelLiteRuntimeBuilder addFunctionBindings(CelFunctionBinding... bindings); + + /** Bind a collection of {@link CelFunctionBinding} objects to the runtime. */ + @CanIgnoreReturnValue + CelLiteRuntimeBuilder addFunctionBindings(Iterable bindings); + + /** + * Sets the {@link CelValueProvider} for resolving struct values during evaluation. Multiple + * providers can be combined using {@code CombinedCelValueProvider}. Note that if you intend to + * support proto messages in addition to custom struct values, protobuf value provider must be + * configured first before the custom value provider. + */ + @CanIgnoreReturnValue + CelLiteRuntimeBuilder setValueProvider(CelValueProvider celValueProvider); + + @CanIgnoreReturnValue + CelLiteRuntimeBuilder addLibraries(CelLiteRuntimeLibrary... libraries); + + @CanIgnoreReturnValue + CelLiteRuntimeBuilder addLibraries(Iterable libraries); + + @CheckReturnValue + CelLiteRuntime build(); +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeFactory.java b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeFactory.java new file mode 100644 index 000000000..260a62980 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeFactory.java @@ -0,0 +1,29 @@ +// Copyright 2025 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 dev.cel.common.annotations.Beta; + +/** Factory class for producing a lite runtime environment. */ +@Beta +public final class CelLiteRuntimeFactory { + + /** Create a new builder for constructing a {@code CelLiteRuntime} instance. */ + public static CelLiteRuntimeBuilder newLiteRuntimeBuilder() { + return LiteRuntimeImpl.newBuilder(); + } + + private CelLiteRuntimeFactory() {} +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeLibrary.java b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeLibrary.java new file mode 100644 index 000000000..fff9ed93d --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeLibrary.java @@ -0,0 +1,27 @@ +// Copyright 2025 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; + +/** + * CelLiteRuntimeLibrary defines the interface to extend functionalities beyond the CEL standard + * functions for {@link CelLiteRuntime}. + */ +public interface CelLiteRuntimeLibrary { + + /** + * Configures the runtime to support the library implementation, such as adding function bindings. + */ + void setRuntimeOptions(CelLiteRuntimeBuilder runtimeBuilder); +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelResolvedOverload.java b/runtime/src/main/java/dev/cel/runtime/CelResolvedOverload.java new file mode 100644 index 000000000..fbe9a3289 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelResolvedOverload.java @@ -0,0 +1,132 @@ +// Copyright 2024 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.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelOverloadNotFoundException; +import java.util.List; + +/** + * Representation of a function overload which has been resolved to a specific set of argument types + * and a function definition. + */ +@AutoValue +@Immutable +@Internal +public abstract class CelResolvedOverload { + + /** The base function name. */ + public abstract String getFunctionName(); + + /** The overload id of the function. */ + public abstract String getOverloadId(); + + /** The types of the function parameters. */ + public abstract ImmutableList> getParameterTypes(); + + /* Denotes whether an overload is strict. + * + *

A strict function will not be invoked if any of its arguments are an error or unknown value. + * The runtime automatically propagates the error or unknown instead. + * + *

A non-strict function will be invoked even if its arguments contain errors or unknowns. The + * function's implementation is then responsible for handling these values. This is primarily used + * for short-circuiting logical operators (e.g., `||`, `&&`) and comprehension's + * internal @not_strictly_false function. + * + *

In a vast majority of cases, this should be set to true. + */ + public abstract boolean isStrict(); + + /** The function definition. */ + public abstract CelFunctionOverload getDefinition(); + + abstract OptimizedFunctionOverload getOptimizedDefinition(); + + 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); + } + 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(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(getFunctionName(), ImmutableList.of(getOverloadId())); + } + + /** + * 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(functionName, overloadId, definition, isStrict, ImmutableList.copyOf(parameterTypes)); + } + + /** + * 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, + List> parameterTypes) { + OptimizedFunctionOverload optimizedDef = + (definition instanceof OptimizedFunctionOverload) + ? (OptimizedFunctionOverload) definition + : definition::apply; + return new AutoValue_CelResolvedOverload( + functionName, + overloadId, + ImmutableList.copyOf(parameterTypes), + isStrict, + definition, + optimizedDef); + } + + /** + * Returns true if the overload's expected argument types match the types of the given arguments. + */ + boolean canHandle(Object[] arguments) { + return CelFunctionOverload.canHandle(arguments, getParameterTypes(), isStrict()); + } + + private boolean isDynamicDispatch() { + return getDefinition() instanceof FunctionBindingImpl.DynamicDispatchOverload; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelRuntime.java b/runtime/src/main/java/dev/cel/runtime/CelRuntime.java new file mode 100644 index 000000000..1e7fdcac8 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelRuntime.java @@ -0,0 +1,112 @@ +// Copyright 2022 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.CanIgnoreReturnValue; +import com.google.errorprone.annotations.Immutable; +import javax.annotation.concurrent.ThreadSafe; +import com.google.protobuf.Message; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import java.util.Map; + +/** + * The CelRuntime creates executable {@code Program} instances from {@code CelAbstractSyntaxTree} + * values. + */ +@ThreadSafe +public interface CelRuntime { + + /** Creates a {@code Program} from the input {@code ast}. */ + @CanIgnoreReturnValue + Program createProgram(CelAbstractSyntaxTree ast) throws CelEvaluationException; + + CelRuntimeBuilder toRuntimeBuilder(); + + /** Creates an evaluable {@code Program} instance which is thread-safe and immutable. */ + @Immutable + interface Program extends dev.cel.runtime.Program { + + /** Evaluate the expression using {@code message} fields as the source of input variables. */ + Object eval(Message message) throws CelEvaluationException; + + /** + * Trace evaluates a compiled program without any variables and invokes the listener as + * evaluation progresses through the AST. + */ + Object trace(CelEvaluationListener listener) throws CelEvaluationException; + + /** + * Trace evaluates a compiled program using a {@code mapValue} as the source of input variables. + * The listener is invoked as evaluation progresses through the AST. + */ + Object trace(Map mapValue, CelEvaluationListener listener) + throws CelEvaluationException; + + /** + * Trace evaluates a compiled program using {@code message} fields as the source of input + * variables. The listener is invoked as evaluation progresses through the AST. + */ + Object trace(Message message, CelEvaluationListener listener) throws CelEvaluationException; + + /** + * Trace evaluates a compiled program using a custom variable {@code resolver}. The listener is + * invoked as evaluation progresses through the AST. + */ + Object trace(CelVariableResolver resolver, CelEvaluationListener listener) + throws CelEvaluationException; + + /** + * Trace evaluates a compiled program using a custom variable {@code resolver} and late-bound + * functions {@code lateBoundFunctionResolver}. The listener is invoked as evaluation progresses + * through the AST. + */ + Object trace( + CelVariableResolver resolver, + CelFunctionResolver lateBoundFunctionResolver, + CelEvaluationListener listener) + throws CelEvaluationException; + + /** + * Trace evaluates a compiled program using a {@code mapValue} as the source of input variables + * and late-bound functions {@code lateBoundFunctionResolver}. The listener is invoked as + * evaluation progresses through the AST. + */ + Object trace( + Map mapValue, + CelFunctionResolver lateBoundFunctionResolver, + CelEvaluationListener listener) + throws CelEvaluationException; + + /** + * Trace evaluates a compiled program using {@code partialVars} as the source of input variables + * and unknown attribute patterns. The listener is invoked as evaluation progresses through the + * AST. + */ + Object trace(PartialVars partialVars, CelEvaluationListener listener) + throws CelEvaluationException; + + /** + * Advance evaluation based on the current unknown context. + * + *

This represents one round of incremental evaluation and may return a final result or a + * CelUnknownSet. + * + *

If no unknowns are declared in the context or {@link CelOptions#enableUnknownTracking() + * UnknownTracking} is disabled, this is equivalent to eval. + */ + Object advanceEvaluation(UnknownContext context) throws CelEvaluationException; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelRuntimeBuilder.java b/runtime/src/main/java/dev/cel/runtime/CelRuntimeBuilder.java new file mode 100644 index 000000000..87f11fde2 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelRuntimeBuilder.java @@ -0,0 +1,211 @@ +// Copyright 2022 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.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.Message; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.values.CelValueProvider; +import java.util.function.Function; + +/** Interface for building an instance of CelRuntime */ +public interface CelRuntimeBuilder { + + /** Set the {@code CelOptions} used to enable fixes and features for this CEL instance. */ + @CanIgnoreReturnValue + CelRuntimeBuilder setOptions(CelOptions options); + + /** + * Add one or more {@link CelFunctionBinding} objects to the CEL runtime. + * + *

Functions with duplicate overload ids will be replaced in favor of the new overload. + */ + @CanIgnoreReturnValue + CelRuntimeBuilder addFunctionBindings(CelFunctionBinding... bindings); + + /** + * Bind a collection of {@link CelFunctionBinding} objects to the runtime. + * + *

Functions with duplicate overload ids will be replaced in favor of the new overload. + */ + @CanIgnoreReturnValue + CelRuntimeBuilder addFunctionBindings(Iterable bindings); + + /** Adds bindings for functions that are allowed to be late-bound (resolved at execution time). */ + @CanIgnoreReturnValue + CelRuntimeBuilder addLateBoundFunctions(String... lateBoundFunctionNames); + + /** Adds bindings for functions that are allowed to be late-bound (resolved at execution time). */ + @CanIgnoreReturnValue + CelRuntimeBuilder addLateBoundFunctions(Iterable lateBoundFunctionNames); + + /** + * Add message {@link Descriptor}s to the builder for type-checking and object creation at + * interpretation time. + * + *

Note, it is valid to combine type factory methods within the runtime. Only the options which + * have been configured will be used. The type creation search order is as follows: + * + *

    + *
  • Custom type factory ({@link #setTypeFactory}) + *
  • Custom descriptor set {{@code #addMessageTypes}) + *
+ */ + @CanIgnoreReturnValue + CelRuntimeBuilder addMessageTypes(Descriptor... descriptors); + + /** + * Add message {@link Descriptor}s to the use for type-checking and object creation at + * interpretation time. + * + *

Note, it is valid to combine type factory methods within the runtime. Only the options which + * have been configured will be used. The type creation search order is as follows: + * + *

    + *
  • Custom type factory ({@link #setTypeFactory}) + *
  • Custom descriptor set {{@code #addMessageTypes}) + *
+ */ + @CanIgnoreReturnValue + CelRuntimeBuilder addMessageTypes(Iterable descriptors); + + /** + * Add {@link FileDescriptor}s to the use for type-checking, and for object creation at + * interpretation time. + * + *

Note, it is valid to combine type factory methods within the runtime. Only the options which + * have been configured will be used. The type creation search order is as follows: + * + *

    + *
  • Custom type factory ({@link #setTypeFactory}) + *
  • Custom descriptor set {{@link #addMessageTypes}) + *
+ */ + @CanIgnoreReturnValue + CelRuntimeBuilder addFileTypes(FileDescriptor... fileDescriptors); + + /** + * Add {@link FileDescriptor}s to the use for type-checking, and for object creation at + * interpretation time. + * + *

Note, it is valid to combine type factory methods within the runtime. Only the options which + * have been configured will be used. The type creation search order is as follows: + * + *

    + *
  • Custom type factory ({@link #setTypeFactory}) + *
  • Custom descriptor set {{@link #addMessageTypes}) + *
+ */ + @CanIgnoreReturnValue + CelRuntimeBuilder addFileTypes(Iterable fileDescriptors); + + /** + * Add all of the {@link FileDescriptor}s in a {@code FileDescriptorSet} to the use for + * type-checking, and for object creation at interpretation time. + * + *

Note, it is valid to combine type factory methods within the runtime. Only the options which + * have been configured will be used. The type creation search order is as follows: + * + *

    + *
  • Custom type factory ({@link #setTypeFactory}) + *
  • Custom descriptor set {{@link #addMessageTypes}) + *
+ */ + @CanIgnoreReturnValue + CelRuntimeBuilder addFileTypes(FileDescriptorSet fileDescriptorSet); + + /** + * Sets the {@link CelTypeProvider} for resolving CEL types during evaluation, such as a fully + * qualified type name to a struct or an enum value. + */ + @CanIgnoreReturnValue + CelRuntimeBuilder setTypeProvider(CelTypeProvider celTypeProvider); + + /** + * Set a custom type factory for the runtime. + * + *

Note: it is valid to combine type factory methods within the runtime. Only the options which + * have been configured will be used. + * + *

The type creation search order is as follows: + * + *

    + *
  • Custom type factory ({@code #setTypeFactory}) + *
  • Custom descriptor set {{@link #addMessageTypes}) + *
+ */ + @CanIgnoreReturnValue + CelRuntimeBuilder setTypeFactory(Function typeFactory); + + /** + * Sets the {@link CelValueProvider} for resolving struct values during evaluation. Multiple + * providers can be combined using {@code CombinedCelValueProvider}. Note that if you intend to + * support proto messages in addition to custom struct values, protobuf value provider must be + * configured first before the custom value provider. + * + *

Note that this option is only supported for planner-based runtime. + */ + @CanIgnoreReturnValue + CelRuntimeBuilder setValueProvider(CelValueProvider celValueProvider); + + /** Enable or disable the standard CEL library functions and variables. */ + @CanIgnoreReturnValue + CelRuntimeBuilder setStandardEnvironmentEnabled(boolean value); + + /** + * Override the standard functions for the runtime. This can be used to subset the standard + * environment to only expose the desired function overloads to the runtime. + * + *

{@link #setStandardEnvironmentEnabled(boolean)} must be set to false for this to take + * effect. + */ + @CanIgnoreReturnValue + CelRuntimeBuilder setStandardFunctions(CelStandardFunctions standardFunctions); + + /** Adds one or more libraries for runtime. */ + @CanIgnoreReturnValue + CelRuntimeBuilder addLibraries(CelRuntimeLibrary... libraries); + + /** Adds a collection of libraries for runtime. */ + @CanIgnoreReturnValue + CelRuntimeBuilder addLibraries(Iterable libraries); + + /** + * Sets a proto ExtensionRegistry to assist with unpacking Any messages containing a proto2 + extension field. + */ + @CanIgnoreReturnValue + CelRuntimeBuilder setExtensionRegistry(ExtensionRegistry extensionRegistry); + + + /** + * Set the {@link CelContainer} to use as the namespace for resolving CEL expression variables and + * functions. + */ + @CanIgnoreReturnValue + CelRuntimeBuilder setContainer(CelContainer container); + + + /** Build a new instance of the {@code CelRuntime}. */ + @CheckReturnValue + CelRuntime build(); +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelRuntimeFactory.java b/runtime/src/main/java/dev/cel/runtime/CelRuntimeFactory.java new file mode 100644 index 000000000..6615b59e0 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelRuntimeFactory.java @@ -0,0 +1,55 @@ +// Copyright 2022 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 dev.cel.common.CelOptions; + +/** Helper class to construct new {@code CelRuntime} instances. */ +public final class CelRuntimeFactory { + + /** + * Create a new builder for constructing a {@code CelRuntime} instance. + * + *

Note, the {@link CelOptions#current}, standard CEL function libraries, and linked message + * evaluation are enabled by default. + */ + public static CelRuntimeBuilder standardCelRuntimeBuilder() { + return CelRuntimeLegacyImpl.newBuilder() + .setOptions(CelOptions.current().build()) + // CEL-Internal-2 + .setStandardEnvironmentEnabled(true); + } + + /** + * Create a new builder for constructing a {@code CelRuntime} instance. + * + *

The {@code ProgramPlanner} architecture provides key benefits over the {@link + * #standardCelRuntimeBuilder()}: + * + *

    + *
  • Performance: Programs can be cached for improving evaluation speed. + *
  • Parsed-only expression evaluation: Unlike the runtime returned by {@link + * #standardCelRuntimeBuilder()}, which only supported evaluating type-checked expressions, + * this architecture handles both parsed-only and type-checked expressions. + *
+ */ + public static CelRuntimeBuilder plannerRuntimeBuilder() { + return CelRuntimeImpl.newBuilder() + // CEL-Internal-2 + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()); + } + + private CelRuntimeFactory() {} +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelRuntimeImpl.java b/runtime/src/main/java/dev/cel/runtime/CelRuntimeImpl.java new file mode 100644 index 000000000..b02f64b61 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelRuntimeImpl.java @@ -0,0 +1,553 @@ +// 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 static com.google.common.base.Preconditions.checkNotNull; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.DescriptorProtos; +import com.google.protobuf.Descriptors; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.Message; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.CelDescriptorPool; +import dev.cel.common.internal.CombinedDescriptorPool; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +// CEL-Internal-1 +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.DefaultTypeProvider; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.common.values.CelValueConverter; +import dev.cel.common.values.CelValueProvider; +import dev.cel.common.values.CombinedCelValueProvider; +import dev.cel.common.values.ProtoMessageValueProvider; +import dev.cel.runtime.planner.PlannedProgram; +import dev.cel.runtime.planner.ProgramPlanner; +import dev.cel.runtime.standard.TypeFunction; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; +import org.jspecify.annotations.Nullable; + +/** + * {@link CelRuntime} implementation based on the {@link ProgramPlanner}. + * + *

CEL Library Internals. Do Not Use. + */ +@AutoValue +@Internal +@Immutable +public abstract class CelRuntimeImpl implements CelRuntime { + + abstract ProgramPlanner planner(); + + abstract CelOptions options(); + + abstract CelContainer container(); + + abstract ImmutableMap functionBindings(); + + abstract ImmutableSet fileDescriptors(); + + // Callers must guarantee that a custom runtime library is immutable. CEL provided ones are + // immutable by default. + @SuppressWarnings("Immutable") + @AutoValue.CopyAnnotations + abstract ImmutableSet runtimeLibraries(); + + abstract ImmutableSet lateBoundFunctionNames(); + + abstract CelStandardFunctions standardFunctions(); + + abstract @Nullable CelTypeProvider typeProvider(); + + abstract @Nullable CelValueProvider valueProvider(); + + // Extension registry is unmodifiable. Just not marked as such from Protobuf's implementation. + @SuppressWarnings("Immutable") + @AutoValue.CopyAnnotations + abstract @Nullable ExtensionRegistry extensionRegistry(); + + @Override + public Program createProgram(CelAbstractSyntaxTree ast) throws CelEvaluationException { + return toRuntimeProgram(planner().plan(ast)); + } + + private static final CelFunctionResolver EMPTY_FUNCTION_RESOLVER = + new CelFunctionResolver() { + @Override + public Optional findOverloadMatchingArgs( + String functionName, Collection overloadIds, Object[] args) { + return Optional.empty(); + } + + @Override + public Optional findOverloadMatchingArgs( + String functionName, Object[] args) { + return Optional.empty(); + } + }; + + public Program toRuntimeProgram(dev.cel.runtime.Program program) { + return new Program() { + + @Override + public Object eval() throws CelEvaluationException { + return program.eval(); + } + + @Override + public Object eval(Map mapValue) throws CelEvaluationException { + return program.eval(mapValue); + } + + @Override + public Object eval(Map mapValue, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException { + return program.eval(mapValue, lateBoundFunctionResolver); + } + + @Override + public Object eval(Message message) throws CelEvaluationException { + PlannedProgram plannedProgram = (PlannedProgram) program; + return plannedProgram.evalOrThrow( + plannedProgram.interpretable(), + ProtoMessageActivationFactory.fromProto(message, plannedProgram.options()), + EMPTY_FUNCTION_RESOLVER, + /* partialVars= */ null, + /* listener= */ null); + } + + @Override + public Object eval(CelVariableResolver resolver) throws CelEvaluationException { + return program.eval(resolver); + } + + @Override + public Object eval( + CelVariableResolver resolver, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException { + return program.eval(resolver, lateBoundFunctionResolver); + } + + @Override + public Object eval(PartialVars partialVars) throws CelEvaluationException { + return program.eval(partialVars); + } + + @Override + public Object trace(CelEvaluationListener listener) throws CelEvaluationException { + return ((PlannedProgram) program) + .trace(GlobalResolver.EMPTY, EMPTY_FUNCTION_RESOLVER, null, listener); + } + + @Override + public Object trace(Map mapValue, CelEvaluationListener listener) + throws CelEvaluationException { + return ((PlannedProgram) program) + .trace(Activation.copyOf(mapValue), EMPTY_FUNCTION_RESOLVER, null, listener); + } + + @Override + public Object trace(Message message, CelEvaluationListener listener) + throws CelEvaluationException { + PlannedProgram plannedProgram = (PlannedProgram) program; + return plannedProgram.evalOrThrow( + plannedProgram.interpretable(), + ProtoMessageActivationFactory.fromProto(message, plannedProgram.options()), + EMPTY_FUNCTION_RESOLVER, + /* partialVars= */ null, + listener); + } + + @Override + public Object trace(CelVariableResolver resolver, CelEvaluationListener listener) + throws CelEvaluationException { + return ((PlannedProgram) program) + .trace( + (name) -> resolver.find(name).orElse(null), + EMPTY_FUNCTION_RESOLVER, + null, + listener); + } + + @Override + public Object trace( + CelVariableResolver resolver, + CelFunctionResolver lateBoundFunctionResolver, + CelEvaluationListener listener) + throws CelEvaluationException { + return ((PlannedProgram) program) + .trace( + (name) -> resolver.find(name).orElse(null), + lateBoundFunctionResolver, + null, + listener); + } + + @Override + public Object trace( + Map mapValue, + CelFunctionResolver lateBoundFunctionResolver, + CelEvaluationListener listener) + throws CelEvaluationException { + return ((PlannedProgram) program) + .trace(Activation.copyOf(mapValue), lateBoundFunctionResolver, null, listener); + } + + @Override + public Object trace(PartialVars partialVars, CelEvaluationListener listener) + throws CelEvaluationException { + return ((PlannedProgram) program) + .trace( + (name) -> partialVars.resolver().find(name).orElse(null), + EMPTY_FUNCTION_RESOLVER, + partialVars, + listener); + } + + @Override + public Object advanceEvaluation(UnknownContext context) throws CelEvaluationException { + throw new UnsupportedOperationException("Unsupported operation."); + } + }; + } + + @Override + public abstract Builder toRuntimeBuilder(); + + /** + * CEL Library Internals. Do not use. Consumers should use {@code CelRuntimeFactory} instead. + * + *

TODO: Restrict visibility once factory is introduced + */ + public static Builder newBuilder() { + return new AutoValue_CelRuntimeImpl.Builder() + .setFunctionBindings(ImmutableMap.of()) + .setStandardFunctions(CelStandardFunctions.newBuilder().build()) + .setContainer(CelContainer.newBuilder().build()) + .setExtensionRegistry(ExtensionRegistry.getEmptyRegistry()); + } + + /** Builder for {@link CelRuntimeImpl}. */ + @AutoValue.Builder + public abstract static class Builder implements CelRuntimeBuilder { + + public abstract Builder setPlanner(ProgramPlanner planner); + + @Override + public abstract Builder setOptions(CelOptions options); + + @Override + public abstract Builder setStandardFunctions(CelStandardFunctions standardFunctions); + + @Override + public abstract Builder setExtensionRegistry(ExtensionRegistry extensionRegistry); + + @Override + public abstract Builder setTypeProvider(CelTypeProvider celTypeProvider); + + @Override + public abstract Builder setValueProvider(CelValueProvider celValueProvider); + + @Override + public abstract Builder setContainer(CelContainer container); + + abstract CelOptions options(); + + abstract CelContainer container(); + + abstract CelTypeProvider typeProvider(); + + abstract CelValueProvider valueProvider(); + + abstract CelStandardFunctions standardFunctions(); + + abstract ExtensionRegistry extensionRegistry(); + + abstract ImmutableMap functionBindings(); + + abstract ImmutableSet.Builder fileDescriptorsBuilder(); + + abstract ImmutableSet.Builder runtimeLibrariesBuilder(); + + abstract ImmutableSet.Builder lateBoundFunctionNamesBuilder(); + + private final Map mutableFunctionBindings = new HashMap<>(); + + @Override + @CanIgnoreReturnValue + public Builder addFunctionBindings(CelFunctionBinding... bindings) { + checkNotNull(bindings); + return addFunctionBindings(Arrays.asList(bindings)); + } + + @Override + @CanIgnoreReturnValue + public Builder addFunctionBindings(Iterable bindings) { + checkNotNull(bindings); + bindings.forEach(o -> mutableFunctionBindings.putIfAbsent(o.getOverloadId(), o)); + return this; + } + + @Override + @CanIgnoreReturnValue + public Builder addLateBoundFunctions(String... lateBoundFunctionNames) { + checkNotNull(lateBoundFunctionNames); + return addLateBoundFunctions(Arrays.asList(lateBoundFunctionNames)); + } + + @Override + @CanIgnoreReturnValue + public Builder addLateBoundFunctions(Iterable lateBoundFunctionNames) { + checkNotNull(lateBoundFunctionNames); + this.lateBoundFunctionNamesBuilder().addAll(lateBoundFunctionNames); + return this; + } + + @Override + @CanIgnoreReturnValue + public Builder addMessageTypes(Descriptors.Descriptor... descriptors) { + checkNotNull(descriptors); + return addMessageTypes(Arrays.asList(descriptors)); + } + + @Override + @CanIgnoreReturnValue + public Builder addMessageTypes(Iterable descriptors) { + checkNotNull(descriptors); + return addFileTypes(CelDescriptorUtil.getFileDescriptorsForDescriptors(descriptors)); + } + + @Override + @CanIgnoreReturnValue + public Builder addFileTypes(DescriptorProtos.FileDescriptorSet fileDescriptorSet) { + checkNotNull(fileDescriptorSet); + return addFileTypes( + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fileDescriptorSet)); + } + + @Override + @CanIgnoreReturnValue + public Builder addFileTypes(Descriptors.FileDescriptor... fileDescriptors) { + checkNotNull(fileDescriptors); + return addFileTypes(Arrays.asList(fileDescriptors)); + } + + @Override + @CanIgnoreReturnValue + public Builder addFileTypes(Iterable fileDescriptors) { + checkNotNull(fileDescriptors); + this.fileDescriptorsBuilder().addAll(fileDescriptors); + return this; + } + + @Override + @CanIgnoreReturnValue + public Builder addLibraries(CelRuntimeLibrary... libraries) { + checkNotNull(libraries); + return this.addLibraries(Arrays.asList(libraries)); + } + + @Override + @CanIgnoreReturnValue + public Builder addLibraries(Iterable libraries) { + checkNotNull(libraries); + this.runtimeLibrariesBuilder().addAll(libraries); + return this; + } + + abstract Builder setFunctionBindings(ImmutableMap value); + + @Override + public Builder setTypeFactory(Function typeFactory) { + throw new UnsupportedOperationException("Unsupported. Use a custom value provider instead."); + } + + @Override + public Builder setStandardEnvironmentEnabled(boolean value) { + throw new UnsupportedOperationException( + "Unsupported. Subset the environment using setStandardFunctions instead."); + } + + /** Throws if an unsupported flag in CelOptions is toggled. */ + private static void assertAllowedCelOptions(CelOptions celOptions) { + String prefix = "Misconfigured CelOptions: "; + if (!celOptions.enableUnsignedLongs()) { + throw new IllegalArgumentException(prefix + "enableUnsignedLongs cannot be disabled."); + } + if (!celOptions.unwrapWellKnownTypesOnFunctionDispatch()) { + throw new IllegalArgumentException( + prefix + "unwrapWellKnownTypesOnFunctionDispatch cannot be disabled."); + } + + // Disallowed options in favor of subsetting + String subsettingError = "Subset the environment instead using setStandardFunctions method."; + + if (!celOptions.enableTimestampEpoch()) { + throw new IllegalArgumentException( + prefix + "enableTimestampEpoch cannot be disabled. " + subsettingError); + } + + if (!celOptions.enableHeterogeneousNumericComparisons()) { + throw new IllegalArgumentException( + prefix + + "enableHeterogeneousNumericComparisons cannot be disabled. " + + subsettingError); + } + } + + abstract CelRuntimeImpl autoBuild(); + + private static DefaultDispatcher newDispatcher( + CelStandardFunctions standardFunctions, + Collection customFunctionBindings, + RuntimeEquality runtimeEquality, + CelOptions options) { + 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(), + binding.getDefinition()); + } + + return builder.build(); + } + + private static CelDescriptorPool newDescriptorPool( + CelDescriptors celDescriptors, + ExtensionRegistry extensionRegistry) { + ImmutableList.Builder descriptorPools = new ImmutableList.Builder<>(); + + descriptorPools.add(DefaultDescriptorPool.create(celDescriptors, extensionRegistry)); + + return CombinedDescriptorPool.create(descriptorPools.build()); + } + + @Override + public CelRuntime build() { + CelOptions options = options(); + assertAllowedCelOptions(options); + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(fileDescriptorsBuilder().build()); + + CelDescriptorPool descriptorPool = + newDescriptorPool( + celDescriptors, + extensionRegistry()); + DefaultMessageFactory defaultMessageFactory = DefaultMessageFactory.create(descriptorPool); + DynamicProto dynamicProto = DynamicProto.create(defaultMessageFactory); + CelValueProvider protoMessageValueProvider = + ProtoMessageValueProvider.newInstance(options(), dynamicProto); + RuntimeEquality runtimeEquality = ProtoMessageRuntimeEquality.create(dynamicProto, options()); + ImmutableSet runtimeLibraries = runtimeLibrariesBuilder().build(); + // Add libraries, such as extensions + for (CelRuntimeLibrary celLibrary : runtimeLibraries) { + if (celLibrary instanceof CelInternalRuntimeLibrary) { + ((CelInternalRuntimeLibrary) celLibrary) + .setRuntimeOptions(this, runtimeEquality, options()); + } else { + celLibrary.setRuntimeOptions(this); + } + } + + if (valueProvider() != null) { + protoMessageValueProvider = + CombinedCelValueProvider.combine(protoMessageValueProvider, valueProvider()); + } + CelValueConverter celValueConverter = protoMessageValueProvider.celValueConverter(); + + CelTypeProvider messageTypeProvider = + ProtoMessageTypeProvider.newBuilder() + .setCelDescriptors(celDescriptors) + .setAllowJsonFieldNames(options().enableJsonFieldNames()) + .setResolveTypeDependencies(options().resolveTypeDependencies()) + .build(); + + CelTypeProvider combinedTypeProvider = + new CelTypeProvider.CombinedCelTypeProvider( + DefaultTypeProvider.getInstance(), messageTypeProvider); + if (typeProvider() != null) { + combinedTypeProvider = + new CelTypeProvider.CombinedCelTypeProvider(combinedTypeProvider, typeProvider()); + } + + DescriptorTypeResolver descriptorTypeResolver = + DescriptorTypeResolver.create(combinedTypeProvider, celValueConverter); + TypeFunction typeFunction = TypeFunction.create(descriptorTypeResolver); + + mutableFunctionBindings.putAll(functionBindings()); + + for (CelFunctionBinding binding : + typeFunction.newFunctionBindings(options(), runtimeEquality)) { + mutableFunctionBindings.put(binding.getOverloadId(), binding); + } + + DefaultDispatcher dispatcher = + newDispatcher( + standardFunctions(), mutableFunctionBindings.values(), runtimeEquality, options()); + + ProgramPlanner planner = + ProgramPlanner.newPlanner( + combinedTypeProvider, + protoMessageValueProvider, + dispatcher, + celValueConverter, + container(), + options(), + lateBoundFunctionNamesBuilder().build()); + setPlanner(planner); + + setFunctionBindings(ImmutableMap.copyOf(mutableFunctionBindings)); + return autoBuild(); + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelRuntimeLegacyImpl.java b/runtime/src/main/java/dev/cel/runtime/CelRuntimeLegacyImpl.java new file mode 100644 index 000000000..b9ce022cf --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelRuntimeLegacyImpl.java @@ -0,0 +1,470 @@ +// Copyright 2022 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 static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import javax.annotation.concurrent.ThreadSafe; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.Message; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.CelDescriptorPool; +import dev.cel.common.internal.CombinedDescriptorPool; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +// CEL-Internal-1 +import dev.cel.common.internal.ProtoMessageFactory; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.CelTypes; +import dev.cel.common.values.CelValueConverter; +import dev.cel.common.values.CelValueProvider; +import dev.cel.common.values.ProtoMessageValueProvider; +import dev.cel.runtime.standard.IntFunction.IntOverload; +import dev.cel.runtime.standard.TimestampFunction.TimestampOverload; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Optional; +import java.util.function.Function; +import org.jspecify.annotations.Nullable; + +/** + * {@code CelRuntime} implementation based on the legacy CEL-Java stack. + * + *

CEL Library Internals. Do Not Use. Consumers should use factories, such as {@link + * CelRuntimeFactory} instead to instantiate a runtime. + */ +@ThreadSafe +@Internal +public final class CelRuntimeLegacyImpl implements CelRuntime { + + private final Interpreter interpreter; + private final CelOptions options; + + private final boolean standardEnvironmentEnabled; + + // Extension registry is thread-safe. Just not marked as such from Protobuf's implementation. + // CEL-Internal-4 + private final ExtensionRegistry extensionRegistry; + + // A user-provided custom type factory should presumably be thread-safe. This is documented, but + // not enforced. + // CEL-Internal-4 + private final Function customTypeFactory; + + private final CelStandardFunctions overriddenStandardFunctions; + private final CelValueProvider celValueProvider; + private final ImmutableSet fileDescriptors; + + // This does not affect the evaluation behavior in any manner. + // CEL-Internal-4 + private final ImmutableSet celRuntimeLibraries; + + private final ImmutableList celFunctionBindings; + + @Override + public CelRuntime.Program createProgram(CelAbstractSyntaxTree ast) { + checkState(ast.isChecked(), "programs must be created from checked expressions"); + return ProgramImpl.from(interpreter.createInterpretable(ast), options); + } + + @Override + public CelRuntimeBuilder toRuntimeBuilder() { + CelRuntimeBuilder builder = + new Builder() + .setOptions(options) + // CEL-Internal-2 + .setStandardEnvironmentEnabled(standardEnvironmentEnabled) + .setExtensionRegistry(extensionRegistry) + .addFileTypes(fileDescriptors) + .addLibraries(celRuntimeLibraries) + .addFunctionBindings(celFunctionBindings); + + if (customTypeFactory != null) { + builder.setTypeFactory(customTypeFactory); + } + + if (overriddenStandardFunctions != null) { + builder.setStandardFunctions(overriddenStandardFunctions); + } + + if (celValueProvider != null) { + builder.setValueProvider(celValueProvider); + } + + return builder; + } + + /** Create a new builder for constructing a {@code CelRuntime} instance. */ + public static CelRuntimeBuilder newBuilder() { + return new Builder(); + } + + /** Builder class for {@code CelRuntimeLegacyImpl}. */ + public static final class Builder implements CelRuntimeBuilder { + + // The following properties are for testing purposes only. Do not expose to public. + @VisibleForTesting final ImmutableSet.Builder fileTypes; + + @VisibleForTesting final HashMap customFunctionBindings; + + @VisibleForTesting final ImmutableSet.Builder celRuntimeLibraries; + + @VisibleForTesting Function customTypeFactory; + @VisibleForTesting CelValueProvider celValueProvider; + @VisibleForTesting CelStandardFunctions overriddenStandardFunctions; + + private CelOptions options; + + private ExtensionRegistry extensionRegistry; + + private boolean standardEnvironmentEnabled; + + @Override + public CelRuntimeBuilder setOptions(CelOptions options) { + this.options = options; + return this; + } + + @Override + public CelRuntimeBuilder addFunctionBindings(CelFunctionBinding... bindings) { + return addFunctionBindings(Arrays.asList(bindings)); + } + + @Override + public CelRuntimeBuilder addFunctionBindings(Iterable bindings) { + bindings.forEach(o -> customFunctionBindings.putIfAbsent(o.getOverloadId(), o)); + return this; + } + + @Override + public CelRuntimeBuilder addLateBoundFunctions(String... lateBoundFunctionNames) { + throw new UnsupportedOperationException( + "This method is not supported for the legacy runtime"); + } + + @Override + public CelRuntimeBuilder addLateBoundFunctions(Iterable lateBoundFunctionNames) { + throw new UnsupportedOperationException( + "This method is not supported for the legacy runtime"); + } + + @Override + public CelRuntimeBuilder addMessageTypes(Descriptor... descriptors) { + return addMessageTypes(Arrays.asList(descriptors)); + } + + @Override + public CelRuntimeBuilder addMessageTypes(Iterable descriptors) { + return addFileTypes(CelDescriptorUtil.getFileDescriptorsForDescriptors(descriptors)); + } + + @Override + public CelRuntimeBuilder addFileTypes(FileDescriptor... fileDescriptors) { + return addFileTypes(Arrays.asList(fileDescriptors)); + } + + @Override + public CelRuntimeBuilder addFileTypes(Iterable fileDescriptors) { + this.fileTypes.addAll(checkNotNull(fileDescriptors)); + return this; + } + + @Override + public CelRuntimeBuilder addFileTypes(FileDescriptorSet fileDescriptorSet) { + return addFileTypes( + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fileDescriptorSet)); + } + + @Override + public CelRuntimeBuilder setTypeProvider(CelTypeProvider celTypeProvider) { + throw new UnsupportedOperationException( + "setTypeProvider is not supported for legacy runtime"); + } + + @Override + public CelRuntimeBuilder setValueProvider(CelValueProvider celValueProvider) { + this.celValueProvider = celValueProvider; + return this; + } + + @Override + public CelRuntimeBuilder setTypeFactory(Function typeFactory) { + this.customTypeFactory = typeFactory; + return this; + } + + @Override + public CelRuntimeBuilder setStandardEnvironmentEnabled(boolean value) { + standardEnvironmentEnabled = value; + return this; + } + + @Override + public CelRuntimeBuilder setStandardFunctions(CelStandardFunctions standardFunctions) { + this.overriddenStandardFunctions = standardFunctions; + return this; + } + + @Override + public CelRuntimeBuilder addLibraries(CelRuntimeLibrary... libraries) { + checkNotNull(libraries); + return this.addLibraries(Arrays.asList(libraries)); + } + + @Override + public CelRuntimeBuilder addLibraries(Iterable libraries) { + checkNotNull(libraries); + this.celRuntimeLibraries.addAll(libraries); + return this; + } + + @Override + public CelRuntimeBuilder setExtensionRegistry(ExtensionRegistry extensionRegistry) { + checkNotNull(extensionRegistry); + this.extensionRegistry = extensionRegistry.getUnmodifiable(); + return this; + } + + @Override + public CelRuntimeBuilder setContainer(CelContainer container) { + throw new UnsupportedOperationException( + "This method is not supported for the legacy runtime"); + } + + /** Build a new {@code CelRuntimeLegacyImpl} instance from the builder config. */ + @Override + public CelRuntimeLegacyImpl build() { + if (standardEnvironmentEnabled && overriddenStandardFunctions != null) { + throw new IllegalArgumentException( + "setStandardEnvironmentEnabled must be set to false to override standard function" + + " bindings."); + } + + ImmutableSet fileDescriptors = fileTypes.build(); + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + fileDescriptors, options.resolveTypeDependencies()); + + CelDescriptorPool celDescriptorPool = + newDescriptorPool( + celDescriptors, + extensionRegistry); + + @SuppressWarnings("Immutable") + ProtoMessageFactory runtimeTypeFactory = + customTypeFactory != null + ? messageName -> + CelTypes.isWellKnownType( + messageName) // Let DefaultMessageFactory handle WKT constructions + ? Optional.empty() + : Optional.ofNullable(customTypeFactory.apply(messageName)) + : null; + runtimeTypeFactory = + maybeCombineMessageFactory( + runtimeTypeFactory, DefaultMessageFactory.create(celDescriptorPool)); + + DynamicProto dynamicProto = DynamicProto.create(runtimeTypeFactory); + RuntimeEquality runtimeEquality = ProtoMessageRuntimeEquality.create(dynamicProto, options); + + ImmutableSet runtimeLibraries = celRuntimeLibraries.build(); + // Add libraries, such as extensions + for (CelRuntimeLibrary celLibrary : runtimeLibraries) { + if (celLibrary instanceof CelInternalRuntimeLibrary) { + ((CelInternalRuntimeLibrary) celLibrary) + .setRuntimeOptions(this, runtimeEquality, options); + } else { + celLibrary.setRuntimeOptions(this); + } + } + + 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(), + customBinding.getDefinition()); + } + + CelValueConverter celValueConverter = CelValueConverter.getDefaultInstance(); + RuntimeTypeProvider runtimeTypeProvider; + + if (options.enableCelValue()) { + CelValueProvider messageValueProvider = celValueProvider; + + if (messageValueProvider == null) { + messageValueProvider = ProtoMessageValueProvider.newInstance(options, dynamicProto); + } + + runtimeTypeProvider = CelValueRuntimeTypeProvider.newInstance(messageValueProvider); + celValueConverter = messageValueProvider.celValueConverter(); + } else { + runtimeTypeProvider = new DescriptorMessageProvider(runtimeTypeFactory, options); + if (celValueProvider != null) { + celValueConverter = celValueProvider.celValueConverter(); + } + } + + DefaultInterpreter interpreter = + new DefaultInterpreter( + DescriptorTypeResolver.create(celValueConverter), + runtimeTypeProvider, + dispatcherBuilder.build(), + options); + + return new CelRuntimeLegacyImpl( + interpreter, + options, + standardEnvironmentEnabled, + extensionRegistry, + customTypeFactory, + overriddenStandardFunctions, + celValueProvider, + fileDescriptors, + runtimeLibraries, + ImmutableList.copyOf(customFunctionBindings.values())); + } + + private ImmutableSet newStandardFunctionBindings( + RuntimeEquality runtimeEquality) { + CelStandardFunctions celStandardFunctions; + if (standardEnvironmentEnabled) { + celStandardFunctions = + CelStandardFunctions.newBuilder() + .filterFunctions( + (standardFunction, standardOverload) -> { + switch (standardFunction) { + case INT: + if (standardOverload.equals(IntOverload.INT64_TO_INT64)) { + // Note that we require UnsignedLong flag here to avoid ambiguous + // overloads against "uint64_to_int64", because they both use the same + // Java Long class. We skip adding this identity function if the flag is + // disabled. + return options.enableUnsignedLongs(); + } + break; + case TIMESTAMP: + // TODO: Remove this flag guard once the feature has been + // auto-enabled. + if (standardOverload.equals(TimestampOverload.INT64_TO_TIMESTAMP)) { + return options.enableTimestampEpoch(); + } + break; + default: + if (!options.enableHeterogeneousNumericComparisons()) { + return !CelStandardFunctions.isHeterogeneousComparison( + standardOverload); + } + break; + } + + return true; + }) + .build(); + } else if (overriddenStandardFunctions != null) { + celStandardFunctions = overriddenStandardFunctions; + } else { + return ImmutableSet.of(); + } + + return celStandardFunctions.newFunctionBindings(runtimeEquality, options); + } + + private static CelDescriptorPool newDescriptorPool( + CelDescriptors celDescriptors, + ExtensionRegistry extensionRegistry) { + ImmutableList.Builder descriptorPools = new ImmutableList.Builder<>(); + + descriptorPools.add(DefaultDescriptorPool.create(celDescriptors, extensionRegistry)); + + return CombinedDescriptorPool.create(descriptorPools.build()); + } + + @CanIgnoreReturnValue + private static ProtoMessageFactory maybeCombineMessageFactory( + @Nullable ProtoMessageFactory parentFactory, ProtoMessageFactory childFactory) { + if (parentFactory == null) { + return childFactory; + } + return new ProtoMessageFactory.CombinedMessageFactory( + ImmutableList.of(parentFactory, childFactory)); + } + + private Builder() { + this.options = CelOptions.newBuilder().build(); + this.fileTypes = ImmutableSet.builder(); + this.customFunctionBindings = new HashMap<>(); + this.celRuntimeLibraries = ImmutableSet.builder(); + this.extensionRegistry = ExtensionRegistry.getEmptyRegistry(); + this.customTypeFactory = null; + } + } + + private CelRuntimeLegacyImpl( + Interpreter interpreter, + CelOptions options, + boolean standardEnvironmentEnabled, + ExtensionRegistry extensionRegistry, + @Nullable Function customTypeFactory, + @Nullable CelStandardFunctions overriddenStandardFunctions, + @Nullable CelValueProvider celValueProvider, + ImmutableSet fileDescriptors, + ImmutableSet celRuntimeLibraries, + ImmutableList celFunctionBindings) { + this.interpreter = interpreter; + this.options = options; + this.standardEnvironmentEnabled = standardEnvironmentEnabled; + this.extensionRegistry = extensionRegistry; + this.customTypeFactory = customTypeFactory; + this.overriddenStandardFunctions = overriddenStandardFunctions; + this.celValueProvider = celValueProvider; + this.fileDescriptors = fileDescriptors; + this.celRuntimeLibraries = celRuntimeLibraries; + this.celFunctionBindings = celFunctionBindings; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelRuntimeLibrary.java b/runtime/src/main/java/dev/cel/runtime/CelRuntimeLibrary.java new file mode 100644 index 000000000..803e40925 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelRuntimeLibrary.java @@ -0,0 +1,27 @@ +// Copyright 2022 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; + +/** + * CelRuntimeLibrary defines the interface to extend functionalities beyond the CEL standard + * functions for {@link CelRuntime}. + */ +public interface CelRuntimeLibrary { + + /** + * Configures the runtime to support the library implementation, such as adding function bindings. + */ + void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder); +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelStandardFunctions.java b/runtime/src/main/java/dev/cel/runtime/CelStandardFunctions.java new file mode 100644 index 000000000..39797e086 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelStandardFunctions.java @@ -0,0 +1,565 @@ +// Copyright 2024 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 static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableMultimap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelOptions; +import dev.cel.common.Operator; +import dev.cel.common.annotations.Internal; +import dev.cel.runtime.standard.AddOperator; +import dev.cel.runtime.standard.AddOperator.AddOverload; +import dev.cel.runtime.standard.BoolFunction; +import dev.cel.runtime.standard.BoolFunction.BoolOverload; +import dev.cel.runtime.standard.BytesFunction; +import dev.cel.runtime.standard.BytesFunction.BytesOverload; +import dev.cel.runtime.standard.CelStandardFunction; +import dev.cel.runtime.standard.CelStandardOverload; +import dev.cel.runtime.standard.ContainsFunction; +import dev.cel.runtime.standard.ContainsFunction.ContainsOverload; +import dev.cel.runtime.standard.DivideOperator; +import dev.cel.runtime.standard.DivideOperator.DivideOverload; +import dev.cel.runtime.standard.DoubleFunction; +import dev.cel.runtime.standard.DoubleFunction.DoubleOverload; +import dev.cel.runtime.standard.DurationFunction; +import dev.cel.runtime.standard.DurationFunction.DurationOverload; +import dev.cel.runtime.standard.DynFunction; +import dev.cel.runtime.standard.DynFunction.DynOverload; +import dev.cel.runtime.standard.EndsWithFunction; +import dev.cel.runtime.standard.EndsWithFunction.EndsWithOverload; +import dev.cel.runtime.standard.EqualsOperator; +import dev.cel.runtime.standard.EqualsOperator.EqualsOverload; +import dev.cel.runtime.standard.GetDateFunction; +import dev.cel.runtime.standard.GetDateFunction.GetDateOverload; +import dev.cel.runtime.standard.GetDayOfMonthFunction; +import dev.cel.runtime.standard.GetDayOfMonthFunction.GetDayOfMonthOverload; +import dev.cel.runtime.standard.GetDayOfWeekFunction; +import dev.cel.runtime.standard.GetDayOfWeekFunction.GetDayOfWeekOverload; +import dev.cel.runtime.standard.GetDayOfYearFunction; +import dev.cel.runtime.standard.GetDayOfYearFunction.GetDayOfYearOverload; +import dev.cel.runtime.standard.GetFullYearFunction; +import dev.cel.runtime.standard.GetFullYearFunction.GetFullYearOverload; +import dev.cel.runtime.standard.GetHoursFunction; +import dev.cel.runtime.standard.GetHoursFunction.GetHoursOverload; +import dev.cel.runtime.standard.GetMillisecondsFunction; +import dev.cel.runtime.standard.GetMillisecondsFunction.GetMillisecondsOverload; +import dev.cel.runtime.standard.GetMinutesFunction; +import dev.cel.runtime.standard.GetMinutesFunction.GetMinutesOverload; +import dev.cel.runtime.standard.GetMonthFunction; +import dev.cel.runtime.standard.GetMonthFunction.GetMonthOverload; +import dev.cel.runtime.standard.GetSecondsFunction; +import dev.cel.runtime.standard.GetSecondsFunction.GetSecondsOverload; +import dev.cel.runtime.standard.GreaterEqualsOperator; +import dev.cel.runtime.standard.GreaterEqualsOperator.GreaterEqualsOverload; +import dev.cel.runtime.standard.GreaterOperator; +import dev.cel.runtime.standard.GreaterOperator.GreaterOverload; +import dev.cel.runtime.standard.InOperator; +import dev.cel.runtime.standard.InOperator.InOverload; +import dev.cel.runtime.standard.IndexOperator; +import dev.cel.runtime.standard.IndexOperator.IndexOverload; +import dev.cel.runtime.standard.IntFunction; +import dev.cel.runtime.standard.IntFunction.IntOverload; +import dev.cel.runtime.standard.LessEqualsOperator; +import dev.cel.runtime.standard.LessEqualsOperator.LessEqualsOverload; +import dev.cel.runtime.standard.LessOperator; +import dev.cel.runtime.standard.LessOperator.LessOverload; +import dev.cel.runtime.standard.LogicalNotOperator; +import dev.cel.runtime.standard.LogicalNotOperator.LogicalNotOverload; +import dev.cel.runtime.standard.MatchesFunction; +import dev.cel.runtime.standard.MatchesFunction.MatchesOverload; +import dev.cel.runtime.standard.ModuloOperator; +import dev.cel.runtime.standard.ModuloOperator.ModuloOverload; +import dev.cel.runtime.standard.MultiplyOperator; +import dev.cel.runtime.standard.MultiplyOperator.MultiplyOverload; +import dev.cel.runtime.standard.NegateOperator; +import dev.cel.runtime.standard.NegateOperator.NegateOverload; +import dev.cel.runtime.standard.NotEqualsOperator; +import dev.cel.runtime.standard.NotEqualsOperator.NotEqualsOverload; +import dev.cel.runtime.standard.NotStrictlyFalseFunction; +import dev.cel.runtime.standard.NotStrictlyFalseFunction.NotStrictlyFalseOverload; +import dev.cel.runtime.standard.SizeFunction; +import dev.cel.runtime.standard.SizeFunction.SizeOverload; +import dev.cel.runtime.standard.StartsWithFunction; +import dev.cel.runtime.standard.StartsWithFunction.StartsWithOverload; +import dev.cel.runtime.standard.StringFunction; +import dev.cel.runtime.standard.StringFunction.StringOverload; +import dev.cel.runtime.standard.SubtractOperator; +import dev.cel.runtime.standard.SubtractOperator.SubtractOverload; +import dev.cel.runtime.standard.TimestampFunction; +import dev.cel.runtime.standard.TimestampFunction.TimestampOverload; +import dev.cel.runtime.standard.UintFunction; +import dev.cel.runtime.standard.UintFunction.UintOverload; +import java.util.Collection; +import java.util.Map; + +/** Runtime function bindings for the standard functions in CEL. */ +@Immutable +public final class CelStandardFunctions { + private static final ImmutableSet HETEROGENEOUS_COMPARISON_OPERATORS = + ImmutableSet.of( + LessOverload.LESS_DOUBLE_UINT64, + LessOverload.LESS_INT64_UINT64, + LessOverload.LESS_UINT64_INT64, + LessOverload.LESS_INT64_DOUBLE, + LessOverload.LESS_DOUBLE_INT64, + LessOverload.LESS_UINT64_DOUBLE, + LessEqualsOverload.LESS_EQUALS_INT64_UINT64, + LessEqualsOverload.LESS_EQUALS_UINT64_INT64, + LessEqualsOverload.LESS_EQUALS_INT64_DOUBLE, + LessEqualsOverload.LESS_EQUALS_DOUBLE_INT64, + LessEqualsOverload.LESS_EQUALS_UINT64_DOUBLE, + LessEqualsOverload.LESS_EQUALS_DOUBLE_UINT64, + GreaterOverload.GREATER_INT64_UINT64, + GreaterOverload.GREATER_UINT64_INT64, + GreaterOverload.GREATER_INT64_DOUBLE, + GreaterOverload.GREATER_DOUBLE_INT64, + GreaterOverload.GREATER_UINT64_DOUBLE, + GreaterOverload.GREATER_DOUBLE_UINT64, + GreaterEqualsOverload.GREATER_EQUALS_INT64_UINT64, + GreaterEqualsOverload.GREATER_EQUALS_UINT64_INT64, + GreaterEqualsOverload.GREATER_EQUALS_INT64_DOUBLE, + GreaterEqualsOverload.GREATER_EQUALS_DOUBLE_INT64, + GreaterEqualsOverload.GREATER_EQUALS_UINT64_DOUBLE, + GreaterEqualsOverload.GREATER_EQUALS_DOUBLE_UINT64); + + private final ImmutableMultimap standardOverloads; + + public static final ImmutableSet ALL_STANDARD_FUNCTIONS = + ImmutableSet.of( + AddOperator.create(), + BoolFunction.create(), + BytesFunction.create(), + ContainsFunction.create(), + DivideOperator.create(), + DoubleFunction.create(), + DurationFunction.create(), + DynFunction.create(), + EndsWithFunction.create(), + EqualsOperator.create(), + GetDateFunction.create(), + GetDayOfMonthFunction.create(), + GetDayOfWeekFunction.create(), + GetDayOfYearFunction.create(), + GetFullYearFunction.create(), + GetHoursFunction.create(), + GetMillisecondsFunction.create(), + GetMinutesFunction.create(), + GetMonthFunction.create(), + GetSecondsFunction.create(), + GreaterEqualsOperator.create(), + GreaterOperator.create(), + IndexOperator.create(), + InOperator.create(), + IntFunction.create(), + LessEqualsOperator.create(), + LessOperator.create(), + LogicalNotOperator.create(), + MatchesFunction.create(), + ModuloOperator.create(), + MultiplyOperator.create(), + NegateOperator.create(), + NotEqualsOperator.create(), + SizeFunction.create(), + StartsWithFunction.create(), + StringFunction.create(), + SubtractOperator.create(), + TimestampFunction.create(), + UintFunction.create(), + NotStrictlyFalseFunction.create()); + + /** + * Enumeration of Standard Function bindings. + * + *

Note: The conditional, logical_or, logical_and, and type functions are currently + * special-cased, and does not appear in this enum. + */ + public enum StandardFunction { + LOGICAL_NOT(Operator.LOGICAL_NOT.getFunction(), LogicalNotOverload.LOGICAL_NOT), + IN(Operator.IN.getFunction(), InOverload.IN_LIST, InOverload.IN_MAP), + NOT_STRICTLY_FALSE( + Operator.NOT_STRICTLY_FALSE.getFunction(), NotStrictlyFalseOverload.NOT_STRICTLY_FALSE), + EQUALS(Operator.EQUALS.getFunction(), EqualsOverload.EQUALS), + NOT_EQUALS(Operator.NOT_EQUALS.getFunction(), NotEqualsOverload.NOT_EQUALS), + BOOL("bool", BoolOverload.BOOL_TO_BOOL, BoolOverload.STRING_TO_BOOL), + ADD( + Operator.ADD.getFunction(), + AddOverload.ADD_INT64, + AddOverload.ADD_UINT64, + AddOverload.ADD_DOUBLE, + AddOverload.ADD_STRING, + AddOverload.ADD_BYTES, + AddOverload.ADD_LIST, + AddOverload.ADD_TIMESTAMP_DURATION, + AddOverload.ADD_DURATION_TIMESTAMP, + AddOverload.ADD_DURATION_DURATION), + SUBTRACT( + Operator.SUBTRACT.getFunction(), + SubtractOverload.SUBTRACT_INT64, + SubtractOverload.SUBTRACT_TIMESTAMP_TIMESTAMP, + SubtractOverload.SUBTRACT_TIMESTAMP_DURATION, + SubtractOverload.SUBTRACT_UINT64, + SubtractOverload.SUBTRACT_DOUBLE, + SubtractOverload.SUBTRACT_DURATION_DURATION), + MULTIPLY( + Operator.MULTIPLY.getFunction(), + MultiplyOverload.MULTIPLY_INT64, + MultiplyOverload.MULTIPLY_DOUBLE, + MultiplyOverload.MULTIPLY_UINT64), + DIVIDE( + Operator.DIVIDE.getFunction(), + DivideOverload.DIVIDE_DOUBLE, + DivideOverload.DIVIDE_INT64, + DivideOverload.DIVIDE_UINT64), + MODULO( + Operator.MODULO.getFunction(), ModuloOverload.MODULO_INT64, ModuloOverload.MODULO_UINT64), + NEGATE( + Operator.NEGATE.getFunction(), NegateOverload.NEGATE_INT64, NegateOverload.NEGATE_DOUBLE), + INDEX(Operator.INDEX.getFunction(), IndexOverload.INDEX_LIST, IndexOverload.INDEX_MAP), + SIZE( + "size", + SizeOverload.SIZE_STRING, + SizeOverload.SIZE_BYTES, + SizeOverload.SIZE_LIST, + SizeOverload.SIZE_MAP, + SizeOverload.STRING_SIZE, + SizeOverload.BYTES_SIZE, + SizeOverload.LIST_SIZE, + SizeOverload.MAP_SIZE), + INT( + "int", + IntOverload.INT64_TO_INT64, + IntOverload.UINT64_TO_INT64, + IntOverload.DOUBLE_TO_INT64, + IntOverload.STRING_TO_INT64, + IntOverload.TIMESTAMP_TO_INT64), + UINT( + "uint", + UintOverload.UINT64_TO_UINT64, + UintOverload.INT64_TO_UINT64, + UintOverload.DOUBLE_TO_UINT64, + UintOverload.STRING_TO_UINT64), + DOUBLE( + "double", + DoubleOverload.DOUBLE_TO_DOUBLE, + DoubleOverload.INT64_TO_DOUBLE, + DoubleOverload.STRING_TO_DOUBLE, + DoubleOverload.UINT64_TO_DOUBLE), + STRING( + "string", + StringOverload.STRING_TO_STRING, + StringOverload.INT64_TO_STRING, + StringOverload.DOUBLE_TO_STRING, + StringOverload.BOOL_TO_STRING, + StringOverload.BYTES_TO_STRING, + StringOverload.TIMESTAMP_TO_STRING, + StringOverload.DURATION_TO_STRING, + StringOverload.UINT64_TO_STRING), + BYTES("bytes", BytesOverload.BYTES_TO_BYTES, BytesOverload.STRING_TO_BYTES), + DURATION( + "duration", DurationOverload.DURATION_TO_DURATION, DurationOverload.STRING_TO_DURATION), + TIMESTAMP( + "timestamp", + TimestampOverload.STRING_TO_TIMESTAMP, + TimestampOverload.TIMESTAMP_TO_TIMESTAMP, + TimestampOverload.INT64_TO_TIMESTAMP), + DYN("dyn", DynOverload.TO_DYN), + MATCHES("matches", MatchesOverload.MATCHES, MatchesOverload.MATCHES_STRING), + CONTAINS("contains", ContainsOverload.CONTAINS_STRING), + ENDS_WITH("endsWith", EndsWithOverload.ENDS_WITH_STRING), + STARTS_WITH("startsWith", StartsWithOverload.STARTS_WITH_STRING), + // Date/time Functions + GET_FULL_YEAR( + "getFullYear", + GetFullYearOverload.TIMESTAMP_TO_YEAR, + GetFullYearOverload.TIMESTAMP_TO_YEAR_WITH_TZ), + GET_MONTH( + "getMonth", + GetMonthOverload.TIMESTAMP_TO_MONTH, + GetMonthOverload.TIMESTAMP_TO_MONTH_WITH_TZ), + GET_DAY_OF_YEAR( + "getDayOfYear", + GetDayOfYearOverload.TIMESTAMP_TO_DAY_OF_YEAR, + GetDayOfYearOverload.TIMESTAMP_TO_DAY_OF_YEAR_WITH_TZ), + GET_DAY_OF_MONTH( + "getDayOfMonth", + GetDayOfMonthOverload.TIMESTAMP_TO_DAY_OF_MONTH, + GetDayOfMonthOverload.TIMESTAMP_TO_DAY_OF_MONTH_WITH_TZ), + GET_DATE( + "getDate", + GetDateOverload.TIMESTAMP_TO_DAY_OF_MONTH_1_BASED, + GetDateOverload.TIMESTAMP_TO_DAY_OF_MONTH_1_BASED_WITH_TZ), + GET_DAY_OF_WEEK( + "getDayOfWeek", + GetDayOfWeekOverload.TIMESTAMP_TO_DAY_OF_WEEK, + GetDayOfWeekOverload.TIMESTAMP_TO_DAY_OF_WEEK_WITH_TZ), + + GET_HOURS( + "getHours", + GetHoursOverload.TIMESTAMP_TO_HOURS, + GetHoursOverload.TIMESTAMP_TO_HOURS_WITH_TZ, + GetHoursOverload.DURATION_TO_HOURS), + GET_MINUTES( + "getMinutes", + GetMinutesOverload.TIMESTAMP_TO_MINUTES, + GetMinutesOverload.TIMESTAMP_TO_MINUTES_WITH_TZ, + GetMinutesOverload.DURATION_TO_MINUTES), + GET_SECONDS( + "getSeconds", + GetSecondsOverload.TIMESTAMP_TO_SECONDS, + GetSecondsOverload.TIMESTAMP_TO_SECONDS_WITH_TZ, + GetSecondsOverload.DURATION_TO_SECONDS), + GET_MILLISECONDS( + "getMilliseconds", + GetMillisecondsOverload.TIMESTAMP_TO_MILLISECONDS, + GetMillisecondsOverload.TIMESTAMP_TO_MILLISECONDS_WITH_TZ, + GetMillisecondsOverload.DURATION_TO_MILLISECONDS), + LESS( + Operator.LESS.getFunction(), + LessOverload.LESS_BOOL, + LessOverload.LESS_INT64, + LessOverload.LESS_UINT64, + LessOverload.LESS_DOUBLE, + LessOverload.LESS_STRING, + LessOverload.LESS_BYTES, + LessOverload.LESS_TIMESTAMP, + LessOverload.LESS_DURATION, + LessOverload.LESS_INT64_UINT64, + LessOverload.LESS_UINT64_INT64, + LessOverload.LESS_INT64_DOUBLE, + LessOverload.LESS_DOUBLE_INT64, + LessOverload.LESS_UINT64_DOUBLE, + LessOverload.LESS_DOUBLE_UINT64), + LESS_EQUALS( + Operator.LESS_EQUALS.getFunction(), + LessEqualsOverload.LESS_EQUALS_BOOL, + LessEqualsOverload.LESS_EQUALS_INT64, + LessEqualsOverload.LESS_EQUALS_UINT64, + LessEqualsOverload.LESS_EQUALS_DOUBLE, + LessEqualsOverload.LESS_EQUALS_STRING, + LessEqualsOverload.LESS_EQUALS_BYTES, + LessEqualsOverload.LESS_EQUALS_TIMESTAMP, + LessEqualsOverload.LESS_EQUALS_DURATION, + LessEqualsOverload.LESS_EQUALS_INT64_UINT64, + LessEqualsOverload.LESS_EQUALS_UINT64_INT64, + LessEqualsOverload.LESS_EQUALS_INT64_DOUBLE, + LessEqualsOverload.LESS_EQUALS_DOUBLE_INT64, + LessEqualsOverload.LESS_EQUALS_UINT64_DOUBLE, + LessEqualsOverload.LESS_EQUALS_DOUBLE_UINT64), + GREATER( + Operator.GREATER.getFunction(), + GreaterOverload.GREATER_BOOL, + GreaterOverload.GREATER_INT64, + GreaterOverload.GREATER_UINT64, + GreaterOverload.GREATER_DOUBLE, + GreaterOverload.GREATER_STRING, + GreaterOverload.GREATER_BYTES, + GreaterOverload.GREATER_TIMESTAMP, + GreaterOverload.GREATER_DURATION, + GreaterOverload.GREATER_INT64_UINT64, + GreaterOverload.GREATER_UINT64_INT64, + GreaterOverload.GREATER_INT64_DOUBLE, + GreaterOverload.GREATER_DOUBLE_INT64, + GreaterOverload.GREATER_UINT64_DOUBLE, + GreaterOverload.GREATER_DOUBLE_UINT64), + GREATER_EQUALS( + Operator.GREATER_EQUALS.getFunction(), + GreaterEqualsOverload.GREATER_EQUALS_BOOL, + GreaterEqualsOverload.GREATER_EQUALS_BYTES, + GreaterEqualsOverload.GREATER_EQUALS_DOUBLE, + GreaterEqualsOverload.GREATER_EQUALS_DURATION, + GreaterEqualsOverload.GREATER_EQUALS_INT64, + GreaterEqualsOverload.GREATER_EQUALS_STRING, + GreaterEqualsOverload.GREATER_EQUALS_TIMESTAMP, + GreaterEqualsOverload.GREATER_EQUALS_UINT64, + GreaterEqualsOverload.GREATER_EQUALS_INT64_UINT64, + GreaterEqualsOverload.GREATER_EQUALS_UINT64_INT64, + GreaterEqualsOverload.GREATER_EQUALS_INT64_DOUBLE, + GreaterEqualsOverload.GREATER_EQUALS_DOUBLE_INT64, + GreaterEqualsOverload.GREATER_EQUALS_UINT64_DOUBLE, + GreaterEqualsOverload.GREATER_EQUALS_DOUBLE_UINT64); + + private final String functionName; + private final ImmutableSet standardOverloads; + + StandardFunction(String functionName, CelStandardOverload... overloads) { + this.functionName = functionName; + this.standardOverloads = ImmutableSet.copyOf(overloads); + } + + @VisibleForTesting + ImmutableSet getOverloads() { + return standardOverloads; + } + } + + @VisibleForTesting + ImmutableSet getOverloads() { + return ImmutableSet.copyOf(standardOverloads.values()); + } + + @Internal + public ImmutableSet newFunctionBindings( + RuntimeEquality runtimeEquality, CelOptions celOptions) { + ImmutableSet.Builder builder = ImmutableSet.builder(); + + for (Map.Entry> entry : + standardOverloads.asMap().entrySet()) { + String functionName = entry.getKey(); + Collection overloads = entry.getValue(); + + ImmutableSet bindings = + overloads.stream() + .map(o -> o.newFunctionBinding(celOptions, runtimeEquality)) + .collect(toImmutableSet()); + + builder.addAll(CelFunctionBinding.fromOverloads(functionName, bindings)); + } + + return builder.build(); + } + + /** Builder for constructing the set of standard function/identifiers. */ + public static final class Builder { + private ImmutableSet includeFunctions; + private ImmutableSet excludeFunctions; + + private FunctionFilter functionFilter; + + private Builder() { + this.includeFunctions = ImmutableSet.of(); + this.excludeFunctions = ImmutableSet.of(); + } + + @CanIgnoreReturnValue + public Builder excludeFunctions(StandardFunction... functions) { + return excludeFunctions(ImmutableSet.copyOf(functions)); + } + + @CanIgnoreReturnValue + public Builder excludeFunctions(Iterable functions) { + this.excludeFunctions = checkNotNull(ImmutableSet.copyOf(functions)); + return this; + } + + @CanIgnoreReturnValue + public Builder includeFunctions(StandardFunction... functions) { + return includeFunctions(ImmutableSet.copyOf(functions)); + } + + @CanIgnoreReturnValue + public Builder includeFunctions(Iterable functions) { + this.includeFunctions = checkNotNull(ImmutableSet.copyOf(functions)); + return this; + } + + @CanIgnoreReturnValue + public Builder filterFunctions(FunctionFilter functionFilter) { + this.functionFilter = functionFilter; + return this; + } + + private static void assertOneSettingIsSet( + boolean a, boolean b, boolean c, String errorMessage) { + int count = 0; + if (a) { + count++; + } + if (b) { + count++; + } + if (c) { + count++; + } + + if (count > 1) { + throw new IllegalArgumentException(errorMessage); + } + } + + public CelStandardFunctions build() { + boolean hasIncludeFunctions = !this.includeFunctions.isEmpty(); + boolean hasExcludeFunctions = !this.excludeFunctions.isEmpty(); + boolean hasFilterFunction = this.functionFilter != null; + assertOneSettingIsSet( + hasIncludeFunctions, + hasExcludeFunctions, + hasFilterFunction, + "You may only populate one of the following builder methods: includeFunctions," + + " excludeFunctions or filterFunctions"); + + ImmutableMultimap.Builder standardOverloadBuilder = + ImmutableMultimap.builder(); + for (StandardFunction standardFunction : StandardFunction.values()) { + if (hasIncludeFunctions) { + if (this.includeFunctions.contains(standardFunction)) { + standardOverloadBuilder.putAll( + standardFunction.functionName, standardFunction.standardOverloads); + } + continue; + } + if (hasExcludeFunctions) { + if (!this.excludeFunctions.contains(standardFunction)) { + standardOverloadBuilder.putAll( + standardFunction.functionName, standardFunction.standardOverloads); + } + continue; + } + if (hasFilterFunction) { + for (CelStandardOverload standardOverload : standardFunction.standardOverloads) { + boolean includeOverload = functionFilter.include(standardFunction, standardOverload); + if (includeOverload) { + standardOverloadBuilder.put(standardFunction.functionName, standardOverload); + } + } + + continue; + } + + standardOverloadBuilder.putAll( + standardFunction.functionName, standardFunction.standardOverloads); + } + + return new CelStandardFunctions(standardOverloadBuilder.build()); + } + + /** + * Functional interface for filtering standard functions. Returning true in the callback will + * include the function in the environment. + */ + @FunctionalInterface + public interface FunctionFilter { + boolean include(StandardFunction standardFunction, CelStandardOverload standardOverload); + } + } + + /** Creates a new builder to configure CelStandardFunctions. */ + public static Builder newBuilder() { + return new Builder(); + } + + static boolean isHeterogeneousComparison(CelStandardOverload overload) { + return HETEROGENEOUS_COMPARISON_OPERATORS.contains(overload); + } + + private CelStandardFunctions(ImmutableMultimap standardOverloads) { + this.standardOverloads = standardOverloads; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelUnknownSet.java b/runtime/src/main/java/dev/cel/runtime/CelUnknownSet.java new file mode 100644 index 000000000..62d975f93 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelUnknownSet.java @@ -0,0 +1,76 @@ +// Copyright 2022 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.auto.value.AutoValue; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Sets; + +/** + * Unknown set representation. + * + *

An unknown set is the collection of unknowns that were encountered while evaluating a CEL + * expression and not pruned via logical operators. + * + *

Note: dependant unknown values may not be included, so it's possible that re-evaluating the + * same expression with all the unknowns resolved will result in a different unknown set. + */ +@AutoValue +public abstract class CelUnknownSet { + + /** + * Set of attributes with a series of selection or index operations marked unknown. This set is + * always empty if enableUnknownTracking is disabled in {@code CelOptions}. + */ + public abstract ImmutableSet attributes(); + + /** Set of subexpression IDs that were decided to be unknown and in the critical path. */ + public abstract ImmutableSet unknownExprIds(); + + public static CelUnknownSet create(CelAttribute attribute) { + return create(ImmutableSet.of(attribute)); + } + + public static CelUnknownSet create(ImmutableSet attributes) { + return create(attributes, ImmutableSet.of()); + } + + public static CelUnknownSet create(Long... unknownExprIds) { + return create(ImmutableSet.copyOf(unknownExprIds)); + } + + public static CelUnknownSet create(CelAttribute attribute, Iterable unknownExprIds) { + return create(ImmutableSet.of(attribute), ImmutableSet.copyOf(unknownExprIds)); + } + + static CelUnknownSet create(Iterable unknownExprIds) { + return create(ImmutableSet.of(), ImmutableSet.copyOf(unknownExprIds)); + } + + public static CelUnknownSet create( + ImmutableSet attributes, ImmutableSet unknownExprIds) { + return new AutoValue_CelUnknownSet(attributes, unknownExprIds); + } + + public static CelUnknownSet union(CelUnknownSet lhs, CelUnknownSet rhs) { + return create( + Sets.union(lhs.attributes(), rhs.attributes()).immutableCopy(), + Sets.union(lhs.unknownExprIds(), rhs.unknownExprIds()).immutableCopy()); + } + + public CelUnknownSet merge(CelUnknownSet rhs) { + return union(this, rhs); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelValueRuntimeTypeProvider.java b/runtime/src/main/java/dev/cel/runtime/CelValueRuntimeTypeProvider.java new file mode 100644 index 000000000..38365127c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelValueRuntimeTypeProvider.java @@ -0,0 +1,137 @@ +// Copyright 2023 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 static com.google.common.base.Preconditions.checkNotNull; + +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.MessageLite; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelAttributeNotFoundException; +import dev.cel.common.values.BaseProtoCelValueConverter; +import dev.cel.common.values.BaseProtoMessageValueProvider; +import dev.cel.common.values.CelValueProvider; +import dev.cel.common.values.CombinedCelValueProvider; +import dev.cel.common.values.SelectableValue; +import java.util.Map; +import java.util.NoSuchElementException; + +/** Bridge between the old RuntimeTypeProvider and CelValueProvider APIs. */ +@Internal +@Immutable +final class CelValueRuntimeTypeProvider implements RuntimeTypeProvider { + + private final CelValueProvider valueProvider; + private final BaseProtoCelValueConverter protoCelValueConverter; + private static final BaseProtoCelValueConverter DEFAULT_CEL_VALUE_CONVERTER = + new BaseProtoCelValueConverter() {}; + + static CelValueRuntimeTypeProvider newInstance(CelValueProvider valueProvider) { + BaseProtoCelValueConverter converter = DEFAULT_CEL_VALUE_CONVERTER; + + // Find the underlying ProtoCelValueConverter. + // This is required because DefaultInterpreter works with a resolved protobuf messages directly + // in evaluation flow. + // A new runtime should not directly depend on protobuf, thus this will not be needed in the + // future. + if (valueProvider instanceof BaseProtoMessageValueProvider) { + converter = ((BaseProtoMessageValueProvider) valueProvider).protoCelValueConverter(); + } else if (valueProvider instanceof CombinedCelValueProvider) { + converter = + ((CombinedCelValueProvider) valueProvider) + .valueProviders().stream() + .filter(p -> p instanceof BaseProtoMessageValueProvider) + .map(p -> ((BaseProtoMessageValueProvider) p).protoCelValueConverter()) + .findFirst() + .orElse(DEFAULT_CEL_VALUE_CONVERTER); + } + + return new CelValueRuntimeTypeProvider(valueProvider, converter); + } + + @Override + public Object createMessage(String messageName, Map values) { + return protoCelValueConverter.maybeUnwrap( + valueProvider + .newValue(messageName, values) + .orElseThrow( + () -> + new NoSuchElementException( + String.format("cannot resolve '%s' as a message", messageName)))); + } + + @Override + public Object selectField(Object message, String fieldName) { + if (message instanceof Map) { + Map map = (Map) message; + if (map.containsKey(fieldName)) { + return map.get(fieldName); + } + + throw CelAttributeNotFoundException.forMissingMapKey(fieldName); + } + + SelectableValue selectableValue = getSelectableValueOrThrow(message, fieldName); + Object value = selectableValue.select(fieldName); + + return protoCelValueConverter.maybeUnwrap(value); + } + + @Override + public Object hasField(Object message, String fieldName) { + SelectableValue selectableValue = getSelectableValueOrThrow(message, fieldName); + + return selectableValue.find(fieldName).isPresent(); + } + + @SuppressWarnings("unchecked") + private SelectableValue getSelectableValueOrThrow(Object obj, String fieldName) { + Object convertedCelValue = protoCelValueConverter.toRuntimeValue(obj); + + if (!(convertedCelValue instanceof SelectableValue)) { + throwInvalidFieldSelection(fieldName); + } + + return (SelectableValue) convertedCelValue; + } + + @Override + public Object adapt(String messageName, Object message) { + if (message instanceof CelUnknownSet) { + return message; // CelUnknownSet is handled specially for iterative evaluation. No need to + // adapt to CelValue. + } + + if (message instanceof MessageLite.Builder) { + message = ((MessageLite.Builder) message).build(); + } + + if (message instanceof MessageLite) { + return protoCelValueConverter.maybeUnwrap(protoCelValueConverter.toRuntimeValue(message)); + } + + return message; + } + + private static void throwInvalidFieldSelection(String fieldName) { + throw CelAttributeNotFoundException.forFieldResolution(fieldName); + } + + private CelValueRuntimeTypeProvider( + CelValueProvider valueProvider, BaseProtoCelValueConverter protoCelValueConverter) { + this.valueProvider = checkNotNull(valueProvider); + this.protoCelValueConverter = checkNotNull(protoCelValueConverter); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/CelVariableResolver.java b/runtime/src/main/java/dev/cel/runtime/CelVariableResolver.java new file mode 100644 index 000000000..76e6bc76e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/CelVariableResolver.java @@ -0,0 +1,55 @@ +// Copyright 2022 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 java.util.Optional; + +/** Functional interface that exposes a method to find a CEL variable value by name. */ +@FunctionalInterface +public interface CelVariableResolver { + + /** + * Find a variable value, if present, by {@code name}. + * + *

Variable {@code String} names may be simple, e.g. {@code status} or qualified {@code + * pkg.qual.status}. CEL resolves identifiers within an expression {@code container} using + * protobuf namespace resolution rules. + * + *

For example, given an expression container name {@code a.b.c.M.N} and a variable name {@code + * R.s}, CEL evaluators will try resolve names in the following order: + * + *

    + *
  1. {@code a.b.c.M.N.R.s} + *
  2. {@code a.b.c.M.R.s} + *
  3. {@code a.b.c.R.s} + *
  4. {@code a.b.R.s} + *
  5. {@code a.R.s} + *
  6. {@code R.s} + *
+ */ + Optional find(String name); + + /** + * Chain two variable resolvers together, using the {@code primary} as the initial variable source + * to consider, and the {@code secondary} as a backup. + * + *

When a variable appears in both resolvers, then the {@code primary} variable value will + * shadow the value in the {@code secondary}. + */ + static CelVariableResolver hierarchicalVariableResolver( + CelVariableResolver primary, CelVariableResolver secondary) { + return HierarchicalVariableResolver.newInstance(primary, secondary); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/ConcatenatedListView.java b/runtime/src/main/java/dev/cel/runtime/ConcatenatedListView.java new file mode 100644 index 000000000..c15e76f77 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/ConcatenatedListView.java @@ -0,0 +1,107 @@ +// Copyright 2025 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 dev.cel.common.annotations.Internal; +import java.util.AbstractList; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; + +/** + * A custom list view implementation that allows O(1) concatenation of two lists. Its primary + * purpose is to facilitate efficient accumulation of lists for later materialization. (ex: + * comprehensions that dispatch `add_list` to concat N lists together). + * + *

This does not support any of the standard list operations from {@link java.util.List}. + * + + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class ConcatenatedListView extends AbstractList { + private final List> sourceLists; + private int totalSize = 0; + + ConcatenatedListView() { + this.sourceLists = new ArrayList<>(); + } + + public ConcatenatedListView(Collection collection) { + this(); + addAll(collection); + } + + @Override + public boolean addAll(Collection collection) { + if (!(collection instanceof List)) { + // size() is O(1) iff it's a list + throw new IllegalStateException("addAll must be called with lists, not collections"); + } + + sourceLists.add((List) collection); + totalSize += collection.size(); + return true; + } + + @Override + public E get(int index) { + throw new UnsupportedOperationException("get method not supported."); + } + + @Override + public int size() { + return totalSize; + } + + @Override + public Iterator iterator() { + return new ConcatenatingIterator(); + } + + /** Custom iterator to provide a flat view of all concatenated collections */ + private class ConcatenatingIterator implements Iterator { + private int index = 0; + private Iterator iterator = null; + + @Override + public boolean hasNext() { + while (iterator == null || !iterator.hasNext()) { + if (index < sourceLists.size()) { + iterator = sourceLists.get(index).iterator(); + index++; + } else { + return false; + } + } + return true; + } + + @Override + public E next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return iterator.next(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException("remove method not supported"); + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/DefaultDispatcher.java b/runtime/src/main/java/dev/cel/runtime/DefaultDispatcher.java new file mode 100644 index 000000000..0a467db81 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/DefaultDispatcher.java @@ -0,0 +1,234 @@ +// Copyright 2022 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 static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Joiner; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelErrorCode; +import dev.cel.common.annotations.Internal; +import dev.cel.runtime.FunctionBindingImpl.DynamicDispatchOverload; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** + * Default implementation of dispatcher. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public final class DefaultDispatcher implements CelFunctionResolver { + + private final ImmutableMap overloads; + + public Optional findOverload(String functionName) { + return Optional.ofNullable(overloads.get(functionName)); + } + + @Override + public Optional findOverloadMatchingArgs(String functionName, Object[] args) + throws CelEvaluationException { + return findOverloadMatchingArgs(functionName, overloads.keySet(), overloads, args); + } + + @Override + public Optional findOverloadMatchingArgs( + String functionName, Collection overloadIds, Object[] args) + throws CelEvaluationException { + return findOverloadMatchingArgs(functionName, overloadIds, overloads, args); + } + + /** Finds the overload that matches the given function name, overload IDs, and arguments. */ + static Optional findOverloadMatchingArgs( + String functionName, + Collection overloadIds, + Map overloads, + Object[] args) + throws CelEvaluationException { + int matchingOverloadCount = 0; + CelResolvedOverload match = 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 (++matchingOverloadCount > 1) { + if (candidates == null) { + candidates = new ArrayList<>(); + candidates.add(match.getOverloadId()); + } + candidates.add(overloadId); + } + match = overload; + } + } + + if (matchingOverloadCount > 1) { + throw CelEvaluationExceptionBuilder.newBuilder( + "Ambiguous overloads for function '%s'. Matching candidates: %s", + functionName, Joiner.on(", ").join(candidates)) + .setErrorCode(CelErrorCode.AMBIGUOUS_OVERLOAD) + .build(); + } + return Optional.ofNullable(match); + } + + /** + * Finds the single registered overload iff it's marked as a non-strict function. + * + *

The intent behind this function is to provide an at-parity behavior with existing + * DefaultInterpreter, where it historically special-cased locating a single overload for certain + * non-strict functions, such as not_strictly_false. This method should not be used outside of + * this specific context. + * + * @throws IllegalStateException if there are multiple overloads that are marked non-strict. + */ + Optional findSingleNonStrictOverload(List overloadIds) { + for (String overloadId : overloadIds) { + CelResolvedOverload overload = overloads.get(overloadId); + if (overload != null && !overload.isStrict()) { + if (overloadIds.size() > 1) { + throw new IllegalStateException( + String.format( + "%d overloads found for a non-strict function. Expected 1.", overloadIds.size())); + } + return Optional.of(overload); + } + } + + return Optional.empty(); + } + + public static Builder newBuilder() { + return new Builder(); + } + + /** Builder for {@link DefaultDispatcher}. */ + public static class Builder { + + @AutoValue + @Immutable + abstract static class OverloadEntry { + abstract String functionName(); + + abstract ImmutableList> argTypes(); + + abstract boolean isStrict(); + + abstract CelFunctionOverload overload(); + + private static OverloadEntry of( + String functionName, + ImmutableList> argTypes, + boolean isStrict, + CelFunctionOverload overload) { + return new AutoValue_DefaultDispatcher_Builder_OverloadEntry( + functionName, argTypes, isStrict, overload); + } + } + + private final Map overloads; + + @CanIgnoreReturnValue + public Builder addOverload( + String functionName, + String overloadId, + ImmutableList> 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(functionName, argTypes, isStrict, overload); + + overloads.merge( + overloadId, + newEntry, + (existing, incoming) -> mergeDynamicDispatchesOrThrow(overloadId, existing, incoming)); + + return this; + } + + private OverloadEntry mergeDynamicDispatchesOrThrow( + String overloadId, OverloadEntry existing, OverloadEntry incoming) { + if (existing.overload() instanceof DynamicDispatchOverload + && incoming.overload() instanceof DynamicDispatchOverload) { + + DynamicDispatchOverload existingOverload = (DynamicDispatchOverload) existing.overload(); + DynamicDispatchOverload incomingOverload = (DynamicDispatchOverload) incoming.overload(); + + DynamicDispatchOverload mergedOverload = + new DynamicDispatchOverload( + overloadId, + ImmutableSet.builder() + .addAll(existingOverload.getOverloadBindings()) + .addAll(incomingOverload.getOverloadBindings()) + .build()); + + boolean isStrict = + mergedOverload.getOverloadBindings().stream().allMatch(CelFunctionBinding::isStrict); + + return OverloadEntry.of(overloadId, incoming.argTypes(), isStrict, mergedOverload); + } + + throw new IllegalArgumentException("Duplicate overload ID binding: " + overloadId); + } + + public DefaultDispatcher build() { + ImmutableMap.Builder resolvedOverloads = ImmutableMap.builder(); + for (Map.Entry entry : overloads.entrySet()) { + String overloadId = entry.getKey(); + OverloadEntry overloadEntry = entry.getValue(); + CelFunctionOverload overloadImpl = overloadEntry.overload(); + + resolvedOverloads.put( + overloadId, + CelResolvedOverload.of( + overloadEntry.functionName(), + overloadId, + overloadImpl, + overloadEntry.isStrict(), + overloadEntry.argTypes())); + } + + return new DefaultDispatcher(resolvedOverloads.buildOrThrow()); + } + + private Builder() { + this.overloads = new HashMap<>(); + } + } + + DefaultDispatcher(ImmutableMap overloads) { + this.overloads = overloads; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/DefaultInterpreter.java b/runtime/src/main/java/dev/cel/runtime/DefaultInterpreter.java new file mode 100644 index 000000000..fdab71c3d --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/DefaultInterpreter.java @@ -0,0 +1,1267 @@ +// Copyright 2023 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 static com.google.common.base.Preconditions.checkNotNull; + +import com.google.auto.value.AutoValue; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Joiner; +import com.google.common.base.Preconditions; +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.Immutable; +import javax.annotation.concurrent.ThreadSafe; +import com.google.protobuf.ByteString; +import com.google.protobuf.NullValue; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelErrorCode; +import dev.cel.common.CelOptions; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelComprehension; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.common.ast.CelExpr.ExprKind; +import dev.cel.common.ast.CelReference; +import dev.cel.common.exceptions.CelRuntimeException; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelType; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelByteString; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; + +/** Default implementation of the CEL interpreter. */ +@ThreadSafe +final class DefaultInterpreter implements Interpreter { + + private final TypeResolver typeResolver; + private final RuntimeTypeProvider typeProvider; + private final DefaultDispatcher dispatcher; + private final CelOptions celOptions; + + /** + * Internal representation of an intermediate evaluation result. + * + *

Represents a partial result of evaluating a sub expression and the corresponding CEL + * attribute (or Empty if not applicable). Top level results of evaluation should unwrap the + * underlying result (.value()). + */ + @AutoValue + abstract static class IntermediateResult { + abstract CelAttribute attribute(); + + abstract Object value(); + + static IntermediateResult create(CelAttribute attr, Object value) { + Preconditions.checkArgument( + !(value instanceof IntermediateResult), + "Recursive intermediate results are not supported."); + return new AutoValue_DefaultInterpreter_IntermediateResult(attr, value); + } + + static IntermediateResult create(Object value) { + return create(CelAttribute.EMPTY, value); + } + } + + /** + * Creates a new interpreter + * + * @param typeProvider object which allows to construct and inspect messages. + * @param dispatcher a method dispatcher. + * @param celOptions the configurable flags for adjusting evaluation behavior. + */ + public DefaultInterpreter( + TypeResolver typeResolver, + RuntimeTypeProvider typeProvider, + DefaultDispatcher dispatcher, + CelOptions celOptions) { + this.typeResolver = checkNotNull(typeResolver); + this.typeProvider = checkNotNull(typeProvider); + this.dispatcher = checkNotNull(dispatcher); + this.celOptions = checkNotNull(celOptions); + } + + @Override + public Interpretable createInterpretable(CelAbstractSyntaxTree ast) { + return new DefaultInterpretable(typeResolver, typeProvider, dispatcher, ast, celOptions); + } + + @Immutable + @VisibleForTesting + static final class DefaultInterpretable implements Interpretable, UnknownTrackingInterpretable { + private final TypeResolver typeResolver; + private final RuntimeTypeProvider typeProvider; + private final DefaultDispatcher dispatcher; + private final Metadata metadata; + private final CelAbstractSyntaxTree ast; + private final CelOptions celOptions; + + DefaultInterpretable( + TypeResolver typeResolver, + RuntimeTypeProvider typeProvider, + DefaultDispatcher dispatcher, + CelAbstractSyntaxTree ast, + CelOptions celOptions) { + this.typeResolver = checkNotNull(typeResolver); + this.typeProvider = checkNotNull(typeProvider); + this.dispatcher = checkNotNull(dispatcher); + this.ast = checkNotNull(ast); + this.metadata = new DefaultMetadata(ast); + this.celOptions = checkNotNull(celOptions); + } + + @Override + public Object eval(GlobalResolver resolver) throws CelEvaluationException { + // Result is already unwrapped from IntermediateResult. + return evalTrackingUnknowns( + RuntimeUnknownResolver.fromResolver(resolver), Optional.empty(), Optional.empty()); + } + + @Override + public Object eval(GlobalResolver resolver, CelEvaluationListener listener) + throws CelEvaluationException { + return evalTrackingUnknowns( + RuntimeUnknownResolver.fromResolver(resolver), Optional.empty(), Optional.of(listener)); + } + + @Override + public Object eval(GlobalResolver resolver, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException { + return evalTrackingUnknowns( + RuntimeUnknownResolver.fromResolver(resolver), + Optional.of(lateBoundFunctionResolver), + Optional.empty()); + } + + @Override + public Object eval( + GlobalResolver resolver, + CelFunctionResolver lateBoundFunctionResolver, + CelEvaluationListener listener) + throws CelEvaluationException { + return evalTrackingUnknowns( + RuntimeUnknownResolver.fromResolver(resolver), + Optional.of(lateBoundFunctionResolver), + Optional.of(listener)); + } + + @Override + public Object evalTrackingUnknowns( + RuntimeUnknownResolver resolver, + Optional functionResolver, + Optional listener) + throws CelEvaluationException { + ExecutionFrame frame = newExecutionFrame(resolver, functionResolver, listener); + IntermediateResult internalResult = evalInternal(frame, ast.getExpr()); + + Object underlyingValue = internalResult.value(); + + return maybeAdaptToCelUnknownSet(underlyingValue); + } + + private static Object maybeAdaptToCelUnknownSet(Object val) { + if (!(val instanceof AccumulatedUnknowns)) { + return val; + } + + AccumulatedUnknowns unknowns = (AccumulatedUnknowns) val; + + return CelUnknownSet.create( + ImmutableSet.copyOf(unknowns.attributes()), ImmutableSet.copyOf(unknowns.exprIds())); + } + + /** + * Evaluates this interpretable and returns the resulting execution frame populated with + * evaluation state. This method is specifically designed for testing the interpreter's internal + * invariants. + * + *

Do not expose to public. This method is strictly for internal testing purposes + * only. + */ + @VisibleForTesting + @CanIgnoreReturnValue + ExecutionFrame populateExecutionFrame(ExecutionFrame frame) throws CelEvaluationException { + evalInternal(frame, ast.getExpr()); + + return frame; + } + + @VisibleForTesting + ExecutionFrame newTestExecutionFrame(GlobalResolver resolver) { + return newExecutionFrame( + RuntimeUnknownResolver.fromResolver(resolver), Optional.empty(), Optional.empty()); + } + + private ExecutionFrame newExecutionFrame( + RuntimeUnknownResolver resolver, + Optional functionResolver, + Optional listener) { + int comprehensionMaxIterations = + celOptions.enableComprehension() ? celOptions.comprehensionMaxIterations() : 0; + return new ExecutionFrame(listener, resolver, functionResolver, comprehensionMaxIterations); + } + + private IntermediateResult evalInternal(ExecutionFrame frame, CelExpr expr) + throws CelEvaluationException { + try { + ExprKind.Kind exprKind = expr.exprKind().getKind(); + IntermediateResult result; + switch (exprKind) { + case CONSTANT: + result = IntermediateResult.create(evalConstant(frame, expr, expr.constant())); + break; + case IDENT: + result = evalIdent(frame, expr); + break; + case SELECT: + result = evalSelect(frame, expr, expr.select()); + break; + case CALL: + result = evalCall(frame, expr, expr.call()); + break; + case LIST: + result = evalList(frame, expr, expr.list()); + break; + case STRUCT: + result = evalStruct(frame, expr, expr.struct()); + break; + case MAP: + result = evalMap(frame, expr.map()); + break; + case COMPREHENSION: + result = evalComprehension(frame, expr, expr.comprehension()); + break; + default: + throw new IllegalStateException( + "unexpected expression kind: " + expr.exprKind().getKind()); + } + + frame + .getEvaluationListener() + .ifPresent( + listener -> listener.callback(expr, maybeAdaptToCelUnknownSet(result.value()))); + return result; + } catch (CelRuntimeException e) { + throw CelEvaluationExceptionBuilder.newBuilder(e).setMetadata(metadata, expr.id()).build(); + } catch (RuntimeException e) { + throw CelEvaluationExceptionBuilder.newBuilder(e.getMessage()) + .setCause(e) + .setMetadata(metadata, expr.id()) + .build(); + } + } + + private static boolean isUnknownValue(Object value) { + return InterpreterUtil.isAccumulatedUnknowns(value); + } + + private static boolean isUnknownOrError(Object value) { + return isUnknownValue(value) || value instanceof Exception; + } + + private Object evalConstant( + ExecutionFrame unusedFrame, CelExpr unusedExpr, CelConstant constExpr) { + switch (constExpr.getKind()) { + case NULL_VALUE: + return celOptions.evaluateCanonicalTypesToNativeValues() + ? constExpr.nullValue() + : NullValue.NULL_VALUE; + case BOOLEAN_VALUE: + return constExpr.booleanValue(); + case INT64_VALUE: + return constExpr.int64Value(); + case UINT64_VALUE: + if (celOptions.enableUnsignedLongs()) { + return constExpr.uint64Value(); + } + // Legacy users without the unsigned longs option turned on + return constExpr.uint64Value().longValue(); + case DOUBLE_VALUE: + return constExpr.doubleValue(); + case STRING_VALUE: + return constExpr.stringValue(); + case BYTES_VALUE: + CelByteString celByteString = constExpr.bytesValue(); + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return celByteString; + } + + return ByteString.copyFrom(celByteString.toByteArray()); + default: + throw new IllegalStateException("unsupported constant case: " + constExpr.getKind()); + } + } + + private IntermediateResult evalIdent(ExecutionFrame frame, CelExpr expr) + throws CelEvaluationException { + CelReference reference = ast.getReferenceOrThrow(expr.id()); + if (reference.value().isPresent()) { + return IntermediateResult.create(evalConstant(frame, expr, reference.value().get())); + } + return resolveIdent(frame, expr, reference.name()); + } + + private IntermediateResult resolveIdent(ExecutionFrame frame, CelExpr expr, String name) + throws CelEvaluationException { + // Check whether the type exists in the type check map as a 'type'. + CelType checkedType = getCheckedTypeOrThrow(expr); + if (checkedType.kind() == CelKind.TYPE) { + TypeType typeValue = typeResolver.adaptType(checkedType); + return IntermediateResult.create(typeValue); + } + + IntermediateResult rawResult = frame.resolveSimpleName(name, expr.id()); + Object value = rawResult.value(); + boolean isLazyExpression = value instanceof LazyExpression; + if (isLazyExpression) { + frame.markLazyEvaluationOrThrow(name); + + try { + value = evalInternal(frame, ((LazyExpression) value).celExpr).value(); + } finally { + frame.endLazyEvaluation(name); + } + } + + // Value resolved from Binding, it could be Message, PartialMessage or unbound(null) + value = InterpreterUtil.strict(typeProvider.adapt(checkedType.name(), value)); + IntermediateResult result = IntermediateResult.create(rawResult.attribute(), value); + + if (isLazyExpression) { + frame.cacheLazilyEvaluatedResult(name, result); + } + + return result; + } + + private IntermediateResult evalSelect(ExecutionFrame frame, CelExpr expr, CelSelect selectExpr) + throws CelEvaluationException { + Optional referenceOptional = ast.getReference(expr.id()); + if (referenceOptional.isPresent()) { + CelReference reference = referenceOptional.get(); + // This indicates it's a qualified name. + if (reference.value().isPresent()) { + // If the value is identified as a constant, skip attribute tracking. + return IntermediateResult.create(evalConstant(frame, expr, reference.value().get())); + } + return resolveIdent(frame, expr, reference.name()); + } + + return evalFieldSelect( + frame, expr, selectExpr.operand(), selectExpr.field(), selectExpr.testOnly()); + } + + private IntermediateResult evalFieldSelect( + ExecutionFrame frame, CelExpr expr, CelExpr operandExpr, String field, boolean isTestOnly) + throws CelEvaluationException { + // This indicates this is a field selection on the operand. + IntermediateResult operandResult = evalInternal(frame, operandExpr); + Object operand = operandResult.value(); + + CelAttribute attribute = + operandResult.attribute().qualify(CelAttribute.Qualifier.ofString(field)); + + Optional attrValue = frame.resolveAttribute(attribute); + + if (attrValue.isPresent()) { + return IntermediateResult.create(attribute, attrValue.get()); + } + + // Nested message could be unknown + if (isUnknownValue(operand)) { + return IntermediateResult.create(attribute, operand); + } + + if (isTestOnly) { + return IntermediateResult.create(attribute, typeProvider.hasField(operand, field)); + } + Object fieldValue = typeProvider.selectField(operand, field); + + return IntermediateResult.create( + attribute, InterpreterUtil.valueOrUnknown(fieldValue, expr.id())); + } + + private IntermediateResult evalCall(ExecutionFrame frame, CelExpr expr, CelCall callExpr) + throws CelEvaluationException { + CelReference reference = ast.getReferenceOrThrow(expr.id()); + Preconditions.checkState(!reference.overloadIds().isEmpty()); + + // Handle cases with special semantics. Those cannot have overloads. + switch (reference.overloadIds().get(0)) { + case "identity": + // Could be added as a binding to the dispatcher. Handled here for parity + // with FuturesInterpreter where the difference is slightly more significant. + return evalInternal(frame, callExpr.args().get(0)); + case "conditional": + return evalConditional(frame, callExpr); + case "logical_and": + return evalLogicalAnd(frame, callExpr); + case "logical_or": + return evalLogicalOr(frame, callExpr); + case "type": + return evalType(frame, callExpr); + case "optional_or_optional": + return evalOptionalOr(frame, expr); + case "optional_orValue_value": + return evalOptionalOrValue(frame, expr); + case "select_optional_field": + Optional result = maybeEvalOptionalSelectField(frame, expr, callExpr); + if (result.isPresent()) { + return result.get(); + } + break; + case "cel_block_list": + return evalCelBlock(frame, expr, callExpr); + default: + break; + } + + boolean isNonStrictCall = + dispatcher.findSingleNonStrictOverload(reference.overloadIds()).isPresent(); + return dispatchCall(frame, expr, callExpr, reference, isNonStrictCall); + } + + private IntermediateResult dispatchCall( + ExecutionFrame frame, + CelExpr expr, + CelCall callExpr, + CelReference reference, + boolean isNonStrict) + throws CelEvaluationException { + List callArgs = new ArrayList<>(); + callExpr.target().ifPresent(callArgs::add); + + callArgs.addAll(callExpr.args()); + IntermediateResult[] argResults = new IntermediateResult[callArgs.size()]; + + for (int i = 0; i < argResults.length; i++) { + IntermediateResult result; + try { + result = evalInternal(frame, callArgs.get(i)); + } catch (Exception e) { + if (!isNonStrict) { + throw e; + } + result = IntermediateResult.create(e); + } + argResults[i] = result; + } + + Optional indexAttr = + maybeContainerIndexAttribute(reference.overloadIds().get(0), argResults); + + CelAttribute attr = indexAttr.orElse(CelAttribute.EMPTY); + + Optional resolved = frame.resolveAttribute(attr); + if (resolved.isPresent()) { + return IntermediateResult.create(attr, resolved.get()); + } + + CallArgumentChecker argChecker = + indexAttr.isPresent() + ? CallArgumentChecker.createAcceptingPartial(frame.getResolver()) + : CallArgumentChecker.create(frame.getResolver()); + for (IntermediateResult element : argResults) { + argChecker.checkArg(element); + } + Optional unknowns = argChecker.maybeUnknowns(); + if (unknowns.isPresent()) { + return IntermediateResult.create(attr, unknowns.get()); + } + + Object[] argArray = Arrays.stream(argResults).map(IntermediateResult::value).toArray(); + ImmutableList overloadIds = reference.overloadIds(); + CelResolvedOverload overload = + findOverloadOrThrow(frame, expr, callExpr.function(), overloadIds, argArray); + try { + Object dispatchResult = overload.getDefinition().apply(argArray); + // CustomFunctions themselves can return a CelUnknownSet directly. + dispatchResult = InterpreterUtil.maybeAdaptToAccumulatedUnknowns(dispatchResult); + if (celOptions.unwrapWellKnownTypesOnFunctionDispatch()) { + CelType checkedType = getCheckedTypeOrThrow(expr); + dispatchResult = typeProvider.adapt(checkedType.name(), dispatchResult); + } + return IntermediateResult.create(attr, dispatchResult); + } catch (CelRuntimeException ce) { + throw CelEvaluationExceptionBuilder.newBuilder(ce).setMetadata(metadata, expr.id()).build(); + } catch (RuntimeException e) { + throw CelEvaluationExceptionBuilder.newBuilder( + "Function '%s' failed with arg(s) '%s'", + overload.getOverloadId(), Joiner.on(", ").join(argArray)) + .setMetadata(metadata, expr.id()) + .setCause(e) + .build(); + } + } + + private CelResolvedOverload findOverloadOrThrow( + ExecutionFrame frame, + CelExpr expr, + String functionName, + List overloadIds, + Object[] args) + throws CelEvaluationException { + try { + Optional funcImpl = + dispatcher.findOverloadMatchingArgs(functionName, overloadIds, args); + if (funcImpl.isPresent()) { + return funcImpl.get(); + } + return frame + .findOverload(functionName, overloadIds, args) + .orElseThrow( + () -> + CelEvaluationExceptionBuilder.newBuilder( + "No matching overload for function '%s'. Overload candidates: %s", + functionName, Joiner.on(",").join(overloadIds)) + .setErrorCode(CelErrorCode.OVERLOAD_NOT_FOUND) + .setMetadata(metadata, expr.id()) + .build()); + } catch (CelRuntimeException e) { + throw CelEvaluationExceptionBuilder.newBuilder(e).setMetadata(metadata, expr.id()).build(); + } + } + + private Optional maybeContainerIndexAttribute( + String overloadId, IntermediateResult[] args) { + switch (overloadId) { + case "index_list": + if (args.length == 2 && args[1].value() instanceof Long) { + return Optional.of( + args[0].attribute().qualify(CelAttribute.Qualifier.ofInt((Long) args[1].value()))); + } + break; + case "index_map": + if (args.length == 2) { + try { + CelAttribute.Qualifier qualifier = + CelAttribute.Qualifier.fromGeneric(args[1].value()); + return Optional.of(args[0].attribute().qualify(qualifier)); + } catch (IllegalArgumentException unused) { + // This indicates a key type that's not a supported attribute qualifier + // (e.g. dyn(b'bytes')). Instead of throwing here, allow dispatch to the possibly + // custom index overload and return an appropriate result. + } + } + break; + default: + break; + } + return Optional.empty(); + } + + private IntermediateResult evalConditional(ExecutionFrame frame, CelCall callExpr) + throws CelEvaluationException { + IntermediateResult condition = evalBooleanStrict(frame, callExpr.args().get(0)); + if (celOptions.enableShortCircuiting()) { + if (isUnknownValue(condition.value())) { + return condition; + } + if ((boolean) condition.value()) { + return evalInternal(frame, callExpr.args().get(1)); + } + return evalInternal(frame, callExpr.args().get(2)); + } else { + IntermediateResult lhs = evalNonstrictly(frame, callExpr.args().get(1)); + IntermediateResult rhs = evalNonstrictly(frame, callExpr.args().get(2)); + if (isUnknownValue(condition.value())) { + return condition; + } + Object result = + InterpreterUtil.strict((boolean) condition.value() ? lhs.value() : rhs.value()); + return IntermediateResult.create(result); + } + } + + private IntermediateResult mergeBooleanUnknowns(IntermediateResult lhs, IntermediateResult rhs) + throws CelEvaluationException { + // TODO: migrate clients to a common type that reports both expr-id unknowns + // and attribute sets. + Object lhsVal = lhs.value(); + Object rhsVal = rhs.value(); + if (lhsVal instanceof AccumulatedUnknowns && rhsVal instanceof AccumulatedUnknowns) { + return IntermediateResult.create( + ((AccumulatedUnknowns) lhsVal).merge((AccumulatedUnknowns) rhsVal)); + } else if (lhsVal instanceof AccumulatedUnknowns) { + return lhs; + } else if (rhsVal instanceof AccumulatedUnknowns) { + return rhs; + } + + // Otherwise, enforce strictness on both args + return IntermediateResult.create(InterpreterUtil.enforceStrictness(lhsVal, rhsVal)); + } + + private enum ShortCircuitableOperators { + LOGICAL_OR, + LOGICAL_AND + } + + private boolean canShortCircuit(IntermediateResult result, ShortCircuitableOperators operator) { + if (!(result.value() instanceof Boolean)) { + return false; + } + + Boolean value = (Boolean) result.value(); + if (value && operator.equals(ShortCircuitableOperators.LOGICAL_OR)) { + return true; + } + + return !value && operator.equals(ShortCircuitableOperators.LOGICAL_AND); + } + + private IntermediateResult evalLogicalOr(ExecutionFrame frame, CelCall callExpr) + throws CelEvaluationException { + IntermediateResult left; + IntermediateResult right; + if (celOptions.enableShortCircuiting()) { + left = evalBooleanNonstrict(frame, callExpr.args().get(0)); + if (canShortCircuit(left, ShortCircuitableOperators.LOGICAL_OR)) { + return left; + } + + right = evalBooleanNonstrict(frame, callExpr.args().get(1)); + if (canShortCircuit(right, ShortCircuitableOperators.LOGICAL_OR)) { + return right; + } + } else { + left = evalBooleanNonstrict(frame, callExpr.args().get(0)); + right = evalBooleanNonstrict(frame, callExpr.args().get(1)); + if (canShortCircuit(left, ShortCircuitableOperators.LOGICAL_OR)) { + return left; + } + if (canShortCircuit(right, ShortCircuitableOperators.LOGICAL_OR)) { + return right; + } + } + + // both are booleans. + if (right.value() instanceof Boolean && left.value() instanceof Boolean) { + return IntermediateResult.create((Boolean) right.value() || (Boolean) left.value()); + } + + return mergeBooleanUnknowns(left, right); + } + + private IntermediateResult evalLogicalAnd(ExecutionFrame frame, CelCall callExpr) + throws CelEvaluationException { + IntermediateResult left; + IntermediateResult right; + if (celOptions.enableShortCircuiting()) { + left = evalBooleanNonstrict(frame, callExpr.args().get(0)); + if (canShortCircuit(left, ShortCircuitableOperators.LOGICAL_AND)) { + return left; + } + + right = evalBooleanNonstrict(frame, callExpr.args().get(1)); + if (canShortCircuit(right, ShortCircuitableOperators.LOGICAL_AND)) { + return right; + } + } else { + left = evalBooleanNonstrict(frame, callExpr.args().get(0)); + right = evalBooleanNonstrict(frame, callExpr.args().get(1)); + if (canShortCircuit(left, ShortCircuitableOperators.LOGICAL_AND)) { + return left; + } + if (canShortCircuit(right, ShortCircuitableOperators.LOGICAL_AND)) { + return right; + } + } + + // both are booleans. + if (right.value() instanceof Boolean && left.value() instanceof Boolean) { + return IntermediateResult.create((Boolean) right.value() && (Boolean) left.value()); + } + + return mergeBooleanUnknowns(left, right); + } + + private IntermediateResult evalType(ExecutionFrame frame, CelCall callExpr) + throws CelEvaluationException { + CelExpr typeExprArg = callExpr.args().get(0); + IntermediateResult argResult = evalInternal(frame, typeExprArg); + // Type is a strict function. Early return if the argument is an error or an unknown. + if (isUnknownOrError(argResult.value())) { + return argResult; + } + + CelType checkedType = getCheckedTypeOrThrow(typeExprArg); + CelType checkedTypeValue = typeResolver.adaptType(checkedType); + return IntermediateResult.create( + typeResolver.resolveObjectType(argResult.value(), checkedTypeValue)); + } + + private IntermediateResult evalOptionalOr(ExecutionFrame frame, CelExpr expr) + throws CelEvaluationException { + return evalOptionalOrInternal(frame, expr, /* unwrapOptional= */ false); + } + + private IntermediateResult evalOptionalOrValue(ExecutionFrame frame, CelExpr expr) + throws CelEvaluationException { + return evalOptionalOrInternal(frame, expr, /* unwrapOptional= */ true); + } + + private IntermediateResult evalOptionalOrInternal( + ExecutionFrame frame, CelExpr expr, boolean unwrapOptional) throws CelEvaluationException { + CelCall callExpr = expr.call(); + CelExpr lhsExpr = + callExpr + .target() + .orElseThrow( + () -> new IllegalStateException("Missing target for chained optional function")); + IntermediateResult lhsResult = evalInternal(frame, lhsExpr); + + if (isUnknownValue(lhsResult.value())) { + return lhsResult; + } + + if (!(lhsResult.value() instanceof Optional)) { + String functionName = unwrapOptional ? "orValue" : "or"; + throw CelEvaluationExceptionBuilder.newBuilder( + "No matching overload for function '%s'.", functionName) + .setErrorCode(CelErrorCode.INVALID_ARGUMENT) + .setMetadata(metadata, expr.id()) + .build(); + } + + Optional lhsOptionalValue = (Optional) lhsResult.value(); + + if (lhsOptionalValue.isPresent()) { + // Short-circuit lhs if a value exists + return unwrapOptional ? IntermediateResult.create(lhsOptionalValue.get()) : lhsResult; + } + + return evalInternal(frame, callExpr.args().get(0)); + } + + private Optional maybeEvalOptionalSelectField( + ExecutionFrame frame, CelExpr expr, CelCall callExpr) throws CelEvaluationException { + CelExpr operand = callExpr.args().get(0); + IntermediateResult lhsResult = evalInternal(frame, operand); + if ((lhsResult.value() instanceof Map)) { + // Let the function dispatch handle optional map indexing + return Optional.empty(); + } + + String field = callExpr.args().get(1).constant().stringValue(); + boolean hasField = (boolean) typeProvider.hasField(lhsResult.value(), field); + if (!hasField) { + // Protobuf sets default (zero) values to uninitialized fields. + // In case of CEL's optional values, we want to explicitly return Optional.none() + // If the field is not set. + return Optional.of(IntermediateResult.create(Optional.empty())); + } + + IntermediateResult result = evalFieldSelect(frame, expr, operand, field, false); + // Ensure only one level of optional is wrapped when chaining optional field selections. + Object resultValue = result.value(); + if (!(resultValue instanceof Optional)) { + resultValue = Optional.of(resultValue); + } + return Optional.of(IntermediateResult.create(result.attribute(), resultValue)); + } + + private IntermediateResult evalBoolean(ExecutionFrame frame, CelExpr expr, boolean strict) + throws CelEvaluationException { + IntermediateResult value = strict ? evalInternal(frame, expr) : evalNonstrictly(frame, expr); + + if (!(value.value() instanceof Boolean) && !isUnknownOrError(value.value())) { + throw CelEvaluationExceptionBuilder.newBuilder( + "expected boolean value, found: %s", value.value()) + .setErrorCode(CelErrorCode.INVALID_ARGUMENT) + .setMetadata(metadata, expr.id()) + .build(); + } + + return value; + } + + private IntermediateResult evalBooleanStrict(ExecutionFrame frame, CelExpr expr) + throws CelEvaluationException { + return evalBoolean(frame, expr, /* strict= */ true); + } + + // Evaluate a non-strict boolean sub expression. + // Behaves the same as non-strict eval, but throws a CelEvaluationException if the result + // doesn't support CELs short-circuiting behavior (not an error, unknown or boolean). + private IntermediateResult evalBooleanNonstrict(ExecutionFrame frame, CelExpr expr) + throws CelEvaluationException { + return evalBoolean(frame, expr, /* strict= */ false); + } + + private IntermediateResult evalList(ExecutionFrame frame, CelExpr unusedExpr, CelList listExpr) + throws CelEvaluationException { + CallArgumentChecker argChecker = CallArgumentChecker.create(frame.getResolver()); + List result = new ArrayList<>(listExpr.elements().size()); + + HashSet optionalIndicesSet = new HashSet<>(listExpr.optionalIndices()); + ImmutableList elements = listExpr.elements(); + for (int i = 0; i < elements.size(); i++) { + CelExpr element = elements.get(i); + IntermediateResult evaluatedElement = evalInternal(frame, element); + + argChecker.checkArg(evaluatedElement); + Object value = evaluatedElement.value(); + if (!optionalIndicesSet + .isEmpty() // Performance optimization to prevent autoboxing when there's no + // optionals. + && optionalIndicesSet.contains(i) + && !isUnknownValue(value)) { + if (!(value instanceof Optional)) { + throw new IllegalArgumentException( + String.format( + "Cannot initialize optional list element from non-optional value %s", value)); + } + Optional optionalVal = (Optional) value; + if (!optionalVal.isPresent()) { + continue; + } + + value = optionalVal.get(); + } + + result.add(value); + } + + return IntermediateResult.create(argChecker.maybeUnknowns().orElse(result)); + } + + private IntermediateResult evalMap(ExecutionFrame frame, CelMap mapExpr) + throws CelEvaluationException { + + CallArgumentChecker argChecker = CallArgumentChecker.create(frame.getResolver()); + + Map result = new LinkedHashMap<>(); + + for (CelMap.Entry entry : mapExpr.entries()) { + IntermediateResult keyResult = evalInternal(frame, entry.key()); + argChecker.checkArg(keyResult); + + IntermediateResult valueResult = evalInternal(frame, entry.value()); + argChecker.checkArg(valueResult); + + if (celOptions.errorOnDuplicateMapKeys() && result.containsKey(keyResult.value())) { + throw CelEvaluationExceptionBuilder.newBuilder( + "duplicate map key [%s]", keyResult.value()) + .setErrorCode(CelErrorCode.DUPLICATE_ATTRIBUTE) + .setMetadata(metadata, entry.key().id()) + .build(); + } + + Object value = valueResult.value(); + if (entry.optionalEntry() && !isUnknownValue(value)) { + if (!(value instanceof Optional)) { + throw new IllegalArgumentException( + String.format( + "Cannot initialize optional entry '%s' from non-optional value %s", + keyResult.value(), value)); + } + Optional optionalVal = (Optional) value; + if (!optionalVal.isPresent()) { + // This is a no-op currently but will be semantically correct when extended proto + // support allows proto mutation. + result.remove(keyResult.value()); + continue; + } + + value = optionalVal.get(); + } + result.put(keyResult.value(), value); + } + + return IntermediateResult.create(argChecker.maybeUnknowns().orElse(result)); + } + + private IntermediateResult evalStruct(ExecutionFrame frame, CelExpr expr, CelStruct structExpr) + throws CelEvaluationException { + CelReference reference = + ast.getReference(expr.id()) + .orElseThrow( + () -> + new IllegalStateException( + "Could not find a reference for CelStruct expression at ID: " + + expr.id())); + + // Message creation. + CallArgumentChecker argChecker = CallArgumentChecker.create(frame.getResolver()); + Map fields = new HashMap<>(); + for (CelStruct.Entry entry : structExpr.entries()) { + IntermediateResult fieldResult = evalInternal(frame, entry.value()); + argChecker.checkArg(fieldResult); + + Object value = fieldResult.value(); + if (entry.optionalEntry()) { + if (!(value instanceof Optional)) { + throw new IllegalArgumentException( + String.format( + "Cannot initialize optional entry 'single_double_wrapper' from non-optional" + + " value %s", + value)); + } + Optional optionalVal = (Optional) value; + if (!optionalVal.isPresent()) { + // This is a no-op currently but will be semantically correct when extended proto + // support allows proto mutation. + fields.remove(entry.fieldKey()); + continue; + } + + value = optionalVal.get(); + } + + fields.put(entry.fieldKey(), value); + } + + return argChecker + .maybeUnknowns() + .map(IntermediateResult::create) + .orElseGet( + () -> + IntermediateResult.create(typeProvider.createMessage(reference.name(), fields))); + } + + // Evaluates the expression and returns a value-or-throwable. + // If evaluation results in a value, that value is returned directly. If an exception + // is thrown during evaluation, that exception itself is returned as the result. + // Applying {@link #strict} to such a value-or-throwable recovers strict behavior. + private IntermediateResult evalNonstrictly(ExecutionFrame frame, CelExpr expr) { + try { + return evalInternal(frame, expr); + } catch (Exception e) { + return IntermediateResult.create(e); + } + } + + @SuppressWarnings("unchecked") // All type-erased elements are object compatible + private IntermediateResult maybeAdaptToListView(IntermediateResult accuValue) { + // ListView uses a mutable reference internally. Macros such as `filter` uses conditionals + // under the hood. In situations where short circuiting is disabled, we don't want to evaluate + // both LHS and RHS, as evaluating LHS can mutate the accu value, which also affects RHS. + if (!(accuValue.value() instanceof List) || !celOptions.enableShortCircuiting()) { + return accuValue; + } + + ConcatenatedListView lv = + new ConcatenatedListView<>((List) accuValue.value()); + return IntermediateResult.create(lv); + } + + @SuppressWarnings("unchecked") // All type-erased elements are object compatible + private IntermediateResult maybeAdaptViewToList(IntermediateResult accuValue) { + if ((accuValue.value() instanceof ConcatenatedListView)) { + // Materialize view back into a list to facilitate O(1) lookups. + List copiedList = new ArrayList<>((List) accuValue.value()); + + accuValue = IntermediateResult.create(copiedList); + } + + return accuValue; + } + + @SuppressWarnings("unchecked") + private IntermediateResult evalComprehension( + ExecutionFrame frame, CelExpr compreExpr, CelComprehension compre) + throws CelEvaluationException { + String accuVar = compre.accuVar(); + String iterVar = compre.iterVar(); + IntermediateResult iterRangeRaw = evalInternal(frame, compre.iterRange()); + Collection iterRange; + if (isUnknownValue(iterRangeRaw.value())) { + return iterRangeRaw; + } + if (iterRangeRaw.value() instanceof List) { + iterRange = (List) iterRangeRaw.value(); + } else if (iterRangeRaw.value() instanceof Map) { + iterRange = ((Map) iterRangeRaw.value()).keySet(); + } else { + throw CelEvaluationExceptionBuilder.newBuilder( + "expected a list or a map for iteration range but got '%s'", + iterRangeRaw.value().getClass().getSimpleName()) + .setErrorCode(CelErrorCode.INVALID_ARGUMENT) + .setMetadata(metadata, compre.iterRange().id()) + .build(); + } + IntermediateResult accuValue; + boolean isLazilyEvaluable = LazyExpression.isLazilyEvaluable(compre); + if (isLazilyEvaluable) { + accuValue = IntermediateResult.create(new LazyExpression(compre.accuInit())); + } else { + accuValue = evalNonstrictly(frame, compre.accuInit()); + // This ensures macros such as filter/map that uses "add_list" functions under the hood + // remain linear in time complexity + accuValue = maybeAdaptToListView(accuValue); + } + int i = 0; + for (Object elem : iterRange) { + frame.incrementIterations(metadata, compreExpr.id()); + + CelAttribute iterAttr = CelAttribute.EMPTY; + if (iterRange instanceof List) { + iterAttr = iterRangeRaw.attribute().qualify(CelAttribute.Qualifier.ofInt(i)); + } + + Map loopVars = new HashMap<>(); + if (!Strings.isNullOrEmpty(compre.iterVar2())) { + String iterVar2 = compre.iterVar2(); + if (iterRangeRaw.value() instanceof List) { + loopVars.put(iterVar, IntermediateResult.create((long) i)); + loopVars.put( + iterVar2, + IntermediateResult.create(iterAttr, RuntimeHelpers.maybeAdaptPrimitive(elem))); + } else if (iterRangeRaw.value() instanceof Map) { + Object key = elem; + Object value = ((Map) iterRangeRaw.value()).get(key); + loopVars.put( + iterVar, IntermediateResult.create(RuntimeHelpers.maybeAdaptPrimitive(key))); + loopVars.put( + iterVar2, IntermediateResult.create(RuntimeHelpers.maybeAdaptPrimitive(value))); + } + } else { + loopVars.put( + iterVar, + IntermediateResult.create(iterAttr, RuntimeHelpers.maybeAdaptPrimitive(elem))); + } + loopVars.put(accuVar, accuValue); + i++; + + frame.pushScope(Collections.unmodifiableMap(loopVars)); + IntermediateResult evalObject = evalBooleanStrict(frame, compre.loopCondition()); + if (!isUnknownValue(evalObject.value()) && !(boolean) evalObject.value()) { + frame.popScope(); + break; + } + accuValue = evalNonstrictly(frame, compre.loopStep()); + frame.popScope(); + } + + accuValue = maybeAdaptViewToList(accuValue); + + Map scopedAttributes = + Collections.singletonMap(accuVar, accuValue); + if (isLazilyEvaluable) { + frame.pushLazyScope(scopedAttributes); + } else { + frame.pushScope(scopedAttributes); + } + IntermediateResult result; + try { + result = evalInternal(frame, compre.result()); + } finally { + frame.popScope(); + } + return result; + } + + private IntermediateResult evalCelBlock( + ExecutionFrame frame, CelExpr unusedExpr, CelCall blockCall) throws CelEvaluationException { + CelList exprList = blockCall.args().get(0).list(); + Map blockList = new HashMap<>(); + for (int index = 0; index < exprList.elements().size(); index++) { + // Register the block indices as lazily evaluated expressions stored as unique identifiers. + String indexKey = "@index" + index; + blockList.put( + indexKey, + IntermediateResult.create(new LazyExpression(exprList.elements().get(index)))); + } + frame.setRequireCycleCheck(true); + frame.pushLazyScope(Collections.unmodifiableMap(blockList)); + + try { + return evalInternal(frame, blockCall.args().get(1)); + } finally { + frame.popScope(); + } + } + + private CelType getCheckedTypeOrThrow(CelExpr expr) throws CelEvaluationException { + return ast.getType(expr.id()) + .orElseThrow( + () -> + CelEvaluationExceptionBuilder.newBuilder( + "expected a runtime type for expression ID '%d' from checked expression," + + " but found none.", + expr.id()) + .setErrorCode(CelErrorCode.TYPE_NOT_FOUND) + .setMetadata(metadata, expr.id()) + .build()); + } + } + + /** Contains a CelExpr that is to be lazily evaluated. */ + private static class LazyExpression { + private final CelExpr celExpr; + + /** + * Checks whether the provided expression can be evaluated lazily then cached. For example, the + * accumulator initializer in `cel.bind` macro is a good candidate because it never needs to be + * updated after being evaluated once. + */ + private static boolean isLazilyEvaluable(CelComprehension comprehension) { + // For now, just handle cel.bind. cel.block will be a future addition. + return comprehension + .loopCondition() + .constantOrDefault() + .getKind() + .equals(CelConstant.Kind.BOOLEAN_VALUE) + && !comprehension.loopCondition().constant().booleanValue() + && comprehension.iterVar().equals("#unused") + && comprehension.iterRange().exprKind().getKind().equals(ExprKind.Kind.LIST) + && comprehension.iterRange().list().elements().isEmpty(); + } + + private LazyExpression(CelExpr celExpr) { + this.celExpr = celExpr; + } + } + + /** This class tracks the state meaningful to a single evaluation pass. */ + static class ExecutionFrame { + private final Optional evaluationListener; + private final int maxIterations; + private final ArrayDeque resolvers; + private final Optional lateBoundFunctionResolver; + private final Set activeLazyAttributes = new HashSet<>(); + private RuntimeUnknownResolver currentResolver; + private int iterations; + private boolean requireCycleCheck; + @VisibleForTesting int scopeLevel; + + private ExecutionFrame( + Optional evaluationListener, + RuntimeUnknownResolver resolver, + Optional lateBoundFunctionResolver, + int maxIterations) { + this.evaluationListener = evaluationListener; + this.resolvers = new ArrayDeque<>(); + this.resolvers.add(resolver); + this.lateBoundFunctionResolver = lateBoundFunctionResolver; + this.currentResolver = resolver; + this.maxIterations = maxIterations; + } + + private void markLazyEvaluationOrThrow(String name) { + if (!requireCycleCheck) { + return; + } + + boolean added = activeLazyAttributes.add(name); + if (!added) { + throw new IllegalStateException(String.format("Cycle detected: %s", name)); + } + } + + private void endLazyEvaluation(String name) { + if (!requireCycleCheck) { + return; + } + + activeLazyAttributes.remove(name); + } + + private Optional getEvaluationListener() { + return evaluationListener; + } + + private RuntimeUnknownResolver getResolver() { + return currentResolver; + } + + private Optional findOverload( + String function, List overloadIds, Object[] args) throws CelEvaluationException { + if (lateBoundFunctionResolver.isPresent()) { + return lateBoundFunctionResolver + .get() + .findOverloadMatchingArgs(function, overloadIds, args); + } + return Optional.empty(); + } + + private void incrementIterations(Metadata metadata, long exprId) throws CelEvaluationException { + if (maxIterations < 0) { + return; + } + if (++iterations > maxIterations) { + throw CelEvaluationExceptionBuilder.newBuilder( + String.format("Iteration budget exceeded: %d", maxIterations)) + .setMetadata(metadata, exprId) + .setErrorCode(CelErrorCode.ITERATION_BUDGET_EXCEEDED) + .build(); + } + } + + private IntermediateResult resolveSimpleName(String name, Long exprId) { + return currentResolver.resolveSimpleName(name, exprId); + } + + private Optional resolveAttribute(CelAttribute attr) { + return currentResolver.resolveAttribute(attr); + } + + private void cacheLazilyEvaluatedResult( + String name, DefaultInterpreter.IntermediateResult result) { + currentResolver.cacheLazilyEvaluatedResult(name, result); + } + + /** + * If set, interpreter will check for potential cycles for lazily evaluable attributes. This + * only applies for cel.@block indices. + */ + private void setRequireCycleCheck(boolean requireCycleCheck) { + this.requireCycleCheck = requireCycleCheck; + } + + private void pushLazyScope(Map scope) { + pushScope(scope); + for (String lazyAttribute : scope.keySet()) { + currentResolver.declareLazyAttribute(lazyAttribute); + } + } + + /** Note: we utilize a HashMap instead of ImmutableMap to make lookups faster on string keys. */ + private void pushScope(Map scope) { + scopeLevel++; + RuntimeUnknownResolver scopedResolver = currentResolver.withScope(scope); + currentResolver = scopedResolver; + resolvers.addLast(scopedResolver); + } + + private void popScope() { + scopeLevel--; + if (resolvers.isEmpty()) { + throw new IllegalStateException("Execution frame error: more scopes popped than pushed"); + } + resolvers.removeLast(); + currentResolver = resolvers.getLast(); + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/DefaultMetadata.java b/runtime/src/main/java/dev/cel/runtime/DefaultMetadata.java new file mode 100644 index 000000000..98aeb9c2a --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/DefaultMetadata.java @@ -0,0 +1,53 @@ +// Copyright 2022 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.common.base.Preconditions; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.annotations.Internal; + +/** + * Metadata implementation based on {@link CelAbstractSyntaxTree}. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public final class DefaultMetadata implements Metadata { + + private final CelAbstractSyntaxTree ast; + + public DefaultMetadata(CelAbstractSyntaxTree ast) { + this.ast = Preconditions.checkNotNull(ast); + } + + @Override + public String getLocation() { + return ast.getSource().getDescription(); + } + + @Override + public int getPosition(long exprId) { + ImmutableMap positions = ast.getSource().getPositionsMap(); + return positions.getOrDefault(exprId, 0); + } + + @Override + public boolean hasPosition(long exprId) { + return ast.getSource().getPositionsMap().containsKey(exprId); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/DescriptorMessageProvider.java b/runtime/src/main/java/dev/cel/runtime/DescriptorMessageProvider.java new file mode 100644 index 000000000..ecbba5e7e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/DescriptorMessageProvider.java @@ -0,0 +1,216 @@ +// Copyright 2022 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 com.google.protobuf.ByteString; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Message; +import com.google.protobuf.MessageOrBuilder; +import com.google.protobuf.NullValue; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelAttributeNotFoundException; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.internal.ProtoAdapter; +import dev.cel.common.internal.ProtoMessageFactory; +import dev.cel.common.types.CelTypes; +import dev.cel.common.values.CelByteString; +import java.util.Map; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** + * An implementation of {@link RuntimeTypeProvider} which relies on proto descriptors. + * + *

This can handle all messages providable by the given {@link MessageFactory}. In addition, one + * can provide message descriptors for messages external to the program which are provided via a + * {@link DynamicMessageFactory}. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public final class DescriptorMessageProvider implements RuntimeTypeProvider { + private final ProtoMessageFactory protoMessageFactory; + private final CelOptions celOptions; + + @SuppressWarnings("Immutable") + private final ProtoAdapter protoAdapter; + + /** + * Creates a new message provider with the given message factory. + * + * @deprecated Migrate to the CEL-Java fluent APIs. See {@code CelRuntimeFactory}. + */ + @Deprecated + public DescriptorMessageProvider(MessageFactory messageFactory) { + this(messageFactory.toProtoMessageFactory(), CelOptions.LEGACY); + } + + /** + * Create a new message provider with a given message factory and custom descriptor set to use + * when adapting from proto to CEL and vice versa. + */ + public DescriptorMessageProvider(ProtoMessageFactory protoMessageFactory, CelOptions celOptions) { + this.protoMessageFactory = protoMessageFactory; + this.celOptions = celOptions; + this.protoAdapter = new ProtoAdapter(DynamicProto.create(protoMessageFactory), celOptions); + } + + @Override + public @Nullable Object createMessage(String messageName, Map values) { + Message.Builder builder = + protoMessageFactory + .newBuilder(messageName) + .orElseThrow( + () -> + CelAttributeNotFoundException.of( + String.format("cannot resolve '%s' as a message", messageName))); + + try { + Descriptor descriptor = builder.getDescriptorForType(); + for (Map.Entry entry : values.entrySet()) { + FieldDescriptor fieldDescriptor = findField(descriptor, entry.getKey()); + Optional fieldValue = + protoAdapter.adaptValueToFieldType(fieldDescriptor, entry.getValue()); + fieldValue.ifPresent(o -> builder.setField(fieldDescriptor, o)); + } + return protoAdapter.adaptProtoToValue(builder.build()); + } catch (ArrayIndexOutOfBoundsException e) { + throw new IllegalArgumentException(e.getMessage()); + } + } + + @Override + @SuppressWarnings("unchecked") + public @Nullable Object selectField(Object message, String fieldName) { + boolean isOptionalMessage = false; + if (message instanceof Optional) { + isOptionalMessage = true; + Optional optionalMessage = (Optional) message; + if (!optionalMessage.isPresent()) { + return Optional.empty(); + } + + message = optionalMessage.get(); + } + + if (message instanceof Map) { + Map map = (Map) message; + if (map.containsKey(fieldName)) { + Object mapValue = map.get(fieldName); + return isOptionalMessage ? Optional.of(mapValue) : mapValue; + } + + if (isOptionalMessage) { + return Optional.empty(); + } else { + throw CelAttributeNotFoundException.forMissingMapKey(fieldName); + } + } + + MessageOrBuilder typedMessage = assertFullProtoMessage(message, fieldName); + FieldDescriptor fieldDescriptor = findField(typedMessage.getDescriptorForType(), fieldName); + // check whether the field is a wrapper type, then test has and return null + if (isWrapperType(fieldDescriptor) + && !fieldDescriptor.isRepeated() + && !typedMessage.hasField(fieldDescriptor)) { + return NullValue.NULL_VALUE; + } + Object value = typedMessage.getField(fieldDescriptor); + return protoAdapter.adaptFieldToValue(fieldDescriptor, value).orElse(null); + } + + /** Adapt object to its message value. */ + @Override + public Object adapt(String messageName, Object message) { + if (message instanceof Message) { + return protoAdapter.adaptProtoToValue((Message) message); + } + + if (celOptions.evaluateCanonicalTypesToNativeValues() && message instanceof ByteString) { + return CelByteString.of(((ByteString) message).toByteArray()); + } + + return message; + } + + @Override + public Object hasField(Object message, String fieldName) { + if (message instanceof Optional) { + Optional optionalMessage = (Optional) message; + if (!optionalMessage.isPresent()) { + return false; + } + message = optionalMessage.get(); + } + + if (message instanceof Map) { + Map map = (Map) message; + return map.containsKey(fieldName); + } + + MessageOrBuilder typedMessage = assertFullProtoMessage(message, fieldName); + FieldDescriptor fieldDescriptor = findField(typedMessage.getDescriptorForType(), fieldName); + if (fieldDescriptor.isRepeated()) { + return typedMessage.getRepeatedFieldCount(fieldDescriptor) > 0; + } + return typedMessage.hasField(fieldDescriptor); + } + + private FieldDescriptor findField(Descriptor descriptor, String fieldName) { + if (celOptions.enableJsonFieldNames()) { + for (FieldDescriptor fd : descriptor.getFields()) { + if (fd.getJsonName().equals(fieldName)) { + return fd; + } + } + } + + FieldDescriptor fieldDescriptor = descriptor.findFieldByName(fieldName); + if (fieldDescriptor != null) { + return fieldDescriptor; + } + fieldDescriptor = + protoMessageFactory.getDescriptorPool().findExtensionDescriptor(descriptor, fieldName).orElse(null); + if (fieldDescriptor != null) { + return fieldDescriptor; + } + + + throw new IllegalArgumentException( + String.format( + "field '%s' is not declared in message '%s'", fieldName, descriptor.getFullName())); + } + + private static MessageOrBuilder assertFullProtoMessage(Object candidate, String fieldName) { + if (!(candidate instanceof MessageOrBuilder)) { + // This can happen when the field selection is done on dyn, and it is not a message. + throw CelAttributeNotFoundException.forFieldResolution(fieldName); + } + return (MessageOrBuilder) candidate; + } + + private static boolean isWrapperType(FieldDescriptor field) { + if (field.getType() != FieldDescriptor.Type.MESSAGE) { + return false; + } + String fieldTypeName = field.getMessageType().getFullName(); + + return CelTypes.isWrapperType(fieldTypeName); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/DescriptorTypeResolver.java b/runtime/src/main/java/dev/cel/runtime/DescriptorTypeResolver.java new file mode 100644 index 000000000..3d5208e2e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/DescriptorTypeResolver.java @@ -0,0 +1,95 @@ +// Copyright 2025 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 static com.google.common.base.Preconditions.checkNotNull; + +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.MessageOrBuilder; +import dev.cel.common.annotations.Internal; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelValueConverter; +import java.util.NoSuchElementException; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** + * {@code DescriptorTypeResolver} extends {@link TypeResolver} and additionally resolves incoming + * protobuf message types using descriptors. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public final class DescriptorTypeResolver extends TypeResolver { + + private final @Nullable CelTypeProvider typeProvider; + + /** + * Creates a {@code DescriptorTypeResolver}. All protobuf messages are resolved as a type of + * {@link StructTypeReference}. + * + * @deprecated This only exists to maintain support for the legacy runtime. Use {@link + * #create(CelTypeProvider, CelValueConverter)} instead. + */ + @Deprecated + static DescriptorTypeResolver create(CelValueConverter celValueConverter) { + return new DescriptorTypeResolver(null, celValueConverter); + } + + /** + * Creates a {@code DescriptorTypeResolver}. If the protobuf message to be resolved can be found + * in the provided {@link CelTypeProvider}, the message is resolved as a concrete {@code + * ProtoMessageType} instead of a {@link StructTypeReference}. + */ + public static DescriptorTypeResolver create( + CelTypeProvider typeProvider, CelValueConverter celValueConverter) { + return new DescriptorTypeResolver(typeProvider, celValueConverter); + } + + @Override + public TypeType resolveObjectType(Object obj, CelType typeCheckedType) { + checkNotNull(obj); + + Optional wellKnownTypeType = resolveWellKnownObjectType(obj); + if (wellKnownTypeType.isPresent()) { + return wellKnownTypeType.get(); + } + + if (obj instanceof MessageOrBuilder) { + MessageOrBuilder msg = (MessageOrBuilder) obj; + String typeName = msg.getDescriptorForType().getFullName(); + if (typeProvider != null) { + return typeProvider + .findType(typeName) + .map(TypeType::create) + .orElseThrow(() -> new NoSuchElementException("Could not find type: " + typeName)); + } else { + return TypeType.create(StructTypeReference.create(typeName)); + } + } + + return super.resolveObjectType(obj, typeCheckedType); + } + + private DescriptorTypeResolver( + @Nullable CelTypeProvider typeProvider, CelValueConverter celValueConverter) { + super(celValueConverter); + this.typeProvider = typeProvider; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/DynamicMessageFactory.java b/runtime/src/main/java/dev/cel/runtime/DynamicMessageFactory.java new file mode 100644 index 000000000..41f78b078 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/DynamicMessageFactory.java @@ -0,0 +1,87 @@ +// Copyright 2022 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 com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.Message; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.CelDescriptorPool; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.ProtoMessageFactory; +import java.util.Collection; +import org.jspecify.annotations.Nullable; + +/** + * The {@code DynamicMessageFactory} creates {@link DynamicMessage} instances by protobuf name. + * + *

Creating message with {@code DynamicMessage} is significantly slower than instantiating + * messages directly as it uses Java reflection. + * + * @deprecated Do not use. CEL-Java users should leverage the Fluent APIs instead. See {@code + * CelRuntimeFactory}. + */ +@Immutable +@Deprecated +public final class DynamicMessageFactory implements MessageFactory { + private final ProtoMessageFactory protoMessageFactory; + + /** + * Create a {@link RuntimeTypeProvider} which can access only the types listed in the input {@code + * descriptors} using the {@code CelOptions.LEGACY} settings. + * + * @deprecated Use CEL Fluent APIs instead. Directly instantiating DynamicMessageFactory's + * RuntimeTypeProvider is no longer needed. + */ + @Deprecated + public static RuntimeTypeProvider typeProvider(Collection descriptors) { + return new DescriptorMessageProvider( + typeFactory(descriptors).toProtoMessageFactory(), CelOptions.LEGACY); + } + + /** + * Create a {@code MessageFactory} which can produce any protobuf type in the generated descriptor + * pool or in the input {@code descriptors}. + * + * @deprecated Use CEL Fluent APIs instead. Directly instantiating DynamicMessageFactory is no + * longer needed. + */ + @Deprecated + public static MessageFactory typeFactory(Collection descriptors) { + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + CelDescriptorUtil.getFileDescriptorsForDescriptors(descriptors)); + + return new DynamicMessageFactory(DefaultDescriptorPool.create(celDescriptors)); + } + + @Override + public ProtoMessageFactory toProtoMessageFactory() { + return protoMessageFactory; + } + + private DynamicMessageFactory(CelDescriptorPool celDescriptorPool) { + protoMessageFactory = DefaultMessageFactory.create(celDescriptorPool); + } + + @Override + public Message.@Nullable Builder newBuilder(String messageName) { + return protoMessageFactory.newBuilder(messageName).orElse(null); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java b/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java new file mode 100644 index 000000000..7b8efe8fd --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java @@ -0,0 +1,216 @@ +// Copyright 2025 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 static com.google.common.collect.ImmutableList.toImmutableList; + +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; + +@Immutable +final class FunctionBindingImpl implements InternalCelFunctionBinding { + + private final String functionName; + + private final String overloadId; + + private final ImmutableList> argTypes; + + private final CelFunctionOverload definition; + + private final boolean isStrict; + + @Override + public String getFunctionName() { + return functionName; + } + + @Override + public String getOverloadId() { + return overloadId; + } + + @Override + public ImmutableList> getArgTypes() { + return argTypes; + } + + @Override + public CelFunctionOverload getDefinition() { + return definition; + } + + @Override + public boolean isStrict() { + return isStrict; + } + + FunctionBindingImpl( + String functionName, + String overloadId, + ImmutableList> argTypes, + CelFunctionOverload definition, + boolean isStrict) { + this.functionName = functionName; + this.overloadId = overloadId; + this.argTypes = argTypes; + this.definition = definition; + this.isStrict = isStrict; + } + + FunctionBindingImpl( + String overloadId, + ImmutableList> argTypes, + CelFunctionOverload definition, + boolean isStrict) { + this(overloadId, overloadId, argTypes, definition, isStrict); + } + + static ImmutableSet groupOverloadsToFunction( + String functionName, ImmutableSet overloadBindings) { + ImmutableSet.Builder builder = ImmutableSet.builder(); + 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. + // (Ex: "matches" function) + boolean hasSingletonBinding = + 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, overloadBindings)); + } + } + + return builder.build(); + } + + @Immutable + static final class DynamicDispatchBinding implements InternalCelFunctionBinding { + + private final boolean isStrict; + private final DynamicDispatchOverload dynamicDispatchOverload; + + @Override + public String getOverloadId() { + return dynamicDispatchOverload.functionName; + } + + @Override + public String getFunctionName() { + return dynamicDispatchOverload.functionName; + } + + @Override + public ImmutableList> getArgTypes() { + return ImmutableList.of(); + } + + @Override + public CelFunctionOverload getDefinition() { + return dynamicDispatchOverload; + } + + @Override + public boolean isStrict() { + return isStrict; + } + + private DynamicDispatchBinding( + String functionName, ImmutableSet overloadBindings) { + this.isStrict = overloadBindings.stream().allMatch(CelFunctionBinding::isStrict); + this.dynamicDispatchOverload = new DynamicDispatchOverload(functionName, overloadBindings); + } + } + + @Immutable + static final class DynamicDispatchOverload implements OptimizedFunctionOverload { + private final String functionName; + private final ImmutableSet overloadBindings; + + @Override + public Object apply(Object[] args) throws CelEvaluationException { + for (CelFunctionBinding overload : overloadBindings) { + if (CelFunctionOverload.canHandle(args, overload.getArgTypes(), overload.isStrict())) { + return overload.getDefinition().apply(args); + } + } + + throw new CelOverloadNotFoundException( + functionName, + overloadBindings.stream() + .map(CelFunctionBinding::getOverloadId) + .collect(toImmutableList())); + } + + @Override + public Object apply(Object arg) throws CelEvaluationException { + for (CelFunctionBinding overload : overloadBindings) { + if (CelFunctionOverload.canHandle(arg, overload.getArgTypes(), overload.isStrict())) { + OptimizedFunctionOverload def = (OptimizedFunctionOverload) overload.getDefinition(); + return def.apply(arg); + } + } + throw new CelOverloadNotFoundException( + functionName, + overloadBindings.stream() + .map(CelFunctionBinding::getOverloadId) + .collect(toImmutableList())); + } + + @Override + public Object apply(Object arg1, Object arg2) throws CelEvaluationException { + for (CelFunctionBinding overload : overloadBindings) { + if (CelFunctionOverload.canHandle( + arg1, arg2, overload.getArgTypes(), overload.isStrict())) { + OptimizedFunctionOverload def = (OptimizedFunctionOverload) overload.getDefinition(); + return def.apply(arg1, arg2); + } + } + throw new CelOverloadNotFoundException( + functionName, + overloadBindings.stream() + .map(CelFunctionBinding::getOverloadId) + .collect(toImmutableList())); + } + + ImmutableSet getOverloadBindings() { + return overloadBindings; + } + + DynamicDispatchOverload( + String functionName, ImmutableSet overloadBindings) { + this.functionName = functionName; + this.overloadBindings = overloadBindings; + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/GlobalResolver.java b/runtime/src/main/java/dev/cel/runtime/GlobalResolver.java new file mode 100644 index 000000000..ffc1933b6 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/GlobalResolver.java @@ -0,0 +1,46 @@ +// Copyright 2022 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 dev.cel.common.annotations.Internal; +import org.jspecify.annotations.Nullable; + +/** + * An interface describing an object that can perform a lookup on a given name, returning the value + * associated with the so-named global variable. + * + *

CEL Library Internals. Do Not Use. + */ +@FunctionalInterface +@Internal +public interface GlobalResolver { + + /** An empty binder which resolves everything to null. */ + GlobalResolver EMPTY = + new GlobalResolver() { + @Override + public @Nullable Object resolve(String name) { + return null; + } + + @Override + public String toString() { + return "{}"; + } + }; + + /** Resolves the given name to its value. Returns null if resolution fails. */ + @Nullable Object resolve(String name); +} diff --git a/runtime/src/main/java/dev/cel/runtime/HierarchicalVariableResolver.java b/runtime/src/main/java/dev/cel/runtime/HierarchicalVariableResolver.java new file mode 100644 index 000000000..5efc4fea4 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/HierarchicalVariableResolver.java @@ -0,0 +1,44 @@ +// Copyright 2024 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 java.util.Optional; + +final class HierarchicalVariableResolver implements CelVariableResolver { + + private final CelVariableResolver primary; + private final CelVariableResolver secondary; + + @Override + public Optional find(String name) { + Optional value = primary.find(name); + return value.isPresent() ? value : secondary.find(name); + } + + @Override + public String toString() { + return secondary + " +> " + primary; + } + + static HierarchicalVariableResolver newInstance( + CelVariableResolver primary, CelVariableResolver secondary) { + return new HierarchicalVariableResolver(primary, secondary); + } + + private HierarchicalVariableResolver(CelVariableResolver primary, CelVariableResolver secondary) { + this.primary = primary; + this.secondary = secondary; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/InternalCelFunctionBinding.java b/runtime/src/main/java/dev/cel/runtime/InternalCelFunctionBinding.java new file mode 100644 index 000000000..48a0f36d1 --- /dev/null +++ b/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. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +@Immutable +public interface InternalCelFunctionBinding extends CelFunctionBinding { + String getFunctionName(); +} diff --git a/runtime/src/main/java/dev/cel/runtime/InternalFunctionBinder.java b/runtime/src/main/java/dev/cel/runtime/InternalFunctionBinder.java new file mode 100644 index 000000000..5a063ee6c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/InternalFunctionBinder.java @@ -0,0 +1,49 @@ +// Copyright 2025 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.common.collect.ImmutableList; +import dev.cel.common.annotations.Internal; + +/** + * A helper to create CelFunctionBinding instances with sensitive controls, such as to toggle the + * strictness of the function. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class InternalFunctionBinder { + + /** + * Create a unary function binding from the {@code overloadId}, {@code arg}, {@code impl}, and + * {@code} isStrict. + */ + @SuppressWarnings("unchecked") + public static CelFunctionBinding from( + String overloadId, Class arg, CelFunctionOverload.Unary impl, boolean isStrict) { + return from(overloadId, ImmutableList.of(arg), (args) -> impl.apply((T) args[0]), isStrict); + } + + /** + * Create a function binding from the {@code overloadId}, {@code argTypes}, {@code impl} and + * {@code isStrict}. + */ + public static CelFunctionBinding from( + String overloadId, Iterable> argTypes, CelFunctionOverload impl, boolean isStrict) { + return new FunctionBindingImpl(overloadId, ImmutableList.copyOf(argTypes), impl, isStrict); + } + + private InternalFunctionBinder() {} +} diff --git a/runtime/src/main/java/dev/cel/runtime/Interpretable.java b/runtime/src/main/java/dev/cel/runtime/Interpretable.java new file mode 100644 index 000000000..ece90cb4b --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/Interpretable.java @@ -0,0 +1,64 @@ +// Copyright 2022 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; + +/** + * Represent an expression which can be interpreted repeatedly using a given activation. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public interface Interpretable { + + /** Runs interpretation with the given activation which supplies name/value bindings. */ + Object eval(GlobalResolver resolver) throws CelEvaluationException; + + /** + * Runs interpretation with the given activation which supplies name/value bindings. + * + *

This method allows for evaluation listeners to be provided per-evaluation. + */ + Object eval(GlobalResolver resolver, CelEvaluationListener listener) + throws CelEvaluationException; + + /** + * Runs interpretation with the given activation which supplies name/value bindings. + * + *

This method allows for late-binding functions to be provided per-evaluation, which can be + * useful for binding functions which might have side-effects that are not observable to CEL + * directly such as recording telemetry or evaluation state in a more granular fashion than a more + * general evaluation listener might permit. + */ + Object eval(GlobalResolver resolver, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException; + + /** + * Runs interpretation with the given activation which supplies name/value bindings. + * + *

This method allows for late-binding functions to be provided per-evaluation, which can be + * useful for binding functions which might have side-effects that are not observable to CEL + * directly such as recording telemetry or evaluation state in a more granular fashion than a more + * general evaluation listener might permit. + */ + Object eval( + GlobalResolver resolver, + CelFunctionResolver lateBoundFunctionResolver, + CelEvaluationListener listener) + throws CelEvaluationException; +} diff --git a/runtime/src/main/java/dev/cel/runtime/Interpreter.java b/runtime/src/main/java/dev/cel/runtime/Interpreter.java new file mode 100644 index 000000000..5c316da1a --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/Interpreter.java @@ -0,0 +1,36 @@ +// Copyright 2022 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 javax.annotation.concurrent.ThreadSafe; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.annotations.Internal; + +/** + * Interface to a CEL interpreter. + * + *

CEL Library Internals. Do Not Use. + */ +@ThreadSafe +@Internal +public interface Interpreter { + + /** + * Creates an interpretable for the given expression. + * + *

This method may run pre-processing and partial evaluation of the expression it gets passed. + */ + Interpretable createInterpretable(CelAbstractSyntaxTree ast); +} diff --git a/runtime/src/main/java/dev/cel/runtime/InterpreterUtil.java b/runtime/src/main/java/dev/cel/runtime/InterpreterUtil.java new file mode 100644 index 000000000..73607cefd --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/InterpreterUtil.java @@ -0,0 +1,116 @@ +// Copyright 2022 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.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CheckReturnValue; +import dev.cel.common.annotations.Internal; +import org.jspecify.annotations.Nullable; + +/** + * Util class for CEL interpreter. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class InterpreterUtil { + + /** + * Enforces strictness. The outcome of a failed computation is represented by the value being a + * {@link Throwable}. Applying {@code strict()} to such a value-or-throwable will re-throw the + * proper exception. + */ + @CheckReturnValue + public static Object strict(Object valueOrThrowable) throws CelEvaluationException { + if (!(valueOrThrowable instanceof Throwable)) { + return valueOrThrowable; + } + if (valueOrThrowable instanceof CelEvaluationException) { + throw (CelEvaluationException) valueOrThrowable; + } + if (valueOrThrowable instanceof RuntimeException) { + throw (RuntimeException) valueOrThrowable; + } + throw new RuntimeException((Throwable) valueOrThrowable); + } + + /** + * Check if raw object is {@link CelUnknownSet}. + * + * @param obj Object to check. + * @return boolean value if object is unknown. + */ + public static boolean isUnknown(Object obj) { + return obj instanceof CelUnknownSet; + } + + public static boolean isAccumulatedUnknowns(Object obj) { + return obj instanceof AccumulatedUnknowns; + } + + /** If the argument is {@link CelUnknownSet}, adapts it into {@link AccumulatedUnknowns} */ + public static Object maybeAdaptToAccumulatedUnknowns(Object val) { + if (!(val instanceof CelUnknownSet)) { + return val; + } + + return adaptToAccumulatedUnknowns((CelUnknownSet) val); + } + + public static AccumulatedUnknowns adaptToAccumulatedUnknowns(CelUnknownSet unknowns) { + return AccumulatedUnknowns.create(unknowns.unknownExprIds(), unknowns.attributes()); + } + + public static Object maybeAdaptToCelUnknownSet(Object val) { + if (!(val instanceof AccumulatedUnknowns)) { + return val; + } + + AccumulatedUnknowns unknowns = (AccumulatedUnknowns) val; + return CelUnknownSet.create( + ImmutableSet.copyOf(unknowns.attributes()), ImmutableSet.copyOf(unknowns.exprIds())); + } + + /** + * Enforces strictness on both lhs/rhs arguments from logical operators (i.e: intentionally throws + * an appropriate exception when {@link Throwable} is encountered as part of evaluated result. + */ + public static Object enforceStrictness(Object left, Object right) throws CelEvaluationException { + // Throw left or right side exception for now, should combine them into ErrorSet. + // ==> + if (left instanceof Throwable) { + return InterpreterUtil.strict(left); + } + if (right instanceof Throwable) { + return InterpreterUtil.strict(right); + } + throw new RuntimeException( + "Left or/and right object is neither bool, unknown nor error, unexpected behavior."); + } + + public static Object valueOrUnknown(@Nullable Object valueOrThrowable, Long id) { + // Handle the unknown value case. + if (isAccumulatedUnknowns(valueOrThrowable)) { + return AccumulatedUnknowns.create(id); + } + // Handle the null value case. + if (valueOrThrowable == null) { + return AccumulatedUnknowns.create(id); + } + return valueOrThrowable; + } + + private InterpreterUtil() {} +} diff --git a/runtime/src/main/java/dev/cel/runtime/LiteProgramImpl.java b/runtime/src/main/java/dev/cel/runtime/LiteProgramImpl.java new file mode 100644 index 000000000..af8c1a6d0 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/LiteProgramImpl.java @@ -0,0 +1,64 @@ +// Copyright 2025 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.auto.value.AutoValue; +import com.google.errorprone.annotations.Immutable; +import java.util.Map; + +@Immutable +@AutoValue +abstract class LiteProgramImpl implements Program { + + abstract Interpretable interpretable(); + + @Override + public Object eval() throws CelEvaluationException { + return interpretable().eval(GlobalResolver.EMPTY); + } + + @Override + public Object eval(Map mapValue) throws CelEvaluationException { + return interpretable().eval(Activation.copyOf(mapValue)); + } + + @Override + public Object eval(Map mapValue, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException { + return interpretable().eval(Activation.copyOf(mapValue), lateBoundFunctionResolver); + } + + @Override + public Object eval(CelVariableResolver resolver, CelFunctionResolver lateBoundFunctionResolver) { + // TODO: Wire in program planner + throw new UnsupportedOperationException("To be implemented"); + } + + @Override + public Object eval(CelVariableResolver resolver) throws CelEvaluationException { + // TODO: Wire in program planner + throw new UnsupportedOperationException("To be implemented"); + } + + @Override + public Object eval(PartialVars partialVars) throws CelEvaluationException { + // TODO: Wire in program planner + throw new UnsupportedOperationException("To be implemented"); + } + + static Program plan(Interpretable interpretable) { + return new AutoValue_LiteProgramImpl(interpretable); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/LiteRuntimeImpl.java b/runtime/src/main/java/dev/cel/runtime/LiteRuntimeImpl.java new file mode 100644 index 000000000..8ce2d7733 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/LiteRuntimeImpl.java @@ -0,0 +1,221 @@ +// Copyright 2025 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 static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import javax.annotation.concurrent.ThreadSafe; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.common.values.CelValueProvider; +import dev.cel.runtime.standard.CelStandardFunction; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Optional; + +@ThreadSafe +final class LiteRuntimeImpl implements CelLiteRuntime { + private final Interpreter interpreter; + private final CelOptions celOptions; + private final ImmutableList customFunctionBindings; + private final ImmutableSet celStandardFunctions; + private final CelValueProvider celValueProvider; + + // This does not affect the evaluation behavior in any manner. + // CEL-Internal-4 + private final ImmutableSet runtimeLibraries; + + @Override + public Program createProgram(CelAbstractSyntaxTree ast) { + checkState(ast.isChecked(), "programs must be created from checked expressions"); + return LiteProgramImpl.plan(interpreter.createInterpretable(ast)); + } + + @Override + public CelLiteRuntimeBuilder toRuntimeBuilder() { + CelLiteRuntimeBuilder builder = + new Builder() + .setOptions(celOptions) + .setStandardFunctions(celStandardFunctions) + .addFunctionBindings(customFunctionBindings) + .addLibraries(runtimeLibraries); + + if (celValueProvider != null) { + builder.setValueProvider(celValueProvider); + } + + return builder; + } + + static final class Builder implements CelLiteRuntimeBuilder { + + // Following is visible to test `toBuilder`. + @VisibleForTesting CelOptions celOptions; + @VisibleForTesting final HashMap customFunctionBindings; + @VisibleForTesting final ImmutableSet.Builder runtimeLibrariesBuilder; + @VisibleForTesting final ImmutableSet.Builder standardFunctionBuilder; + @VisibleForTesting CelValueProvider celValueProvider; + + @Override + public CelLiteRuntimeBuilder setOptions(CelOptions celOptions) { + this.celOptions = celOptions; + return this; + } + + @Override + public CelLiteRuntimeBuilder setStandardFunctions(CelStandardFunction... standardFunctions) { + return setStandardFunctions(Arrays.asList(standardFunctions)); + } + + @Override + public CelLiteRuntimeBuilder setStandardFunctions( + Iterable standardFunctions) { + standardFunctionBuilder.addAll(standardFunctions); + return this; + } + + @Override + public CelLiteRuntimeBuilder addFunctionBindings(CelFunctionBinding... bindings) { + return addFunctionBindings(Arrays.asList(bindings)); + } + + @Override + public CelLiteRuntimeBuilder addFunctionBindings(Iterable bindings) { + bindings.forEach(o -> customFunctionBindings.putIfAbsent(o.getOverloadId(), o)); + return this; + } + + @Override + public CelLiteRuntimeBuilder setValueProvider(CelValueProvider celValueProvider) { + this.celValueProvider = celValueProvider; + return this; + } + + @Override + public CelLiteRuntimeBuilder addLibraries(CelLiteRuntimeLibrary... libraries) { + return addLibraries(Arrays.asList(checkNotNull(libraries))); + } + + @Override + public CelLiteRuntimeBuilder addLibraries(Iterable libraries) { + this.runtimeLibrariesBuilder.addAll(checkNotNull(libraries)); + return this; + } + + /** Throws if an unsupported flag in CelOptions is toggled. */ + private static void assertAllowedCelOptions(CelOptions celOptions) { + String prefix = "Misconfigured CelOptions: "; + if (!celOptions.enableCelValue()) { + throw new IllegalArgumentException(prefix + "enableCelValue must be enabled."); + } + if (!celOptions.enableUnsignedLongs()) { + throw new IllegalArgumentException(prefix + "enableUnsignedLongs cannot be disabled."); + } + if (!celOptions.unwrapWellKnownTypesOnFunctionDispatch()) { + throw new IllegalArgumentException( + prefix + "unwrapWellKnownTypesOnFunctionDispatch cannot be disabled."); + } + } + + @Override + public CelLiteRuntime build() { + assertAllowedCelOptions(celOptions); + ImmutableSet runtimeLibs = runtimeLibrariesBuilder.build(); + runtimeLibs.forEach(lib -> lib.setRuntimeOptions(this)); + + ImmutableMap.Builder functionBindingsBuilder = + ImmutableMap.builder(); + + ImmutableSet standardFunctions = standardFunctionBuilder.build(); + if (!standardFunctions.isEmpty()) { + RuntimeHelpers runtimeHelpers = RuntimeHelpers.create(); + RuntimeEquality runtimeEquality = RuntimeEquality.create(runtimeHelpers, celOptions); + for (CelStandardFunction standardFunction : standardFunctions) { + ImmutableSet standardFunctionBinding = + standardFunction.newFunctionBindings(celOptions, runtimeEquality); + for (CelFunctionBinding func : standardFunctionBinding) { + functionBindingsBuilder.put(func.getOverloadId(), func); + } + } + } + + functionBindingsBuilder.putAll(customFunctionBindings); + + DefaultDispatcher.Builder dispatcherBuilder = DefaultDispatcher.newBuilder(); + functionBindingsBuilder + .buildOrThrow() + .forEach( + (String overloadId, CelFunctionBinding func) -> { + String functionName = func.getOverloadId(); + if (func instanceof InternalCelFunctionBinding) { + functionName = ((InternalCelFunctionBinding) func).getFunctionName(); + } + dispatcherBuilder.addOverload( + functionName, + overloadId, + func.getArgTypes(), + func.isStrict(), + func.getDefinition()); + }); + + Interpreter interpreter = + new DefaultInterpreter( + TypeResolver.create(celValueProvider.celValueConverter()), + CelValueRuntimeTypeProvider.newInstance(celValueProvider), + dispatcherBuilder.build(), + celOptions); + + return new LiteRuntimeImpl( + interpreter, + celOptions, + customFunctionBindings.values(), + standardFunctions, + runtimeLibs, + celValueProvider); + } + + private Builder() { + this.celOptions = CelOptions.current().enableCelValue(true).build(); + this.celValueProvider = (structType, fields) -> Optional.empty(); + this.customFunctionBindings = new HashMap<>(); + this.standardFunctionBuilder = ImmutableSet.builder(); + this.runtimeLibrariesBuilder = ImmutableSet.builder(); + } + } + + static CelLiteRuntimeBuilder newBuilder() { + return new Builder(); + } + + private LiteRuntimeImpl( + Interpreter interpreter, + CelOptions celOptions, + Iterable customFunctionBindings, + ImmutableSet celStandardFunctions, + ImmutableSet runtimeLibraries, + CelValueProvider celValueProvider) { + this.interpreter = interpreter; + this.celOptions = celOptions; + this.customFunctionBindings = ImmutableList.copyOf(customFunctionBindings); + this.celStandardFunctions = celStandardFunctions; + this.runtimeLibraries = runtimeLibraries; + this.celValueProvider = celValueProvider; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/MessageFactory.java b/runtime/src/main/java/dev/cel/runtime/MessageFactory.java new file mode 100644 index 000000000..a7ec8de23 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/MessageFactory.java @@ -0,0 +1,83 @@ +// Copyright 2022 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.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Message; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.ProtoMessageFactory; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** + * The {@code MessageFactory} provides a method to create a protobuf builder objects by name. + * + * @deprecated Do not use. Internally, {@link ProtoMessageFactory} should be used. + */ +@Immutable +@FunctionalInterface +@Deprecated +public interface MessageFactory { + + /** + * Create a {@code Message.Builder} instance for the protobuf by {@code messageName}. + * + *

Returns {@code null} if the builder could not be created. + */ + Message.@Nullable Builder newBuilder(String messageName); + + /** + * Exists only to maintain FunctionalInterface requirement and to make legacy Dynamic/Linked + * message factories compatible with the new ProtoMessageFactory. + */ + default ProtoMessageFactory toProtoMessageFactory() { + return msgName -> { + Optional msgBuilder = DefaultMessageFactory.INSTANCE.newBuilder(msgName); + if (msgBuilder.isPresent()) { + return msgBuilder; // Bypass custom factory and return well known type with our own + // descriptor. + } + + return Optional.ofNullable(newBuilder(msgName)); + }; + } + + /** + * The {@code CombinedMessageFactory} takes one or more {@code MessageFactory} instances and + * attempts to create a {@code Message.Builder} instance for a given {@code messageName} by + * calling each {@code MessageFactory} in the order that they are provided to the constructor. + */ + @Immutable + final class CombinedMessageFactory implements MessageFactory { + + private final ImmutableList messageFactories; + + public CombinedMessageFactory(Iterable messageFactories) { + this.messageFactories = ImmutableList.copyOf(messageFactories); + } + + @Override + public Message.@Nullable Builder newBuilder(String messageName) { + for (MessageFactory messageFactory : messageFactories) { + Message.Builder builder = messageFactory.newBuilder(messageName); + if (builder != null) { + return builder; + } + } + return null; + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/MessageProvider.java b/runtime/src/main/java/dev/cel/runtime/MessageProvider.java new file mode 100644 index 000000000..b92f2a668 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/MessageProvider.java @@ -0,0 +1,39 @@ +// Copyright 2022 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 dev.cel.common.annotations.Internal; +import java.util.Map; + +/** + * An object which allows to create and interpret messages. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public interface MessageProvider { + + /** Create a message based on the fully qualified message name and field-value mapping. */ + Object createMessage(String messageName, Map values); + + /** Select field from message. */ + Object selectField(Object message, String fieldName); + + /** Check whether a field is set on message. */ + Object hasField(Object message, String fieldName); + + /** Adapt object to its message value with source location metadata on failure. */ + Object adapt(String messageName, Object message); +} diff --git a/runtime/src/main/java/dev/cel/runtime/Metadata.java b/runtime/src/main/java/dev/cel/runtime/Metadata.java new file mode 100644 index 000000000..05d60768c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/Metadata.java @@ -0,0 +1,39 @@ +// Copyright 2022 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; + +/** + * An interface which provides metadata for syntax nodes. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public interface Metadata { + + /** Returns the location (like a filename) of the interpreted expression. */ + String getLocation(); + + /** + * Returns the character position of the node in the source. This is a 0-based character offset. + */ + int getPosition(long exprId); + + /** Checks if a source position recorded for the provided expression id. */ + boolean hasPosition(long exprId); +} diff --git a/runtime/src/main/java/dev/cel/runtime/OptimizedFunctionOverload.java b/runtime/src/main/java/dev/cel/runtime/OptimizedFunctionOverload.java new file mode 100644 index 000000000..fde8bcc15 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/OptimizedFunctionOverload.java @@ -0,0 +1,35 @@ +// 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; + +/** + * Internal interface to support fast-path Unary and Binary evaluations, avoiding Object[] + * allocation. + */ +@Immutable +interface OptimizedFunctionOverload extends CelFunctionOverload { + + /** Fast-path for unary function execution to avoid Object[] allocation. */ + default Object apply(Object arg) throws CelEvaluationException { + return apply(new Object[] {arg}); + } + + /** Fast-path for binary function execution to avoid Object[] allocation. */ + default Object apply(Object arg1, Object arg2) throws CelEvaluationException { + return apply(new Object[] {arg1, arg2}); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/PartialVars.java b/runtime/src/main/java/dev/cel/runtime/PartialVars.java new file mode 100644 index 000000000..f195880d0 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/PartialVars.java @@ -0,0 +1,75 @@ +// 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.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import java.util.Map; +import java.util.Optional; + +/** + * A holder for a {@link CelVariableResolver} and a set of {@link CelAttributePattern}s that + * indicate variables or parts of variables whose value are not yet known. + */ +@AutoValue +public abstract class PartialVars { + + /** The resolver to use for resolving evaluation variables. */ + public abstract CelVariableResolver resolver(); + + /** + * A list of attribute patterns specifying which missing attribute paths should be tracked as + * unknown values. + */ + public abstract ImmutableList unknowns(); + + /** Constructs a new {@code PartialVars} from one or more {@link CelAttributePattern}s. */ + public static PartialVars of(CelAttributePattern... unknownAttributes) { + return of(ImmutableList.copyOf(unknownAttributes)); + } + + /** Constructs a new {@code PartialVars} from a list of {@link CelAttributePattern}s. */ + public static PartialVars of(Iterable unknownAttributes) { + return of((unused) -> Optional.empty(), unknownAttributes); + } + + /** + * Constructs a new {@code PartialVars} from a {@link CelVariableResolver} and a list of {@link + * CelAttributePattern}s. + */ + public static PartialVars of( + CelVariableResolver resolver, Iterable unknownAttributes) { + return new AutoValue_PartialVars(resolver, ImmutableList.copyOf(unknownAttributes)); + } + + /** + * Constructs a new {@code PartialVars} from a map of variables and an array of {@link + * CelAttributePattern}s. + */ + public static PartialVars of(Map variables, CelAttributePattern... unknownAttributes) { + return of( + (name) -> variables.containsKey(name) ? Optional.of(variables.get(name)) : Optional.empty(), + unknownAttributes); + } + + /** + * Constructs a new {@code PartialVars} from a {@link CelVariableResolver} and an array of {@link + * CelAttributePattern}s. + */ + public static PartialVars of( + CelVariableResolver resolver, CelAttributePattern... unknownAttributes) { + return of(resolver, ImmutableList.copyOf(unknownAttributes)); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/Program.java b/runtime/src/main/java/dev/cel/runtime/Program.java new file mode 100644 index 000000000..e808a373c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/Program.java @@ -0,0 +1,49 @@ +// Copyright 2025 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 java.util.Map; + +/** Creates an evaluable {@code Program} instance which is thread-safe and immutable. */ +@Immutable +public interface Program { + + /** Evaluate the expression without any variables. */ + Object eval() throws CelEvaluationException; + + /** Evaluate the expression using a {@code mapValue} as the source of input variables. */ + Object eval(Map mapValue) throws CelEvaluationException; + + /** + * Evaluate a compiled program with {@code mapValue} and late-bound functions {@code + * lateBoundFunctionResolver}. + */ + Object eval(Map mapValue, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException; + + /** Evaluate a compiled program with a custom variable {@code resolver}. */ + Object eval(CelVariableResolver resolver) throws CelEvaluationException; + + /** + * Evaluate a compiled program with a custom variable {@code resolver} and late-bound functions + * {@code lateBoundFunctionResolver}. + */ + Object eval(CelVariableResolver resolver, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException; + + /** Evaluate a compiled program with unknown attribute patterns {@code partialVars}. */ + Object eval(PartialVars partialVars) throws CelEvaluationException; +} diff --git a/runtime/src/main/java/dev/cel/runtime/ProgramImpl.java b/runtime/src/main/java/dev/cel/runtime/ProgramImpl.java new file mode 100644 index 000000000..2543a9525 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/ProgramImpl.java @@ -0,0 +1,201 @@ +// Copyright 2025 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.auto.value.AutoValue; +import com.google.common.base.Preconditions; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Message; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelRuntime.Program; +import java.util.Map; +import java.util.Optional; + +/** Internal implementation of a {@link CelRuntime.Program} */ +@AutoValue +@Immutable +abstract class ProgramImpl implements CelRuntime.Program { + + @Override + public Object eval() throws CelEvaluationException { + return evalInternal(Activation.EMPTY); + } + + @Override + public Object eval(Map mapValue) throws CelEvaluationException { + return evalInternal(Activation.copyOf(mapValue)); + } + + @Override + public Object eval(Message message) throws CelEvaluationException { + return evalInternal(ProtoMessageActivationFactory.fromProto(message, getOptions())); + } + + @Override + public Object eval(CelVariableResolver resolver) throws CelEvaluationException { + return evalInternal((name) -> resolver.find(name).orElse(null)); + } + + @Override + public Object eval(CelVariableResolver resolver, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException { + return evalInternal((name) -> resolver.find(name).orElse(null), lateBoundFunctionResolver); + } + + @Override + public Object eval(Map mapValue, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException { + return evalInternal(Activation.copyOf(mapValue), lateBoundFunctionResolver); + } + + @Override + public Object eval(PartialVars partialVars) throws CelEvaluationException { + return evalInternal( + UnknownContext.create(partialVars.resolver(), partialVars.unknowns()), + /* lateBoundFunctionResolver= */ Optional.empty(), + /* listener= */ Optional.empty()); + } + + @Override + public Object trace(CelEvaluationListener listener) throws CelEvaluationException { + return evalInternal(Activation.EMPTY, listener); + } + + @Override + public Object trace(Map mapValue, CelEvaluationListener listener) + throws CelEvaluationException { + return evalInternal(Activation.copyOf(mapValue), listener); + } + + @Override + public Object trace(Message message, CelEvaluationListener listener) + throws CelEvaluationException { + return evalInternal(ProtoMessageActivationFactory.fromProto(message, getOptions()), listener); + } + + @Override + public Object trace(CelVariableResolver resolver, CelEvaluationListener listener) + throws CelEvaluationException { + return evalInternal((name) -> resolver.find(name).orElse(null), listener); + } + + @Override + public Object trace( + CelVariableResolver resolver, + CelFunctionResolver lateBoundFunctionResolver, + CelEvaluationListener listener) + throws CelEvaluationException { + return evalInternal( + (name) -> resolver.find(name).orElse(null), lateBoundFunctionResolver, listener); + } + + @Override + public Object trace( + Map mapValue, + CelFunctionResolver lateBoundFunctionResolver, + CelEvaluationListener listener) + throws CelEvaluationException { + return evalInternal(Activation.copyOf(mapValue), lateBoundFunctionResolver, listener); + } + + @Override + public Object trace(PartialVars partialVars, CelEvaluationListener listener) + throws CelEvaluationException { + return evalInternal( + UnknownContext.create(partialVars.resolver(), partialVars.unknowns()), + /* lateBoundFunctionResolver= */ Optional.empty(), + Optional.of(listener)); + } + + @Override + public Object advanceEvaluation(UnknownContext context) throws CelEvaluationException { + return evalInternal(context, Optional.empty(), Optional.empty()); + } + + private Object evalInternal(GlobalResolver resolver) throws CelEvaluationException { + return evalInternal(UnknownContext.create(resolver), Optional.empty(), Optional.empty()); + } + + private Object evalInternal(GlobalResolver resolver, CelEvaluationListener listener) + throws CelEvaluationException { + return evalInternal(UnknownContext.create(resolver), Optional.empty(), Optional.of(listener)); + } + + private Object evalInternal(GlobalResolver resolver, CelFunctionResolver functionResolver) + throws CelEvaluationException { + return evalInternal( + UnknownContext.create(resolver), Optional.of(functionResolver), Optional.empty()); + } + + private Object evalInternal( + GlobalResolver resolver, + CelFunctionResolver lateBoundFunctionResolver, + CelEvaluationListener listener) + throws CelEvaluationException { + return evalInternal( + UnknownContext.create(resolver), + Optional.of(lateBoundFunctionResolver), + Optional.of(listener)); + } + + /** + * Evaluate an expr node with an UnknownContext (an activation annotated with which attributes are + * unknown). + */ + private Object evalInternal( + UnknownContext context, + Optional lateBoundFunctionResolver, + Optional listener) + throws CelEvaluationException { + Interpretable impl = getInterpretable(); + if (getOptions().enableUnknownTracking()) { + Preconditions.checkState( + impl instanceof UnknownTrackingInterpretable, + "Environment misconfigured. Requested unknown tracking without a compatible" + + " implementation."); + + UnknownTrackingInterpretable interpreter = (UnknownTrackingInterpretable) impl; + return interpreter.evalTrackingUnknowns( + RuntimeUnknownResolver.builder() + .setResolver(context.variableResolver()) + .setAttributeResolver(context.createAttributeResolver()) + .build(), + lateBoundFunctionResolver, + listener); + } else { + if (lateBoundFunctionResolver.isPresent() && listener.isPresent()) { + return impl.eval( + context.variableResolver(), lateBoundFunctionResolver.get(), listener.get()); + } else if (lateBoundFunctionResolver.isPresent()) { + return impl.eval(context.variableResolver(), lateBoundFunctionResolver.get()); + } else if (listener.isPresent()) { + return impl.eval(context.variableResolver(), listener.get()); + } + + return impl.eval(context.variableResolver()); + } + } + + /** Get the underlying {@link Interpretable} for the {@code Program}. */ + abstract Interpretable getInterpretable(); + + /** Get the {@code CelOptions} configured for this program. */ + abstract CelOptions getOptions(); + + /** Instantiate a new {@code Program} from the input {@code interpretable}. */ + static Program from(Interpretable interpretable, CelOptions options) { + return new AutoValue_ProgramImpl(interpretable, options); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/ProtoMessageActivationFactory.java b/runtime/src/main/java/dev/cel/runtime/ProtoMessageActivationFactory.java new file mode 100644 index 000000000..fb42a1964 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/ProtoMessageActivationFactory.java @@ -0,0 +1,74 @@ +// Copyright 2025 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.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.Message; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.internal.ProtoAdapter; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** Package-private factory to facilitate binding a full protobuf message into an activation. */ +final class ProtoMessageActivationFactory { + + /** + * Creates an {@code Activation} from a {@code Message} where each field in the message is exposed + * as a top-level variable in the {@code Activation}. + * + *

Unset message fields are published with the default value for the field type. However, an + * unset {@code google.protobuf.Any} value is not a valid CEL value, and will be published as an + * {@code Exception} value on the {@code Activation} just as though an unset {@code Any} would if + * it were accessed during a CEL evaluation. + */ + public static Activation fromProto(Message message, CelOptions celOptions) { + Map variables = new HashMap<>(); + Map msgFieldValues = message.getAllFields(); + + ProtoAdapter protoAdapter = + new ProtoAdapter(DynamicProto.create(DefaultMessageFactory.INSTANCE), celOptions); + + boolean skipUnsetFields = + celOptions.fromProtoUnsetFieldOption().equals(CelOptions.ProtoUnsetFieldOptions.SKIP); + + for (FieldDescriptor field : message.getDescriptorForType().getFields()) { + // If skipping unset fields and the field is not repeated, then continue. + if (skipUnsetFields && !field.isRepeated() && !msgFieldValues.containsKey(field)) { + continue; + } + + // Get the value of the field set on the message, if present, otherwise use reflection to + // get the default value for the field using the FieldDescriptor. + Object fieldValue = msgFieldValues.getOrDefault(field, message.getField(field)); + try { + Optional adapted = protoAdapter.adaptFieldToValue(field, fieldValue); + variables.put(field.getName(), adapted.orElse(null)); + } catch (IllegalArgumentException e) { + variables.put( + field.getName(), + CelEvaluationExceptionBuilder.newBuilder( + "illegal field value. field=%s, value=%s", field.getName(), fieldValue) + .setCause(e) + .build()); + } + } + return Activation.copyOf(variables); + } + + private ProtoMessageActivationFactory() {} +} diff --git a/runtime/src/main/java/dev/cel/runtime/ProtoMessageRuntimeEquality.java b/runtime/src/main/java/dev/cel/runtime/ProtoMessageRuntimeEquality.java new file mode 100644 index 000000000..25a090081 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/ProtoMessageRuntimeEquality.java @@ -0,0 +1,70 @@ +// Copyright 2025 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 com.google.protobuf.Message; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.internal.ProtoEquality; +import java.util.Objects; + +/** + * ProtoMessageRuntimeEquality contains methods for performing CEL related equality checks, + * including full protobuf messages by leveraging descriptors. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +@Immutable +public final class ProtoMessageRuntimeEquality extends RuntimeEquality { + + private final ProtoEquality protoEquality; + + @Internal + public static ProtoMessageRuntimeEquality create( + DynamicProto dynamicProto, CelOptions celOptions) { + return new ProtoMessageRuntimeEquality(dynamicProto, celOptions); + } + + @Override + public boolean objectEquals(Object x, Object y) { + if (celOptions.disableCelStandardEquality()) { + return Objects.equals(x, y); + } + if (x == y) { + return true; + } + + if (celOptions.enableProtoDifferencerEquality()) { + x = runtimeHelpers.adaptValue(x); + y = runtimeHelpers.adaptValue(y); + if (x instanceof Message) { + if (!(y instanceof Message)) { + return false; + } + return protoEquality.equals((Message) x, (Message) y); + } + } + + return super.objectEquals(x, y); + } + + private ProtoMessageRuntimeEquality(DynamicProto dynamicProto, CelOptions celOptions) { + super(ProtoMessageRuntimeHelpers.create(dynamicProto, celOptions), celOptions); + this.protoEquality = new ProtoEquality(dynamicProto); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/ProtoMessageRuntimeHelpers.java b/runtime/src/main/java/dev/cel/runtime/ProtoMessageRuntimeHelpers.java new file mode 100644 index 000000000..85acd373c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/ProtoMessageRuntimeHelpers.java @@ -0,0 +1,65 @@ +// Copyright 2025 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.protobuf.Message; +import com.google.protobuf.MessageLiteOrBuilder; +import com.google.protobuf.MessageOrBuilder; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.internal.ProtoAdapter; + +/** + * Helper methods for common CEL related routines that require a full protobuf dependency. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class ProtoMessageRuntimeHelpers extends RuntimeHelpers { + + private final ProtoAdapter protoAdapter; + + @Internal + public static ProtoMessageRuntimeHelpers create( + DynamicProto dynamicProto, CelOptions celOptions) { + return new ProtoMessageRuntimeHelpers(new ProtoAdapter(dynamicProto, celOptions)); + } + + /** + * Adapts a {@code protobuf.Message} to a plain old Java object. + * + *

Well-known protobuf types (wrappers, JSON types) are unwrapped to Java native object + * representations. + * + *

If the incoming {@code obj} is of type {@code google.protobuf.Any} the object is unpacked + * and the proto within is passed to the {@code adaptProtoToValue} method again to ensure the + * message contained within the Any is properly unwrapped if it is a well-known protobuf type. + */ + @Override + Object adaptProtoToValue(MessageLiteOrBuilder obj) { + if (obj instanceof Message) { + return protoAdapter.adaptProtoToValue((MessageOrBuilder) obj); + } + if (obj instanceof Message.Builder) { + return protoAdapter.adaptProtoToValue(((Message.Builder) obj).build()); + } + return obj; + } + + private ProtoMessageRuntimeHelpers(ProtoAdapter protoAdapter) { + this.protoAdapter = protoAdapter; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/Registrar.java b/runtime/src/main/java/dev/cel/runtime/Registrar.java new file mode 100644 index 000000000..467a7c426 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/Registrar.java @@ -0,0 +1,56 @@ +// Copyright 2022 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 java.util.List; + +/** + * An object which registers the functions that a {@link Dispatcher} calls. + * + * @deprecated Do not use. This interface exists solely for legacy async stack compatibility + * reasons. + */ +@Deprecated +public interface Registrar { + + /** Interface describing the general signature of all CEL custom function implementations. */ + @Immutable + interface Function extends CelFunctionOverload {} + + /** + * Helper interface for describing unary functions where the type-parameter is used to improve + * compile-time correctness of function bindings. + */ + @Immutable + interface UnaryFunction extends CelFunctionOverload.Unary {} + + /** + * Helper interface for describing binary functions where the type parameters are used to improve + * compile-time correctness of function bindings. + */ + @Immutable + interface BinaryFunction extends CelFunctionOverload.Binary {} + + /** Adds a unary function to the dispatcher. */ + void add(String overloadId, Class argType, UnaryFunction function); + + /** Adds a binary function to the dispatcher. */ + void add( + String overloadId, Class argType1, Class argType2, BinaryFunction function); + + /** Adds a general function to the dispatcher. */ + void add(String overloadId, List> argTypes, Function function); +} diff --git a/runtime/src/main/java/dev/cel/runtime/RuntimeEquality.java b/runtime/src/main/java/dev/cel/runtime/RuntimeEquality.java new file mode 100644 index 000000000..56a8761cd --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/RuntimeEquality.java @@ -0,0 +1,283 @@ +// Copyright 2022 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.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.MessageLiteOrBuilder; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelAttributeNotFoundException; +import dev.cel.common.internal.ComparisonFunctions; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; + +/** RuntimeEquality contains methods for performing CEL related equality checks. */ +@Immutable +@Internal +public class RuntimeEquality { + protected final RuntimeHelpers runtimeHelpers; + protected final CelOptions celOptions; + + public static RuntimeEquality create(RuntimeHelpers runtimeHelper, CelOptions celOptions) { + return new RuntimeEquality(runtimeHelper, celOptions); + } + + // Functions + // ========= + + /** Determine whether the {@code list} contains the given {@code value}. */ + public boolean inList(List list, A value) { + if (list.contains(value)) { + return true; + } + if (value instanceof Number) { + for (A elem : list) { + if (objectEquals(elem, value)) { + return true; + } + } + } + return false; + } + + /** Bound-checked indexing of maps. */ + @SuppressWarnings("unchecked") + public B indexMap(Map map, A index) { + Optional value = findInMap(map, index); + // Use this method rather than the standard 'orElseThrow' method because of the unchecked cast. + if (value.isPresent()) { + return (B) value.get(); + } + + throw CelAttributeNotFoundException.of(index.toString()); + } + + /** Determine whether the {@code map} contains the given {@code key}. */ + public boolean inMap(Map map, A key) { + return findInMap(map, key).isPresent(); + } + + public Optional findInMap(Map map, Object index) { + if (celOptions.disableCelStandardEquality()) { + return Optional.ofNullable(map.get(index)); + } + + if (index instanceof MessageLiteOrBuilder) { + index = runtimeHelpers.adaptProtoToValue((MessageLiteOrBuilder) index); + } + Object v = map.get(index); + if (v != null) { + return Optional.of(v); + } + if (index instanceof Long) { + return longToUnsignedLossless((Long) index).map(map::get); + } else if (index instanceof UnsignedLong) { + return unsignedToLongLossless((UnsignedLong) index).map(map::get); + } else if (index instanceof Number) { + Number numberIndex = (Number) index; + Optional indexValue = RuntimeHelpers.doubleToLongLossless(numberIndex).map(map::get); + // Early return rather than use 'or()' since or is not JDK 1.8 compatible. + if (indexValue.isPresent()) { + return indexValue; + } + return doubleToUnsignedLossless(numberIndex).map(map::get); + } + return Optional.empty(); + } + + // Object equality + // =================== + + /** + * CEL implements homogeneous equality where two values are only comparable if they have the same + * type, otherwise an error is thrown. + * + *

If the values are of different type, the comparison fails with an error. For aggregate + * types, equality + * + *

If lists are of different length, return false, otherwise take the CEL logical AND of + * homogeneous equality of the elements by list position: + * + *

    + *
  • If any element comparison returns false, the list comparison returns false. + *
  • Otherwise, if all element comparisons return true, the list comparison returns true. + *
  • Otherwise, there are one or more errors, one of which is re-thrown. + *
+ * + *

If maps have different key sets, return false, otherwise take the CEL logical AND of + * homogeneous equality of the values by map key: + * + *

    + *
  • If any value comparison returns false, the map comparison returns false. + *
  • Otherwise, if all value comparisons return true, the map comparison returns true. + *
  • Otherwise, there are one or more errors, one of which is re-thrown. + *
+ * + *

Heterogeneous equality differs from homogeneous equality in that two objects may be + * comparable even if they are not of the same type, where type differences are usually trivially + * false. + */ + @SuppressWarnings({"rawtypes", "unchecked"}) + public boolean objectEquals(Object x, Object y) { + if (celOptions.disableCelStandardEquality()) { + return Objects.equals(x, y); + } + if (x == y) { + return true; + } + x = runtimeHelpers.adaptValue(x); + y = runtimeHelpers.adaptValue(y); + if (x instanceof Number) { + if (!(y instanceof Number)) { + return false; + } + return ComparisonFunctions.numericEquals((Number) x, (Number) y); + } + if (celOptions.enableProtoDifferencerEquality()) { + if (x instanceof MessageLiteOrBuilder) { + if (!(y instanceof MessageLiteOrBuilder)) { + return false; + } + // TODO: Implement when CelLiteDescriptor is available + throw new UnsupportedOperationException( + "Proto Differencer equality is not supported for MessageLite."); + } + } + if (x instanceof Iterable) { + if (!(y instanceof Iterable)) { + return false; + } + Iterable xIter = (Iterable) x; + Iterable yIter = (Iterable) y; + Iterator yElems = yIter.iterator(); + IllegalArgumentException e = null; + for (Object xElem : xIter) { + if (!yElems.hasNext()) { + return false; + } + try { + if (!objectEquals(xElem, yElems.next())) { + return false; + } + } catch (IllegalArgumentException iae) { + e = iae; + } + } + if (yElems.hasNext()) { + return false; + } + if (e != null) { + throw e; + } + return true; + } + if (x instanceof Map) { + if (!(y instanceof Map)) { + return false; + } + Map xMap = (Map) x; + Map yMap = (Map) y; + if (xMap.size() != yMap.size()) { + return false; + } + IllegalArgumentException e = null; + Set entrySet = xMap.entrySet(); + for (Map.Entry xEntry : entrySet) { + Optional yVal = findInMap(yMap, xEntry.getKey()); + // Use isPresent() rather than isEmpty() to stay backwards compatible with Java 8. + if (!yVal.isPresent()) { + return false; + } + try { + if (!objectEquals(xEntry.getValue(), yVal.get())) { + return false; + } + } catch (IllegalArgumentException iae) { + e = iae; + } + } + if (e != null) { + throw e; + } + return true; + } + return Objects.equals(x, y); + } + + /** + * Returns the hash code consistent with the {@link #objectEquals(Object, Object)} method. For + * example, {@code hashCode(1) == hashCode(1.0)} since {@code objectEquals(1, 1.0)} is true. + */ + public int hashCode(Object object) { + if (object == null) { + return 0; + } + + if (celOptions.disableCelStandardEquality()) { + return Objects.hashCode(object); + } + + object = runtimeHelpers.adaptValue(object); + if (object instanceof Number) { + return Double.hashCode(((Number) object).doubleValue()); + } + if (object instanceof Iterable) { + int h = 1; + Iterable iter = (Iterable) object; + for (Object elem : iter) { + h = h * 31 + hashCode(elem); + } + return h; + } + if (object instanceof Map) { + int h = 0; + for (Map.Entry entry : ((Map) object).entrySet()) { + h += hashCode(entry.getKey()) ^ hashCode(entry.getValue()); + } + return h; + } + return Objects.hashCode(object); + } + + private static Optional doubleToUnsignedLossless(Number v) { + Optional conv = RuntimeHelpers.doubleToUnsignedChecked(v.doubleValue()); + return conv.map(ul -> ul.longValue() == v.doubleValue() ? ul : null); + } + + private static Optional longToUnsignedLossless(long v) { + if (v >= 0) { + return Optional.of(UnsignedLong.valueOf(v)); + } + return Optional.empty(); + } + + private static Optional unsignedToLongLossless(UnsignedLong v) { + if (v.compareTo(UnsignedLong.valueOf(Long.MAX_VALUE)) <= 0) { + return Optional.of(v.longValue()); + } + return Optional.empty(); + } + + RuntimeEquality(RuntimeHelpers runtimeHelpers, CelOptions celOptions) { + this.runtimeHelpers = runtimeHelpers; + this.celOptions = celOptions; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/RuntimeHelpers.java b/runtime/src/main/java/dev/cel/runtime/RuntimeHelpers.java new file mode 100644 index 000000000..0ee7824b7 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/RuntimeHelpers.java @@ -0,0 +1,406 @@ +// Copyright 2022 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 static com.google.common.base.Preconditions.checkArgument; + +import com.google.common.primitives.Ints; +import com.google.common.primitives.UnsignedLong; +import com.google.common.primitives.UnsignedLongs; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Duration; +import com.google.protobuf.MessageLiteOrBuilder; +import com.google.re2j.Pattern; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelDivideByZeroException; +import dev.cel.common.exceptions.CelIndexOutOfBoundsException; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.common.internal.Converter; +import dev.cel.common.values.NullValue; +import java.time.format.DateTimeParseException; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import org.threeten.extra.AmountFormats; + +/** + * Helper methods for common CEL related routines. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public class RuntimeHelpers { + + // Maximum and minimum range supported by protobuf Duration values. + private static final java.time.Duration DURATION_MAX = java.time.Duration.ofDays(3652500); + private static final java.time.Duration DURATION_MIN = DURATION_MAX.negated(); + + public static RuntimeHelpers create() { + return new RuntimeHelpers(); + } + + // Functions + // ========= + + /** Convert a string to a Protobuf Duration. */ + public static Duration createDurationFromString(String d) { + java.time.Duration dv = createJavaDurationFromString(d); + return Duration.newBuilder().setSeconds(dv.getSeconds()).setNanos(dv.getNano()).build(); + } + + /** Convert a string to a native Java Duration. */ + public static java.time.Duration createJavaDurationFromString(String d) { + try { + java.time.Duration dv = AmountFormats.parseUnitBasedDuration(d); + // Ensure that the duration value can be adequately represented within a protobuf.Duration. + checkArgument( + dv.compareTo(DURATION_MAX) <= 0 && dv.compareTo(DURATION_MIN) >= 0, + "invalid duration range"); + return dv; + } catch (DateTimeParseException e) { + throw new IllegalArgumentException("invalid duration format", e); + } + } + + public static boolean matches(String string, String regexp, CelOptions celOptions) { + Pattern pattern = Pattern.compile(regexp); + int maxProgramSize = celOptions.maxRegexProgramSize(); + if (maxProgramSize >= 0 && pattern.programSize() > maxProgramSize) { + throw new IllegalArgumentException( + String.format( + "Regex pattern exceeds allowed program size. Allowed: %d, Provided: %d", + maxProgramSize, pattern.programSize())); + } + + if (!celOptions.enableRegexPartialMatch()) { + // Uses re2 for consistency across languages. + return pattern.matcher(string).matches(); + } + + // Return an unanchored match for the presence of the regexp anywhere in the string. + return pattern.matcher(string).find(); + } + + /** Concatenates two lists into a new list. */ + public static List concat(List first, List second) { + if (first instanceof ConcatenatedListView) { + // Comprehensions use a more efficient list view for performing O(1) concatenation + first.addAll(second); + return first; + } + + List result = new ArrayList<>(first.size() + second.size()); + result.addAll(first); + result.addAll(second); + return result; + } + + // Collections + // =========== + + /** Bound-checked indexing of lists. */ + public static A indexList(List list, Number index) { + if (index instanceof Double) { + return doubleToLongLossless(index.doubleValue()) + .map(v -> indexList(list, v)) + .orElseThrow(() -> new CelIndexOutOfBoundsException(index.doubleValue())); + } + int castIndex = Ints.checkedCast(index.longValue()); + if (castIndex < 0 || castIndex >= list.size()) { + throw new CelIndexOutOfBoundsException(castIndex); + } + return list.get(castIndex); + } + + // Integer Arithmetic + // ================== + // + // CEL requires exceptions to be thrown when int arithmetic exceeds the represented range. + + public static long int64Add(long x, long y, CelOptions celOptions) { + if (celOptions.errorOnIntWrap()) { + return Math.addExact(x, y); + } + return x + y; + } + + public static long int64Divide(long x, long y, CelOptions celOptions) { + if (celOptions.errorOnIntWrap() && x == Long.MIN_VALUE && y == -1) { + throw new CelNumericOverflowException("most negative number wraps"); + } + return x / y; + } + + public static long int64Multiply(long x, long y, CelOptions celOptions) { + if (celOptions.errorOnIntWrap()) { + return Math.multiplyExact(x, y); + } + return x * y; + } + + public static long int64Negate(long x, CelOptions celOptions) { + if (celOptions.errorOnIntWrap()) { + return Math.negateExact(x); + } + return -x; + } + + public static long int64Subtract(long x, long y, CelOptions celOptions) { + if (celOptions.errorOnIntWrap()) { + return Math.subtractExact(x, y); + } + return x - y; + } + + // Unsigned Arithmetic + // =================== + + // Some arithmetic for unsigned longs cannot be handled via signed longs. + // See + // http://stackoverflow.com/questions/14063599/why-are-signed-and-unsigned-multiplication-different-instructions-on-x86-64 + + // We need to use UnsignedLong.fromLongBits() rather than UnsignedLong.valueOf(). The later only + // works for signed long values that are greater than or equal to 0. The former reinterprets the + // long as unsigned, using the bits as is. + + public static long uint64Add(long x, long y, CelOptions celOptions) { + if (celOptions.errorOnIntWrap()) { + if (x < 0 && y < 0) { + // Both numbers are in the upper half of the range, so it must overflow. + throw new CelNumericOverflowException("range overflow on unsigned addition"); + } + long z = x + y; + if ((x < 0 || y < 0) && z >= 0) { + // Only one number is in the upper half of the range. It overflows if the result + // is not in the upper half. + throw new CelNumericOverflowException("range overflow on unsigned addition"); + } + return z; + } + return x + y; + } + + public static UnsignedLong uint64Add(UnsignedLong x, UnsignedLong y) { + if (x.compareTo(UnsignedLong.MAX_VALUE.minus(y)) > 0) { + throw new CelNumericOverflowException("range overflow on unsigned addition"); + } + return x.plus(y); + } + + public static int uint64CompareTo(long x, long y, CelOptions celOptions) { + return celOptions.enableUnsignedComparisonAndArithmeticIsUnsigned() + ? UnsignedLongs.compare(x, y) + : UnsignedLong.valueOf(x).compareTo(UnsignedLong.valueOf(y)); + } + + static int uint64CompareTo(long x, long y) { + // Features is set to empty, as this class is public and the build visibility is public. + // Existing callers expect legacy behavior. + return uint64CompareTo(x, y, CelOptions.LEGACY); + } + + public static int uint64CompareTo(UnsignedLong x, UnsignedLong y) { + return x.compareTo(y); + } + + public static long uint64Divide(long x, long y, CelOptions celOptions) { + try { + return celOptions.enableUnsignedComparisonAndArithmeticIsUnsigned() + ? UnsignedLongs.divide(x, y) + : UnsignedLong.valueOf(x).dividedBy(UnsignedLong.valueOf(y)).longValue(); + } catch (ArithmeticException e) { + throw new CelDivideByZeroException(e); + } + } + + static long uint64Divide(long x, long y) { + // Features is set to empty, as this class is public and the build visibility is public. + // Existing callers expect legacy behavior. + return uint64Divide(x, y, CelOptions.LEGACY); + } + + public static UnsignedLong uint64Divide(UnsignedLong x, UnsignedLong y) { + if (y.equals(UnsignedLong.ZERO)) { + throw new CelDivideByZeroException(); + } + return x.dividedBy(y); + } + + public static long uint64Mod(long x, long y, CelOptions celOptions) { + try { + return celOptions.enableUnsignedComparisonAndArithmeticIsUnsigned() + ? UnsignedLongs.remainder(x, y) + : UnsignedLong.valueOf(x).mod(UnsignedLong.valueOf(y)).longValue(); + } catch (ArithmeticException e) { + throw new CelDivideByZeroException(e); + } + } + + public static UnsignedLong uint64Mod(UnsignedLong x, UnsignedLong y) { + if (y.equals(UnsignedLong.ZERO)) { + throw new CelDivideByZeroException(); + } + return x.mod(y); + } + + static long uint64Mod(long x, long y) { + // Features is set to empty, as this class is public and the build visibility is public. + // Existing callers expect legacy behavior. + return uint64Mod(x, y, CelOptions.LEGACY); + } + + public static long uint64Multiply(long x, long y, CelOptions celOptions) { + long z = + celOptions.enableUnsignedComparisonAndArithmeticIsUnsigned() + ? x * y + : UnsignedLong.valueOf(x).times(UnsignedLong.valueOf(y)).longValue(); + if (celOptions.errorOnIntWrap() && y != 0 && Long.divideUnsigned(z, y) != x) { + throw new CelNumericOverflowException("multiply out of unsigned integer range"); + } + return z; + } + + static long uint64Multiply(long x, long y) { + // Features is set to empty, as this class is public and the build visibility is public. + // Existing callers expect legacy behavior. + return uint64Multiply(x, y, CelOptions.LEGACY); + } + + public static UnsignedLong uint64Multiply(UnsignedLong x, UnsignedLong y) { + if (!y.equals(UnsignedLong.ZERO) && x.compareTo(UnsignedLong.MAX_VALUE.dividedBy(y)) > 0) { + throw new CelNumericOverflowException("multiply out of unsigned integer range"); + } + return x.times(y); + } + + public static long uint64Subtract(long x, long y, CelOptions celOptions) { + if (celOptions.errorOnIntWrap()) { + // Throw an overflow error if x < y, as unsigned longs. This happens if y has its high + // bit set and x does not, or if they have the same high bit and x < y as signed longs. + if ((x < 0 && y < 0 && x < y) || (x >= 0 && y >= 0 && x < y) || (x >= 0 && y < 0)) { + throw new CelNumericOverflowException("unsigned subtraction underflow"); + } + // fallthrough + } + return x - y; + } + + public static UnsignedLong uint64Subtract(UnsignedLong x, UnsignedLong y) { + // Throw an overflow error if x < y, as unsigned longs. This happens if y has its high + // bit set and x does not, or if they have the same high bit and x < y as signed longs. + if (x.compareTo(y) < 0) { + throw new CelNumericOverflowException("unsigned subtraction underflow"); + } + return x.minus(y); + } + + // Proto Type Adaption + // =================== + + // CEL unifies int32, int64, and enum, and float and double. Values selected or assigned to + // protobuf fields need to be adapted to CEL's simpler type system. For collections, we + // want to avoid to do this conversion eagerly, so we create views on the underlying data. + // The below code is the extensive boilerplate to do so. + + static Converter identity() { + return (A value) -> value; + } + + static final Converter INT32_TO_INT64 = Integer::longValue; + + static final Converter FLOAT_TO_DOUBLE = Float::doubleValue; + + static final Converter INT64_TO_INT32 = Ints::checkedCast; + + static final Converter DOUBLE_TO_FLOAT = Double::floatValue; + + /** Adapts a plain old Java object into a CEL value. */ + public Object adaptValue(Object value) { + if (value == null || value.equals(com.google.protobuf.NullValue.NULL_VALUE)) { + return NullValue.NULL_VALUE; + } + if (value instanceof Number) { + return maybeAdaptPrimitive(value); + } + if (value instanceof MessageLiteOrBuilder) { + return adaptProtoToValue((MessageLiteOrBuilder) value); + } + return value; + } + + /** Adapts a {@code Number} value to its appropriate CEL type. */ + static Object maybeAdaptPrimitive(Object value) { + if (value instanceof Optional) { + Optional optionalVal = (Optional) value; + if (!optionalVal.isPresent()) { + return optionalVal; + } + return Optional.of(maybeAdaptPrimitive(optionalVal.get())); + } + if (value instanceof Float) { + return FLOAT_TO_DOUBLE.convert((Float) value); + } + if (value instanceof Integer) { + return INT32_TO_INT64.convert((Integer) value); + } + return value; + } + + /** + * Adapts a {@code protobuf.Message} to a plain old Java object. + * + *

Well-known protobuf types (wrappers, JSON types) are unwrapped to Java native object + * representations. + * + *

If the incoming {@code obj} is of type {@code google.protobuf.Any} the object is unpacked + * and the proto within is passed to the {@code adaptProtoToValue} method again to ensure the + * message contained within the Any is properly unwrapped if it is a well-known protobuf type. + */ + Object adaptProtoToValue(MessageLiteOrBuilder obj) { + throw new UnsupportedOperationException("Not implemented yet"); + } + + public static Optional doubleToUnsignedChecked(double v) { + // getExponent of NaN or Infinite will return a Double.MAX_EXPONENT + 1 (or 128) + if (v < 0.0 || Math.getExponent(v) >= 64) { + return Optional.empty(); + } + if (v >= Math.scalb(1.0, 63)) { + // If in the upper range 2^63 <= arg < 2^64, move into the representable range for + // signed long, mod 2^64. Note that we cannot have a fractional part since + // there aren't enough mantissa bits, so we don't need to worry about rounding. + v -= Math.scalb(1.0, 64); + } + return Optional.of(UnsignedLong.fromLongBits((long) v)); + } + + public static Optional doubleToLongChecked(double v) { + // getExponent of NaN or Infinite values will return a Double.MAX_EXPONENT + 1 (or 128) + int exp = Math.getExponent(v); + if (exp >= 63 && v != Math.scalb(-1.0, 63)) { + return Optional.empty(); + } + return Optional.of((long) v); + } + + static Optional doubleToLongLossless(Number v) { + Optional conv = doubleToLongChecked(v.doubleValue()); + return conv.map(l -> l.doubleValue() == v.doubleValue() ? l : null); + } + + RuntimeHelpers() {} +} diff --git a/runtime/src/main/java/dev/cel/runtime/RuntimeTypeProvider.java b/runtime/src/main/java/dev/cel/runtime/RuntimeTypeProvider.java new file mode 100644 index 000000000..97e4f3af1 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/RuntimeTypeProvider.java @@ -0,0 +1,28 @@ +// Copyright 2022 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; + +/** + * The {@code RuntimeTypeProvider} is a combination of the {@code MessageProvider} and {@code + * TypeResolver} interfaces. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public interface RuntimeTypeProvider extends MessageProvider {} diff --git a/runtime/src/main/java/dev/cel/runtime/RuntimeUnknownResolver.java b/runtime/src/main/java/dev/cel/runtime/RuntimeUnknownResolver.java new file mode 100644 index 000000000..f14e75dd7 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/RuntimeUnknownResolver.java @@ -0,0 +1,234 @@ +// Copyright 2022 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.CanIgnoreReturnValue; +import dev.cel.common.annotations.Internal; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** + * Runtime representation of the current state in an iterative evaluation session. + * + *

This is used by the interpreter to coordinate identifying and tracking unknown values through + * evaluation. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public class RuntimeUnknownResolver { + private static final CelAttributeResolver DEFAULT_RESOLVER = new NullAttributeResolver(); + + /** The underlying resolver for known values. */ + private final GlobalResolver resolver; + + /** Resolver for unknown and resolved attributes. */ + private final CelAttributeResolver attributeResolver; + + private final boolean attributeTrackingEnabled; + + private RuntimeUnknownResolver( + GlobalResolver resolver, + CelAttributeResolver attributeResolver, + boolean attributeTrackingEnabled) { + this.resolver = resolver; + this.attributeResolver = attributeResolver; + this.attributeTrackingEnabled = attributeTrackingEnabled; + } + + public static RuntimeUnknownResolver fromResolver(GlobalResolver resolver) { + // This prevents calculating the attribute trail if it will never be used for + // efficiency, but doesn't change observable behavior. + return new RuntimeUnknownResolver( + resolver, DEFAULT_RESOLVER, /* attributeTrackingEnabled= */ false); + } + + public static Builder builder() { + return new Builder(); + } + + /** Builder for {@link RuntimeUnknownResolver}. */ + public static class Builder { + private CelAttributeResolver attributeResolver; + private GlobalResolver resolver; + + private Builder() { + resolver = GlobalResolver.EMPTY; + attributeResolver = DEFAULT_RESOLVER; + } + + @CanIgnoreReturnValue + public Builder setResolver(GlobalResolver resolver) { + this.resolver = resolver; + return this; + } + + @CanIgnoreReturnValue + public Builder setAttributeResolver(CelAttributeResolver resolver) { + attributeResolver = resolver; + return this; + } + + public RuntimeUnknownResolver build() { + return new RuntimeUnknownResolver(resolver, attributeResolver, true); + } + } + + /** + * Return a single element unknown set if the attribute is partially unknown based on the defined + * patterns. + */ + Optional maybePartialUnknown(CelAttribute attribute) { + CelUnknownSet unknownSet = attributeResolver.maybePartialUnknown(attribute).orElse(null); + return Optional.ofNullable(unknownSet).map(InterpreterUtil::adaptToAccumulatedUnknowns); + } + + /** Resolve a simple name to a value. */ + DefaultInterpreter.IntermediateResult resolveSimpleName(String name, Long exprId) { + // Strip leading dot if present (for global disambiguation). + if (name.startsWith(".")) { + name = name.substring(1); + } + + CelAttribute attr = CelAttribute.EMPTY; + + if (attributeTrackingEnabled) { + attr = CelAttribute.fromQualifiedIdentifier(name); + + Optional result = resolveAttribute(attr); + if (result.isPresent()) { + return DefaultInterpreter.IntermediateResult.create(attr, result.get()); + } + } + + Object result = resolver.resolve(name); + + return DefaultInterpreter.IntermediateResult.create( + attr, InterpreterUtil.valueOrUnknown(result, exprId)); + } + + void cacheLazilyEvaluatedResult(String name, DefaultInterpreter.IntermediateResult result) { + throw new IllegalStateException( + "Internal error: Lazy attributes can only be cached in ScopedResolver."); + } + + void declareLazyAttribute(String attrName) { + throw new IllegalStateException( + "Internal error: Lazy attributes can only be declared in ScopedResolver."); + } + + /** + * Attempt to resolve an attribute bound to a context variable. This is used to shadow lazily + * resolved values behind field accesses and index operations. + */ + Optional resolveAttribute(CelAttribute attr) { + Object resolved = attributeResolver.resolve(attr).orElse(null); + return Optional.ofNullable(resolved).map(InterpreterUtil::maybeAdaptToAccumulatedUnknowns); + } + + ScopedResolver withScope(Map vars) { + return new ScopedResolver(this, vars); + } + + static final class ScopedResolver extends RuntimeUnknownResolver { + private final RuntimeUnknownResolver parent; + private final Map shadowedVars; + private final Map lazyEvalResultCache; + + private ScopedResolver( + RuntimeUnknownResolver parent, + Map shadowedVars) { + super(parent.resolver, parent.attributeResolver, parent.attributeTrackingEnabled); + this.parent = parent; + this.shadowedVars = shadowedVars; + this.lazyEvalResultCache = new HashMap<>(); + } + + @Override + DefaultInterpreter.IntermediateResult resolveSimpleName(String name, Long exprId) { + // A name with a leading '.' always resolves in the root scope + if (name.startsWith(".")) { + return parent.resolveSimpleName(name, exprId); + } + DefaultInterpreter.IntermediateResult result = lazyEvalResultCache.get(name); + if (result != null) { + return copyIfMutable(result); + } + result = shadowedVars.get(name); + if (result != null) { + return result; + } + return parent.resolveSimpleName(name, exprId); + } + + @Override + void cacheLazilyEvaluatedResult(String name, DefaultInterpreter.IntermediateResult result) { + // Ensure that lazily evaluated result is stored at the proper scope. + // A lazily attribute is first declared when a new cel.bind/cel.block expr is encountered. + // + // If this attribute isn't found in the current scope, we need to walk up the parent scopes + // until we find this declaration. + // + // For example: cel.bind(x, get_true(), ['foo','bar'].map(unused, x && x)) + // + // Here, `x` would be evaluated in map macro's scope, but the result should be stored in + // cel.bind's scope. + if (!lazyEvalResultCache.containsKey(name)) { + parent.cacheLazilyEvaluatedResult(name, result); + } else { + lazyEvalResultCache.put(name, copyIfMutable(result)); + } + } + + @Override + void declareLazyAttribute(String attrName) { + lazyEvalResultCache.put(attrName, null); + } + + /** + * Perform a defensive copy of the intermediate result if it is mutable. + * + *

Some internal types are mutable to optimize performance, but this can cause issues when + * the result can be reused in multiple subexpressions due to caching. + * + *

Note: this is necessary on both the cache put and get path since the interpreter may use + * the same instance that was cached as a return value. + */ + private static DefaultInterpreter.IntermediateResult copyIfMutable( + DefaultInterpreter.IntermediateResult result) { + if (result.value() instanceof AccumulatedUnknowns) { + AccumulatedUnknowns unknowns = (AccumulatedUnknowns) result.value(); + return DefaultInterpreter.IntermediateResult.create( + result.attribute(), + AccumulatedUnknowns.create(unknowns.exprIds(), unknowns.attributes())); + } + return result; + } + } + + /** Null implementation for attribute resolution. */ + private static final class NullAttributeResolver implements CelAttributeResolver { + @Override + public Optional resolve(CelAttribute attr) { + return Optional.empty(); + } + + @Override + public Optional maybePartialUnknown(CelAttribute attr) { + return Optional.empty(); + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/TypeResolver.java b/runtime/src/main/java/dev/cel/runtime/TypeResolver.java new file mode 100644 index 000000000..691810837 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/TypeResolver.java @@ -0,0 +1,210 @@ +// Copyright 2025 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 static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.ByteString; +import com.google.protobuf.Duration; +import com.google.protobuf.MessageLiteOrBuilder; +import com.google.protobuf.NullValue; +import com.google.protobuf.Timestamp; +import dev.cel.common.annotations.Internal; +import dev.cel.common.types.CelType; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.CelValue; +import dev.cel.common.values.CelValueConverter; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** + * {@code TypeResolver} resolves incoming {@link CelType} into {@link TypeType}., either as part of + * a type call (type('foo'), type(1), etc.) or as a type literal (type, int, string, etc.) + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public class TypeResolver { + + private final CelValueConverter celValueConverter; + + static TypeResolver create(CelValueConverter celValueConverter) { + return new TypeResolver(celValueConverter); + } + + // Sentinel runtime value representing the special "type" ident. This ensures following to be + // true: type == type(string) && type == type(type("foo")) + @VisibleForTesting static final TypeType RUNTIME_TYPE_TYPE = TypeType.create(SimpleType.DYN); + + private static final ImmutableMap, TypeType> COMMON_TYPES = + ImmutableMap., TypeType>builder() + .put(Boolean.class, TypeType.create(SimpleType.BOOL)) + .put(Double.class, TypeType.create(SimpleType.DOUBLE)) + .put(Long.class, TypeType.create(SimpleType.INT)) + .put(UnsignedLong.class, TypeType.create(SimpleType.UINT)) + .put(String.class, TypeType.create(SimpleType.STRING)) + .put(NullValue.class, TypeType.create(SimpleType.NULL_TYPE)) + .put(dev.cel.common.values.NullValue.class, TypeType.create(SimpleType.NULL_TYPE)) + .put(java.time.Duration.class, TypeType.create(SimpleType.DURATION)) + .put(Instant.class, TypeType.create(SimpleType.TIMESTAMP)) + .put( + Duration.class, + TypeType.create( + SimpleType.DURATION)) // TODO: Remove once clients have been migrated + .put( + Timestamp.class, + TypeType.create( + SimpleType + .TIMESTAMP)) // TODO: Remove once clients have been migrated + .put(ArrayList.class, TypeType.create(ListType.create(SimpleType.DYN))) + .put(HashMap.class, TypeType.create(MapType.create(SimpleType.DYN, SimpleType.DYN))) + .put(Optional.class, TypeType.create(OptionalType.create(SimpleType.DYN))) + .put(CelByteString.class, TypeType.create(SimpleType.BYTES)) + .buildOrThrow(); + + private static final ImmutableMap, TypeType> EXTENDABLE_TYPES = + ImmutableMap., TypeType>builder() + .put( + ByteString.class, + TypeType.create( + SimpleType.BYTES)) // TODO: Remove once clients have been migrated + .put(Collection.class, TypeType.create(ListType.create(SimpleType.DYN))) + .put(Map.class, TypeType.create(MapType.create(SimpleType.DYN, SimpleType.DYN))) + .buildOrThrow(); + + /** Adapt the type-checked {@link CelType} into a runtime type value {@link TypeType}. */ + TypeType adaptType(CelType typeCheckedType) { + checkNotNull(typeCheckedType); + + switch (typeCheckedType.kind()) { + case TYPE: + CelType typeOfType = ((TypeType) typeCheckedType).type(); + switch (typeOfType.kind()) { + case STRUCT: + return TypeType.create(adaptStructType((StructType) typeOfType)); + default: + return (TypeType) typeCheckedType; + } + case UNSPECIFIED: + throw new IllegalArgumentException("Unsupported CelType kind: " + typeCheckedType.kind()); + default: + return TypeType.create(typeCheckedType); + } + } + + Optional resolveWellKnownObjectType(Object obj) { + if (obj instanceof TypeType) { + return Optional.of(RUNTIME_TYPE_TYPE); + } + + Class currentClass = obj.getClass(); + TypeType commonType = COMMON_TYPES.get(currentClass); + if (commonType != null) { + return Optional.of(commonType); + } + + // Guava's Immutable classes use package-private implementations, such that they require an + // explicit check. + if (ImmutableList.class.isAssignableFrom(currentClass)) { + return Optional.of(TypeType.create(ListType.create(SimpleType.DYN))); + } else if (ImmutableMap.class.isAssignableFrom(currentClass)) { + return Optional.of(TypeType.create(MapType.create(SimpleType.DYN, SimpleType.DYN))); + } + + return Optional.empty(); + } + + /** Resolve the CEL type of the {@code obj}. */ + public TypeType resolveObjectType(Object obj, CelType typeCheckedType) { + checkNotNull(obj); + Optional wellKnownTypeType = resolveWellKnownObjectType(obj); + if (wellKnownTypeType.isPresent()) { + return wellKnownTypeType.get(); + } + + if (celValueConverter != null) { + Object celVal = celValueConverter.toRuntimeValue(obj); + if (celVal instanceof CelValue) { + return TypeType.create(((CelValue) celVal).celType()); + } + } + + if (obj instanceof MessageLiteOrBuilder) { + // TODO: Replace with CelLiteDescriptor + throw new UnsupportedOperationException("Not implemented yet"); + } + + Class currentClass = obj.getClass(); + TypeType runtimeType; + + // Handle types that the client may have extended. + while (currentClass != null) { + runtimeType = EXTENDABLE_TYPES.get(currentClass); + if (runtimeType != null) { + return runtimeType; + } + + // Check interfaces + for (Class interfaceClass : currentClass.getInterfaces()) { + runtimeType = EXTENDABLE_TYPES.get(interfaceClass); + if (runtimeType != null) { + return runtimeType; + } + } + currentClass = currentClass.getSuperclass(); + } + + // This is an opaque type, or something CEL doesn't know about. + return (TypeType) typeCheckedType; + } + + private static CelType adaptStructType(StructType typeOfType) { + String structName = typeOfType.name(); + CelType newTypeOfType; + if (structName.equals(SimpleType.DURATION.name())) { + newTypeOfType = SimpleType.DURATION; + } else if (structName.equals(SimpleType.TIMESTAMP.name())) { + newTypeOfType = SimpleType.TIMESTAMP; + } else { + // Coerces ProtoMessageTypeProvider to be a struct type reference for accurate + // equality tests. + // In the future, we can plumb ProtoMessageTypeProvider through the runtime to retain + // ProtoMessageType here. + newTypeOfType = StructTypeReference.create(typeOfType.name()); + } + return newTypeOfType; + } + + protected TypeResolver(CelValueConverter celValueConverter) { + this.celValueConverter = checkNotNull(celValueConverter); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/UnknownContext.java b/runtime/src/main/java/dev/cel/runtime/UnknownContext.java new file mode 100644 index 000000000..c494ff252 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/UnknownContext.java @@ -0,0 +1,177 @@ +// Copyright 2022 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 static com.google.common.collect.ImmutableList.toImmutableList; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.Immutable; +import java.util.Collection; +import java.util.Map; +import java.util.Optional; + +/** + * AsyncContext represents the state required for an iterative evaluation session in the CEL + * evaluator. + * + *

It manages the effective state for an evaluation pass in {@link + * CelRuntime.Program#advanceEvaluation(UnknownContext)}. + * + *

This class is conditionally thread-safe. + * + *

    + *
  • Resolved values are type-erased, but must be immutable for this class to remain thread + * safe. + *
  • The class implementing the variable resolver interface must be thread-safe. + *
+ */ +@Immutable +public class UnknownContext { + private final ImmutableList unresolvedAttributes; + + // GlobalResolver implementation must be Immutable if used in this class. + @SuppressWarnings("Immutable") + private final GlobalResolver variableResolver; + + // Clients must resolve attributes to Immutable types. + @SuppressWarnings("Immutable") + private final ImmutableMap resolvedAttributes; + + private UnknownContext( + GlobalResolver resolver, + ImmutableList unresolvedAttributes, + ImmutableMap resolvedAttributes) { + this.unresolvedAttributes = unresolvedAttributes; + this.variableResolver = resolver; + this.resolvedAttributes = resolvedAttributes; + } + + /** + * Creates a trivial unknown context from a GlobalResolver. + * + *

This is used for compatibility with {@link CelRuntime.Program} overloads that don't specify + * any attributes. + */ + public static UnknownContext create(GlobalResolver resolver) { + return new UnknownContext(resolver, ImmutableList.of(), ImmutableMap.of()); + } + + /** Creates an unknown context from a list */ + public static UnknownContext create( + CelVariableResolver resolver, Collection attributes) { + return new UnknownContext( + createExprVariableResolver(resolver), ImmutableList.copyOf(attributes), ImmutableMap.of()); + } + + /** Extends an existing {@code UnknownContext} by adding more attribute patterns to it. */ + public UnknownContext extend(Collection attributePatterns) { + return new UnknownContext( + this.variableResolver(), + ImmutableList.builder() + .addAll(this.unresolvedAttributes) + .addAll(attributePatterns) + .build(), + this.resolvedAttributes); + } + + /** Adapts a CelVariableResolver to the legacy impl equivalent GlobalResolver. */ + private static GlobalResolver createExprVariableResolver(CelVariableResolver resolver) { + return (String name) -> resolver.find(name).orElse(null); + } + + /** + * Creates an attribute resolver based on registered unknown patterns and resolved attribute + * values. + * + *

This provides attribute lookups and unknown matching functions to the interpreter. + */ + public CelAttributeResolver createAttributeResolver() { + return DefaultAttributeResolver.create(unresolvedAttributes, resolvedAttributes); + } + + /** Accessor for the underlying variable resolver. */ + public GlobalResolver variableResolver() { + return variableResolver; + } + + /** + * Creates a new unknown context that is a copy of the current context with the provided + * additional attribute values. + * + *

any unknown CelAttributePatterns are removed if they are satisfied by the newly resolved + * attributes. + */ + public UnknownContext withResolvedAttributes(Map resolvedAttributes) { + return new UnknownContext( + this.variableResolver, + unresolvedAttributes.stream() + .filter((pattern) -> !patternMaskedByResolvedAttribute(resolvedAttributes, pattern)) + .collect(toImmutableList()), + ImmutableMap.builder() + .putAll(this.resolvedAttributes) + .putAll(resolvedAttributes) + .buildOrThrow()); + } + + private boolean patternMaskedByResolvedAttribute( + Map resolved, CelAttributePattern pattern) { + return resolved.keySet().stream().anyMatch(pattern::isPartialMatch); + } + + /** + * Default implementation of an attribute resolver. + * + *

Checks against a map of resolved attributes then a list of unknown patterns. + */ + private static class DefaultAttributeResolver implements CelAttributeResolver { + private final ImmutableList unresolvedAttributes; + private final ImmutableMap resolvedAttributes; + + private DefaultAttributeResolver( + ImmutableList unresolvedAttributes, + ImmutableMap resolvedAttributes) { + this.unresolvedAttributes = unresolvedAttributes; + this.resolvedAttributes = resolvedAttributes; + } + + private static DefaultAttributeResolver create( + ImmutableList attributes, + ImmutableMap resolvedAttributes) { + return new DefaultAttributeResolver(attributes, resolvedAttributes); + } + + @Override + public Optional resolve(CelAttribute attribute) { + Object entry = resolvedAttributes.get(attribute); + if (entry != null) { + return Optional.of(entry); + } + + return unresolvedAttributes.stream() + .filter(pattern -> pattern.isMatch(attribute)) + .findFirst() + .map(p -> CelUnknownSet.create(p.simplify(attribute))); + } + + @Override + public Optional maybePartialUnknown(CelAttribute attribute) { + return unresolvedAttributes.stream() + .filter(p -> p.isPartialMatch(attribute)) + .findFirst() + .map(p -> CelUnknownSet.create(p.simplify(attribute))); + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/UnknownTrackingInterpretable.java b/runtime/src/main/java/dev/cel/runtime/UnknownTrackingInterpretable.java new file mode 100644 index 000000000..8422910a1 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/UnknownTrackingInterpretable.java @@ -0,0 +1,41 @@ +// Copyright 2022 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 dev.cel.common.annotations.Internal; +import java.util.Optional; + +/** + * An interpretable that allows for tracking unknowns at runtime. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public interface UnknownTrackingInterpretable { + /** + * Runs interpretation with the given activation which supplies name/value bindings with the + * ability to track and resolve unknown variables as they are encountered. + * + *

This method allows for late-binding functions to be provided per-evaluation, which can be + * useful for binding functions which might have side-effects that are not observable to CEL + * directly such as recording telemetry or evaluation state in a more granular fashion than a more + * general evaluation listener might permit. + */ + Object evalTrackingUnknowns( + RuntimeUnknownResolver resolver, + Optional lateBoundFunctionResolver, + Optional listener) + throws CelEvaluationException; +} diff --git a/runtime/src/main/java/dev/cel/runtime/async/AsyncProgramImpl.java b/runtime/src/main/java/dev/cel/runtime/async/AsyncProgramImpl.java new file mode 100644 index 000000000..b53c6254b --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/async/AsyncProgramImpl.java @@ -0,0 +1,187 @@ +// Copyright 2022 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.async; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableMap.toImmutableMap; +import static com.google.common.util.concurrent.Futures.immediateFailedFuture; +import static com.google.common.util.concurrent.Futures.immediateFuture; +import static com.google.common.util.concurrent.Futures.transformAsync; +import static com.google.common.util.concurrent.Futures.whenAllSucceed; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.ListeningExecutorService; +import javax.annotation.concurrent.ThreadSafe; +import dev.cel.runtime.CelAttribute; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime.Program; +import dev.cel.runtime.CelUnknownSet; +import dev.cel.runtime.UnknownContext; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutionException; + +/** + * Default runtime implementation for {@link CelAsyncRuntime.AsyncProgram}. + * + *

Control flow is: + * + *

    + *
  1. Evaluate the expression (synchronously), identifying unknowns or final result + *
  2. If unknowns identified, schedule lookups (calls to *Resolver.resolve) on the executor + *
  3. On any failure, return failed future. CEL errors can be introduced by the return value of + * resolver. + *
  4. On all successful, generate new context for next round of evaluation on the executor + *
  5. repeat until a final (non-unknown) result, no progress is made, or iteration limit reached. + *
+ */ +@ThreadSafe +final class AsyncProgramImpl implements CelAsyncRuntime.AsyncProgram { + // Safety limit for resolution rounds. + private final int maxEvaluateIterations; + private final UnknownContext startingUnknownContext; + private final Program program; + private final ListeningExecutorService executor; + + AsyncProgramImpl( + Program program, + ListeningExecutorService executor, + int maxEvaluateIterations, + UnknownContext startingUnknownContext) { + this.program = program; + this.executor = executor; + this.maxEvaluateIterations = maxEvaluateIterations; + // The following is populated from CelAsyncRuntime. The impl is immutable, thus safe to reuse as + // a starting context. + this.startingUnknownContext = startingUnknownContext; + } + + private Optional lookupResolver( + Iterable resolvableAttributePatterns, CelAttribute attribute) { + // TODO: may need to handle multiple resolvers for partial case. + for (CelResolvableAttributePattern entry : resolvableAttributePatterns) { + if (entry.attributePattern().isPartialMatch(attribute)) { + return Optional.of(entry.resolver()); + } + } + + return Optional.empty(); + } + + private ListenableFuture> allAsMapOnSuccess( + Map> futureMap) { + return whenAllSucceed(futureMap.values()) + .call( + () -> + futureMap.entrySet().stream() + .collect( + toImmutableMap( + Map.Entry::getKey, + entry -> { + try { + return Futures.getDone(entry.getValue()); + } catch (ExecutionException e) { + throw new AssertionError( + "Futures.whenAllSucceed forwarded failed future", e); + } + })), + executor); + } + + private ListenableFuture resolveAndReevaluate( + CelUnknownSet unknowns, + UnknownContext ctx, + Iterable resolvableAttributePatterns, + int iteration) { + Map> futureMap = new LinkedHashMap<>(); + for (CelAttribute attr : unknowns.attributes()) { + Optional maybeResolver = + lookupResolver(resolvableAttributePatterns, attr); + + maybeResolver.ifPresent((resolver) -> futureMap.put(attr, resolver.resolve(executor, attr))); + } + + if (futureMap.isEmpty()) { + return immediateFailedFuture( + new CelEvaluationException( + String.format("Unknown resolution failed -- no resolvers for: %s", unknowns))); + } + + // TODO: lookup fails on any failure. Fine for prototyping, but this would likely + // need to be configurable in the future. + return transformAsync( + allAsMapOnSuccess(futureMap), + (result) -> + evalPass( + ctx.withResolvedAttributes(result), + resolvableAttributePatterns, + unknowns, + iteration), + executor); + } + + private ListenableFuture evalPass( + UnknownContext ctx, + Iterable resolvableAttributePatterns, + CelUnknownSet lastSet, + int iteration) { + Object result; + try { + result = program.advanceEvaluation(ctx); + } catch (CelEvaluationException e) { + return immediateFailedFuture(e); + } + if (result instanceof CelUnknownSet) { + if (result.equals(lastSet)) { + return immediateFailedFuture( + new CelEvaluationException("No progress in iterative eval. Last result: " + result)); + } + // Don't handle unknowns if next evaluation would exceed eval limit. + iteration++; + if (iteration >= maxEvaluateIterations) { + return immediateFailedFuture( + new CelEvaluationException("Max Evaluation iterations exceeded: " + iteration)); + } + return resolveAndReevaluate( + (CelUnknownSet) result, ctx, resolvableAttributePatterns, iteration); + } + + return immediateFuture(result); + } + + @Override + public ListenableFuture evaluateToCompletion( + CelResolvableAttributePattern... resolvableAttributes) { + return evaluateToCompletion(ImmutableList.copyOf(resolvableAttributes)); + } + + @Override + public ListenableFuture evaluateToCompletion( + Iterable resolvableAttributePatterns) { + UnknownContext newAsyncContext = + startingUnknownContext.extend( + ImmutableList.copyOf(resolvableAttributePatterns).stream() + .map(CelResolvableAttributePattern::attributePattern) + .collect(toImmutableList())); + + return evalPass( + newAsyncContext, resolvableAttributePatterns, CelUnknownSet.create(ImmutableSet.of()), 0); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/async/BUILD.bazel b/runtime/src/main/java/dev/cel/runtime/async/BUILD.bazel new file mode 100644 index 000000000..56fa42a02 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/async/BUILD.bazel @@ -0,0 +1,37 @@ +# Reference implementation for an Async evaluator for the CEL runtime. + +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = [ + "//runtime/async:__pkg__", + ], +) + +ASYNC_RUNTIME_SOURCES = [ + "AsyncProgramImpl.java", + "CelResolvableAttributePattern.java", + "CelAsyncRuntimeImpl.java", + "CelAsyncRuntime.java", + "CelAsyncRuntimeBuilder.java", + "CelAsyncRuntimeFactory.java", + "ThreadSafeCelVariableResolver.java", + "CelUnknownAttributeValueResolver.java", +] + +java_library( + name = "async", + srcs = ASYNC_RUNTIME_SOURCES, + deps = [ + "//:auto_value", + "//common:cel_ast", + "//runtime", + "//runtime:unknown_attributes", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) diff --git a/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntime.java b/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntime.java new file mode 100644 index 000000000..a8a2b789e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntime.java @@ -0,0 +1,54 @@ +// Copyright 2022 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.async; + +import com.google.common.util.concurrent.ListenableFuture; +import javax.annotation.concurrent.ThreadSafe; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.UnknownContext; + +/** + * CelAsyncRuntime provides configuration for an async evaluation context. + * + *

This is a factory for two primitives: + * + *

    + *
  • {@link UnknownContext} manages the state necessary for the initial round of iterative + * evaluation. The AsyncProgram implementation may use its .withX methods to generate an + * updated context for later rounds. + *
  • {@link AsyncProgram} provides an evaluation manager to automate evaluating and resolving + * unknown data + *
+ */ +@ThreadSafe +public interface CelAsyncRuntime { + + /** AsyncProgram wraps a CEL Program with a driver to resolve unknowns as they are encountered. */ + interface AsyncProgram { + ListenableFuture evaluateToCompletion( + CelResolvableAttributePattern... resolvableAttributes); + + ListenableFuture evaluateToCompletion( + Iterable resolvableAttributes); + } + + /** + * Creates an {@link AsyncProgram} for the given AST. + * + * @param ast the input CEL expression. must be type checked. + */ + AsyncProgram createProgram(CelAbstractSyntaxTree ast) throws CelEvaluationException; +} diff --git a/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntimeBuilder.java b/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntimeBuilder.java new file mode 100644 index 000000000..23400fcf0 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntimeBuilder.java @@ -0,0 +1,62 @@ +// Copyright 2022 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.async; + +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.runtime.CelRuntime; +import java.util.concurrent.ExecutorService; + +/** Builder interface for {@link CelAsyncRuntime}. */ +public interface CelAsyncRuntimeBuilder { + int DEFAULT_MAX_EVALUATE_ITERATIONS = 10; + + /** Set the CEL runtime for running incremental evaluation. */ + @CanIgnoreReturnValue + CelAsyncRuntimeBuilder setRuntime(CelRuntime runtime); + + /** + * Set the maximum number of allowed evaluation passes. + * + *

This is a safety mechanism for expressions that chain dependent unknowns (e.g. via the + * conditional operator or nested function calls). + * + *

Implementations should default to {@value DEFAULT_MAX_EVALUATE_ITERATIONS}. + */ + @CanIgnoreReturnValue + CelAsyncRuntimeBuilder setMaxEvaluateIterations(int n); + + /** + * Sets the variable resolver for simple CelVariable names (e.g. 'x' or 'com.google.x'). + * + *

This is consulted after checking for unknown or resolved attributes. It represents any data + * about the environment that does not need any special resolution. + */ + @CanIgnoreReturnValue + CelAsyncRuntimeBuilder setVariableResolver(ThreadSafeCelVariableResolver variableResolver); + + /** + * Sets the executorService for generated AsyncPrograms. + * + *

The executor is used for handling simple transformations of the resolved data and for + * scheduling subsequent rounds of evaluation. If synchronous style resolvers are provided, they + * will be run on the same executor. + * + *

Explicitly setting an executor is mandatory. Pick an appropriate executor for the configured + * resolvers. + */ + @CanIgnoreReturnValue + CelAsyncRuntimeBuilder setExecutorService(ExecutorService executorService); + + CelAsyncRuntime build(); +} diff --git a/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntimeFactory.java b/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntimeFactory.java new file mode 100644 index 000000000..8712b429e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntimeFactory.java @@ -0,0 +1,24 @@ +// Copyright 2023 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.async; + +/** Factory for default {@link CelAsyncRuntime}. */ +public final class CelAsyncRuntimeFactory { + public static CelAsyncRuntimeBuilder defaultAsyncRuntime() { + return CelAsyncRuntimeImpl.newBuilder(); + } + + private CelAsyncRuntimeFactory() {} +} diff --git a/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntimeImpl.java b/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntimeImpl.java new file mode 100644 index 000000000..902d9d7c6 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/async/CelAsyncRuntimeImpl.java @@ -0,0 +1,114 @@ +// Copyright 2022 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.async; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; +import javax.annotation.concurrent.ThreadSafe; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.runtime.UnknownContext; +import java.util.Optional; +import java.util.concurrent.ExecutorService; + +/** Default {@link CelAsyncRuntime} runtime implementation. See {@link AsyncProgramImpl}. */ +@ThreadSafe +final class CelAsyncRuntimeImpl implements CelAsyncRuntime { + private final CelRuntime runtime; + private final ListeningExecutorService executorService; + private final ThreadSafeCelVariableResolver variableResolver; + private final int maxEvaluateIterations; + + private CelAsyncRuntimeImpl( + ThreadSafeCelVariableResolver variableResolver, + CelRuntime runtime, + ListeningExecutorService executorService, + int maxEvaluateIterations) { + this.variableResolver = variableResolver; + this.runtime = runtime; + this.executorService = executorService; + this.maxEvaluateIterations = maxEvaluateIterations; + } + + private UnknownContext newAsyncContext() { + return UnknownContext.create(variableResolver, ImmutableList.of()); + } + + @Override + public AsyncProgram createProgram(CelAbstractSyntaxTree ast) throws CelEvaluationException { + return new AsyncProgramImpl( + runtime.createProgram(ast), + executorService, + maxEvaluateIterations, + newAsyncContext()); + } + + static Builder newBuilder() { + return new Builder(); + } + + /** {@link CelAsyncRuntimeBuilder} implementation for {@link CelAsyncRuntimeImpl}. */ + private static final class Builder implements CelAsyncRuntimeBuilder { + private CelRuntime runtime; + private ListeningExecutorService executorService; + private Optional variableResolver; + private int maxEvaluateIterations; + + private Builder() { + runtime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + variableResolver = Optional.empty(); + maxEvaluateIterations = DEFAULT_MAX_EVALUATE_ITERATIONS; + } + + @Override + public Builder setRuntime(CelRuntime runtime) { + this.runtime = runtime; + return this; + } + + @Override + public Builder setMaxEvaluateIterations(int n) { + Preconditions.checkArgument(n > 0, "maxEvaluateIterations must be positive"); + this.maxEvaluateIterations = n; + return this; + } + + @Override + public Builder setVariableResolver(ThreadSafeCelVariableResolver variableResolver) { + this.variableResolver = Optional.of(variableResolver); + return this; + } + + @Override + public Builder setExecutorService(ExecutorService executorService) { + this.executorService = MoreExecutors.listeningDecorator(executorService); + return this; + } + + @Override + public CelAsyncRuntime build() { + Preconditions.checkNotNull(executorService, "executorService must be specified."); + return new CelAsyncRuntimeImpl( + variableResolver.orElse((unused) -> Optional.empty()), + runtime, + executorService, + maxEvaluateIterations); + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/async/CelResolvableAttributePattern.java b/runtime/src/main/java/dev/cel/runtime/async/CelResolvableAttributePattern.java new file mode 100644 index 000000000..8e243476b --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/async/CelResolvableAttributePattern.java @@ -0,0 +1,36 @@ +// Copyright 2025 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.async; + +import com.google.auto.value.AutoValue; +import dev.cel.runtime.CelAttributePattern; + +/** + * CelResolvableAttributePattern wraps {@link CelAttributePattern} to represent a CEL attribute + * whose value is initially unknown and needs to be resolved. It couples the attribute pattern with + * a {@link CelUnknownAttributeValueResolver} that can fetch the actual value for the attribute when + * it becomes available. + */ +@AutoValue +public abstract class CelResolvableAttributePattern { + public abstract CelAttributePattern attributePattern(); + + public abstract CelUnknownAttributeValueResolver resolver(); + + public static CelResolvableAttributePattern of( + CelAttributePattern attribute, CelUnknownAttributeValueResolver resolver) { + return new AutoValue_CelResolvableAttributePattern(attribute, resolver); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/async/CelUnknownAttributeValueResolver.java b/runtime/src/main/java/dev/cel/runtime/async/CelUnknownAttributeValueResolver.java new file mode 100644 index 000000000..a0e0d56d9 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/async/CelUnknownAttributeValueResolver.java @@ -0,0 +1,106 @@ +// Copyright 2022 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.async; + +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.ListeningExecutorService; +import javax.annotation.concurrent.ThreadSafe; +import dev.cel.runtime.CelAttribute; + +/** + * Represents a resolver function for an Attribute (determining a value for an unknown attribute). + * + *

The resolver supports either an async or synchronous style. + * + *

Error handling: thrown exceptions propagate immediately (as a failed future). To handle an + * error in the CEL evaluator, return a value that is an instance of an unchecked exception. + * TODO: checked exceptions get double wrapped but otherwise behave as expected. + */ +@ThreadSafe +public abstract class CelUnknownAttributeValueResolver { + + /** + * Synchronous style resolver. Implementation should return a value for the given attribute. A + * thrown exception ends evaluation with a failed future. + * + *

The lookup may be run in an executor managed by the CEL runtime. + * + *

The implementation must be effectively immutable: multiple resolve requests for the same + * attribute must return the same value. + */ + @FunctionalInterface + @ThreadSafe + public interface Resolver { + Object resolve(CelAttribute attribute) throws Exception; + } + + /** + * Async style resolver. Implementation should return a future representing the lookup for the + * given attribute. + * + *

A failed future is propagated immediately. + * + *

The implementation must be effectively immutable: multiple resolve requests for the same + * attribute must return the same value. + * + *

Note: the caller is responsible for scheduling the execution of the lookup, and the + * evaluator will update the async context with the result. + */ + @FunctionalInterface + @ThreadSafe + public interface AsyncResolver { + ListenableFuture resolve(CelAttribute attribute); + } + + /** Package private adapter to a normalized listenable future. */ + abstract ListenableFuture resolve( + ListeningExecutorService executorService, CelAttribute attribute); + + private static final class SyncImpl extends CelUnknownAttributeValueResolver { + private final Resolver resolver; + + public SyncImpl(Resolver resolver) { + this.resolver = resolver; + } + + @Override + ListenableFuture resolve( + ListeningExecutorService executorService, CelAttribute attribute) { + return executorService.submit(() -> resolver.resolve(attribute)); + } + } + + private static final class AsyncImpl extends CelUnknownAttributeValueResolver { + private final AsyncResolver resolver; + + public AsyncImpl(AsyncResolver resolver) { + this.resolver = resolver; + } + + @Override + ListenableFuture resolve( + ListeningExecutorService executorService, CelAttribute attribute) { + return resolver.resolve(attribute); + } + } + + public static CelUnknownAttributeValueResolver fromResolver(Resolver resolve) { + return new SyncImpl(resolve); + } + + public static CelUnknownAttributeValueResolver fromAsyncResolver(AsyncResolver resolve) { + return new AsyncImpl(resolve); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/async/ThreadSafeCelVariableResolver.java b/runtime/src/main/java/dev/cel/runtime/async/ThreadSafeCelVariableResolver.java new file mode 100644 index 000000000..49cc5a496 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/async/ThreadSafeCelVariableResolver.java @@ -0,0 +1,32 @@ +// Copyright 2023 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.async; + +import javax.annotation.concurrent.ThreadSafe; +import dev.cel.runtime.CelVariableResolver; + +/** + * Trivial subinterface of {@link dev.cel.runtime.CelVariableResovler} that allows for enforcing + * ThreadSafe errorprone checks. + * + *

TODO: Check feasibility of applying ThreadSafe annotation directly on + * CelVariableResolver. Implementations should be effectively immutable for consistent behavior, but + * in practice the errorprone check may be too restricting for clients. At present, this will break + * at least a few clients. Alternatively, if this interface adds additional functionality specific + * to the async runtime, it may make sense to keep. + */ +@ThreadSafe +@FunctionalInterface +public interface ThreadSafeCelVariableResolver extends CelVariableResolver {} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/ActivationWrapper.java b/runtime/src/main/java/dev/cel/runtime/planner/ActivationWrapper.java new file mode 100644 index 000000000..8883ac12c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/ActivationWrapper.java @@ -0,0 +1,25 @@ +// 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.planner; + +import dev.cel.runtime.GlobalResolver; + +/** Identifies a resolver that can be unwrapped to bypass local variable state. */ +public interface ActivationWrapper extends GlobalResolver { + GlobalResolver unwrap(); + + /** Returns true if the given name is bound by this local activation wrapper. */ + boolean isLocallyBound(String name); +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/Attribute.java b/runtime/src/main/java/dev/cel/runtime/planner/Attribute.java new file mode 100644 index 000000000..90165c1ac --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/Attribute.java @@ -0,0 +1,26 @@ +// Copyright 2025 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.planner; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.runtime.GlobalResolver; + +/** Represents a resolvable symbol or path (such as a variable or a field selection). */ +@Immutable +interface Attribute { + Object resolve(long exprId, GlobalResolver ctx, ExecutionFrame frame); + + Attribute addQualifier(Qualifier qualifier); +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/AttributeFactory.java b/runtime/src/main/java/dev/cel/runtime/planner/AttributeFactory.java new file mode 100644 index 000000000..fabf7ade5 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/AttributeFactory.java @@ -0,0 +1,63 @@ +// Copyright 2025 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.planner; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelContainer; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.values.CelValueConverter; + +@Immutable +final class AttributeFactory { + + private final CelContainer container; + private final CelTypeProvider typeProvider; + private final CelValueConverter celValueConverter; + + NamespacedAttribute newAbsoluteAttribute(String... names) { + return NamespacedAttribute.create(typeProvider, celValueConverter, ImmutableSet.copyOf(names)); + } + + RelativeAttribute newRelativeAttribute(PlannedInterpretable operand) { + return new RelativeAttribute(operand, celValueConverter); + } + + MaybeAttribute newMaybeAttribute(String name) { + // When there's a single name with a dot prefix, it indicates that the 'maybe' attribute is a + // globally namespaced identifier. + // Otherwise, the candidate names resolved from the container should be inferred. + ImmutableSet names = + name.startsWith(".") ? ImmutableSet.of(name) : container.resolveCandidateNames(name); + + return new MaybeAttribute( + this, ImmutableList.of(NamespacedAttribute.create(typeProvider, celValueConverter, names))); + } + + static AttributeFactory newAttributeFactory( + CelContainer celContainer, + CelTypeProvider typeProvider, + CelValueConverter celValueConverter) { + return new AttributeFactory(celContainer, typeProvider, celValueConverter); + } + + private AttributeFactory( + CelContainer container, CelTypeProvider typeProvider, CelValueConverter celValueConverter) { + this.container = container; + this.typeProvider = typeProvider; + this.celValueConverter = celValueConverter; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/BUILD.bazel b/runtime/src/main/java/dev/cel/runtime/planner/BUILD.bazel new file mode 100644 index 000000000..801e56d73 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/BUILD.bazel @@ -0,0 +1,557 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//runtime/planner:__pkg__", + ], +) + +java_library( + name = "program_planner", + srcs = ["ProgramPlanner.java"], + tags = [ + ], + deps = [ + ":attribute", + ":error_metadata", + ":eval_and", + ":eval_attribute", + ":eval_binary", + ":eval_block", + ":eval_conditional", + ":eval_const", + ":eval_create_list", + ":eval_create_map", + ":eval_create_struct", + ":eval_exhaustive_and", + ":eval_exhaustive_conditional", + ":eval_exhaustive_or", + ":eval_fold", + ":eval_late_bound_call", + ":eval_optional_or", + ":eval_optional_or_value", + ":eval_optional_select_field", + ":eval_or", + ":eval_test_only", + ":eval_unary", + ":eval_var_args_call", + ":eval_zero_arity", + ":interpretable_attribute", + ":planned_interpretable", + ":planned_program", + ":qualifier", + ":string_qualifier", + "//:auto_value", + "//common:cel_ast", + "//common:container", + "//common:operator", + "//common:options", + "//common/annotations", + "//common/ast", + "//common/exceptions:overload_not_found", + "//common/types", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_value_provider", + "//runtime:dispatcher", + "//runtime:evaluation_exception", + "//runtime:evaluation_exception_builder", + "//runtime:program", + "//runtime:resolved_overload", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "planned_program", + srcs = ["PlannedProgram.java"], + tags = [ + ], + deps = [ + ":error_metadata", + ":localized_evaluation_exception", + ":planned_interpretable", + "//:auto_value", + "//common:options", + "//common/annotations", + "//common/exceptions:runtime_exception", + "//common/values", + "//runtime:activation", + "//runtime:evaluation_exception", + "//runtime:evaluation_exception_builder", + "//runtime:evaluation_listener", + "//runtime:function_resolver", + "//runtime:interpretable", + "//runtime:interpreter_util", + "//runtime:partial_vars", + "//runtime:program", + "//runtime:resolved_overload", + "//runtime:variable_resolver", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "eval_const", + srcs = ["EvalConstant.java"], + deps = [ + ":planned_interpretable", + "//common/ast", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "interpretable_attribute", + srcs = ["InterpretableAttribute.java"], + deps = [ + ":planned_interpretable", + ":qualifier", + "//common/ast", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "attribute", + srcs = [ + "Attribute.java", + "AttributeFactory.java", + "MaybeAttribute.java", + "MissingAttribute.java", + "NamespacedAttribute.java", + "RelativeAttribute.java", + ], + deps = [ + ":activation_wrapper", + ":eval_helpers", + ":planned_interpretable", + ":qualifier", + "//common:container", + "//common/exceptions:attribute_not_found", + "//common/types", + "//common/types:type_providers", + "//common/values", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "//runtime:interpreter_util", + "//runtime:partial_vars", + "//runtime:unknown_attributes", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "activation_wrapper", + srcs = ["ActivationWrapper.java"], + deps = [ + "//runtime:interpretable", + ], +) + +java_library( + name = "qualifier", + srcs = ["Qualifier.java"], + deps = [ + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "presence_test_qualifier", + srcs = ["PresenceTestQualifier.java"], + deps = [ + ":attribute", + ":qualifier", + "//common/values", + ], +) + +java_library( + name = "string_qualifier", + srcs = ["StringQualifier.java"], + deps = [ + ":qualifier", + "//common/exceptions:attribute_not_found", + "//common/values", + ], +) + +java_library( + name = "eval_attribute", + srcs = ["EvalAttribute.java"], + deps = [ + ":attribute", + ":interpretable_attribute", + ":planned_interpretable", + ":qualifier", + "//common/ast", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "eval_test_only", + srcs = ["EvalTestOnly.java"], + deps = [ + ":interpretable_attribute", + ":planned_interpretable", + ":presence_test_qualifier", + ":qualifier", + "//common/ast", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "eval_zero_arity", + srcs = ["EvalZeroArity.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/values", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "//runtime:resolved_overload", + ], +) + +java_library( + name = "eval_unary", + srcs = ["EvalUnary.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/values", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "//runtime:resolved_overload", + ], +) + +java_library( + name = "eval_binary", + srcs = ["EvalBinary.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/values", + "//runtime:accumulated_unknowns", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "//runtime:resolved_overload", + ], +) + +java_library( + name = "eval_var_args_call", + srcs = ["EvalVarArgsCall.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/values", + "//runtime:accumulated_unknowns", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "//runtime:resolved_overload", + ], +) + +java_library( + name = "eval_late_bound_call", + srcs = ["EvalLateBoundCall.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/exceptions:overload_not_found", + "//common/values", + "//runtime:accumulated_unknowns", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "//runtime:resolved_overload", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_or", + srcs = ["EvalOr.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/values", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_and", + srcs = ["EvalAnd.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/values", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_conditional", + srcs = ["EvalConditional.java"], + deps = [ + ":planned_interpretable", + "//common/ast", + "//runtime:accumulated_unknowns", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_create_struct", + srcs = ["EvalCreateStruct.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_value_provider", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_create_list", + srcs = ["EvalCreateList.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_create_map", + srcs = ["EvalCreateMap.java"], + deps = [ + ":eval_helpers", + ":localized_evaluation_exception", + ":planned_interpretable", + "//common/ast", + "//common/exceptions:duplicate_key", + "//common/exceptions:invalid_argument", + "//runtime:accumulated_unknowns", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_fold", + srcs = ["EvalFold.java"], + deps = [ + ":activation_wrapper", + ":planned_interpretable", + "//common/ast", + "//common/exceptions:runtime_exception", + "//common/values:mutable_map_value", + "//runtime:accumulated_unknowns", + "//runtime:concatenated_list_view", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "eval_helpers", + srcs = ["EvalHelpers.java"], + deps = [ + ":localized_evaluation_exception", + ":planned_interpretable", + "//common:error_codes", + "//common/exceptions:runtime_exception", + "//common/values", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "//runtime:resolved_overload", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "localized_evaluation_exception", + srcs = ["LocalizedEvaluationException.java"], + deps = [ + "//common:error_codes", + "//common/exceptions:runtime_exception", + ], +) + +java_library( + name = "error_metadata", + srcs = ["ErrorMetadata.java"], + deps = [ + "//runtime:metadata", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "planned_interpretable", + srcs = [ + "BlockMemoizer.java", + "ExecutionFrame.java", + "PlannedInterpretable.java", + ], + deps = [ + ":localized_evaluation_exception", + "//common:options", + "//common/ast", + "//common/exceptions:iteration_budget_exceeded", + "//runtime:evaluation_exception", + "//runtime:evaluation_listener", + "//runtime:function_resolver", + "//runtime:interpretable", + "//runtime:interpreter_util", + "//runtime:partial_vars", + "//runtime:resolved_overload", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "eval_optional_or", + srcs = ["EvalOptionalOr.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/exceptions:overload_not_found", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_optional_or_value", + srcs = ["EvalOptionalOrValue.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/exceptions:overload_not_found", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_optional_select_field", + srcs = ["EvalOptionalSelectField.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/values", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "eval_exhaustive_and", + srcs = ["EvalExhaustiveAnd.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/values", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "eval_exhaustive_or", + srcs = ["EvalExhaustiveOr.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//common/values", + "//runtime:accumulated_unknowns", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "eval_exhaustive_conditional", + srcs = ["EvalExhaustiveConditional.java"], + deps = [ + ":eval_helpers", + ":planned_interpretable", + "//common/ast", + "//runtime:accumulated_unknowns", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "eval_block", + srcs = ["EvalBlock.java"], + deps = [ + ":planned_interpretable", + "//common/ast", + "//runtime:evaluation_exception", + "//runtime:interpretable", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) diff --git a/runtime/src/main/java/dev/cel/runtime/planner/BlockMemoizer.java b/runtime/src/main/java/dev/cel/runtime/planner/BlockMemoizer.java new file mode 100644 index 000000000..80a0a5de0 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/BlockMemoizer.java @@ -0,0 +1,72 @@ +// 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.planner; + +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.GlobalResolver; +import java.util.Arrays; + +/** Handles memoization, lazy evaluation, and cycle detection for cel.@block slots. */ +final class BlockMemoizer { + + private static final Object IN_PROGRESS = new Object(); + private static final Object UNSET = new Object(); + + private final PlannedInterpretable[] slotExprs; + private final Object[] slotVals; + private final ExecutionFrame frame; + + static BlockMemoizer create(PlannedInterpretable[] slotExprs, ExecutionFrame frame) { + return new BlockMemoizer(slotExprs, frame); + } + + private BlockMemoizer(PlannedInterpretable[] slotExprs, ExecutionFrame frame) { + this.slotExprs = slotExprs; + this.frame = frame; + this.slotVals = new Object[slotExprs.length]; + Arrays.fill(this.slotVals, UNSET); + } + + Object resolveSlot(int idx, GlobalResolver resolver) { + Object val = slotVals[idx]; + + // Already evaluated + if (val != UNSET && val != IN_PROGRESS) { + if (val instanceof RuntimeException) { + throw (RuntimeException) val; + } + return val; + } + + if (val == IN_PROGRESS) { + throw new IllegalStateException("Cycle detected: @index" + idx); + } + + slotVals[idx] = IN_PROGRESS; + try { + Object result = slotExprs[idx].eval(resolver, frame); + slotVals[idx] = result; + return result; + } catch (CelEvaluationException e) { + LocalizedEvaluationException localizedException = + new LocalizedEvaluationException(e, e.getErrorCode(), slotExprs[idx].expr().id()); + slotVals[idx] = localizedException; + throw localizedException; + } catch (RuntimeException e) { + slotVals[idx] = e; + throw e; + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/ErrorMetadata.java b/runtime/src/main/java/dev/cel/runtime/planner/ErrorMetadata.java new file mode 100644 index 000000000..2358bd0f9 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/ErrorMetadata.java @@ -0,0 +1,52 @@ +// Copyright 2025 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.planner; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.Immutable; +import dev.cel.runtime.Metadata; + +@Immutable +final class ErrorMetadata implements Metadata { + + private final ImmutableMap exprIdToPositionMap; + private final String location; + + @Override + public String getLocation() { + return location; + } + + @Override + public int getPosition(long exprId) { + return exprIdToPositionMap.getOrDefault(exprId, 0); + } + + @Override + public boolean hasPosition(long exprId) { + return exprIdToPositionMap.containsKey(exprId); + } + + static ErrorMetadata create(ImmutableMap exprIdToPositionMap, String location) { + return new ErrorMetadata(exprIdToPositionMap, location); + } + + private ErrorMetadata(ImmutableMap exprIdToPositionMap, String location) { + this.exprIdToPositionMap = checkNotNull(exprIdToPositionMap); + this.location = checkNotNull(location); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalAnd.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalAnd.java new file mode 100644 index 000000000..11da26a50 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalAnd.java @@ -0,0 +1,77 @@ +// Copyright 2025 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.planner; + +import static dev.cel.runtime.planner.EvalHelpers.evalNonstrictly; + +import com.google.common.base.Preconditions; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.values.ErrorValue; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; + +final class EvalAnd extends PlannedInterpretable { + + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] args; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + ErrorValue errorValue = null; + AccumulatedUnknowns unknowns = null; + for (PlannedInterpretable arg : args) { + Object argVal = evalNonstrictly(arg, resolver, frame); + if (argVal instanceof Boolean) { + // Short-circuit on false + if (!((boolean) argVal)) { + return false; + } + } else if (argVal instanceof ErrorValue) { + // Preserve the first encountered error instead of overwriting it with subsequent errors. + if (errorValue == null) { + errorValue = (ErrorValue) argVal; + } + } else if (argVal instanceof AccumulatedUnknowns) { + unknowns = AccumulatedUnknowns.maybeMerge(unknowns, argVal); + } else { + errorValue = + ErrorValue.create( + arg.expr().id(), + new IllegalArgumentException( + String.format("Expected boolean value, found: %s", argVal))); + } + } + + if (unknowns != null) { + return unknowns; + } + + if (errorValue != null) { + return errorValue; + } + + return true; + } + + static EvalAnd create(CelExpr expr, PlannedInterpretable[] args) { + return new EvalAnd(expr, args); + } + + private EvalAnd(CelExpr expr, PlannedInterpretable[] args) { + super(expr); + Preconditions.checkArgument(args.length == 2); + this.args = args; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalAttribute.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalAttribute.java new file mode 100644 index 000000000..56ea8a832 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalAttribute.java @@ -0,0 +1,50 @@ +// Copyright 2025 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.planner; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.runtime.GlobalResolver; + +@Immutable +final class EvalAttribute extends InterpretableAttribute { + + private final Attribute attr; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + Object resolved = attr.resolve(expr().id(), resolver, frame); + if (resolved instanceof MissingAttribute) { + ((MissingAttribute) resolved).resolve(expr().id(), resolver, frame); + } + + return resolved; + } + + @Override + public EvalAttribute addQualifier(CelExpr expr, Qualifier qualifier) { + Attribute newAttribute = attr.addQualifier(qualifier); + return create(expr, newAttribute); + } + + static EvalAttribute create(CelExpr expr, Attribute attr) { + return new EvalAttribute(expr, attr); + } + + private EvalAttribute(CelExpr expr, Attribute attr) { + super(expr); + this.attr = attr; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalBinary.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalBinary.java new file mode 100644 index 000000000..fcade7789 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalBinary.java @@ -0,0 +1,81 @@ +// 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.planner; + +import static dev.cel.runtime.planner.EvalHelpers.evalNonstrictly; +import static dev.cel.runtime.planner.EvalHelpers.evalStrictly; + +import dev.cel.common.ast.CelExpr; +import dev.cel.common.values.CelValueConverter; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelResolvedOverload; +import dev.cel.runtime.GlobalResolver; + +final class EvalBinary extends PlannedInterpretable { + + private final String functionName; + private final CelResolvedOverload resolvedOverload; + private final PlannedInterpretable arg1; + private final PlannedInterpretable arg2; + private final CelValueConverter celValueConverter; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + Object argVal1 = + resolvedOverload.isStrict() + ? evalStrictly(arg1, resolver, frame) + : evalNonstrictly(arg1, resolver, frame); + Object argVal2 = + resolvedOverload.isStrict() + ? evalStrictly(arg2, resolver, frame) + : evalNonstrictly(arg2, resolver, frame); + + AccumulatedUnknowns unknowns = AccumulatedUnknowns.maybeMerge(null, argVal1); + unknowns = AccumulatedUnknowns.maybeMerge(unknowns, argVal2); + + if (unknowns != null) { + return unknowns; + } + + return EvalHelpers.dispatch( + functionName, resolvedOverload, celValueConverter, argVal1, argVal2); + } + + static EvalBinary create( + CelExpr expr, + String functionName, + CelResolvedOverload resolvedOverload, + PlannedInterpretable arg1, + PlannedInterpretable arg2, + CelValueConverter celValueConverter) { + return new EvalBinary(expr, functionName, resolvedOverload, arg1, arg2, celValueConverter); + } + + private EvalBinary( + CelExpr expr, + String functionName, + CelResolvedOverload resolvedOverload, + PlannedInterpretable arg1, + PlannedInterpretable arg2, + CelValueConverter celValueConverter) { + super(expr); + this.functionName = functionName; + this.resolvedOverload = resolvedOverload; + this.arg1 = arg1; + this.arg2 = arg2; + this.celValueConverter = celValueConverter; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalBlock.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalBlock.java new file mode 100644 index 000000000..eed8791d4 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalBlock.java @@ -0,0 +1,68 @@ +// 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.planner; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.GlobalResolver; + +/** Eval implementation of {@code cel.@block}. */ +@Immutable +final class EvalBlock extends PlannedInterpretable { + + @SuppressWarnings("Immutable") // Array not mutated after creation + private final PlannedInterpretable[] slotExprs; + + private final PlannedInterpretable resultExpr; + + static EvalBlock create( + CelExpr expr, PlannedInterpretable[] slotExprs, PlannedInterpretable resultExpr) { + return new EvalBlock(expr, slotExprs, resultExpr); + } + + private EvalBlock( + CelExpr expr, PlannedInterpretable[] slotExprs, PlannedInterpretable resultExpr) { + super(expr); + this.slotExprs = slotExprs; + this.resultExpr = resultExpr; + } + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + BlockMemoizer memoizer = BlockMemoizer.create(slotExprs, frame); + frame.setBlockMemoizer(memoizer); + return resultExpr.eval(resolver, frame); + } + + @Immutable + static final class EvalBlockSlot extends PlannedInterpretable { + private final int slotIndex; + + static EvalBlockSlot create(CelExpr expr, int slotIndex) { + return new EvalBlockSlot(expr, slotIndex); + } + + private EvalBlockSlot(CelExpr expr, int slotIndex) { + super(expr); + this.slotIndex = slotIndex; + } + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + return frame.getBlockMemoizer().resolveSlot(slotIndex, resolver); + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalConditional.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalConditional.java new file mode 100644 index 000000000..c2d730cdf --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalConditional.java @@ -0,0 +1,59 @@ +// Copyright 2025 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.planner; + +import com.google.common.base.Preconditions; +import dev.cel.common.ast.CelExpr; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.GlobalResolver; + +final class EvalConditional extends PlannedInterpretable { + + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] args; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + PlannedInterpretable condition = args[0]; + PlannedInterpretable truthy = args[1]; + PlannedInterpretable falsy = args[2]; + Object condResult = condition.eval(resolver, frame); + if (condResult instanceof AccumulatedUnknowns) { + return condResult; + } + if (!(condResult instanceof Boolean)) { + throw new IllegalArgumentException( + String.format("Expected boolean value, found :%s", condResult)); + } + + // TODO: Handle exhaustive eval + if ((boolean) condResult) { + return truthy.eval(resolver, frame); + } + + return falsy.eval(resolver, frame); + } + + static EvalConditional create(CelExpr expr, PlannedInterpretable[] args) { + return new EvalConditional(expr, args); + } + + private EvalConditional(CelExpr expr, PlannedInterpretable[] args) { + super(expr); + Preconditions.checkArgument(args.length == 3); + this.args = args; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalConstant.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalConstant.java new file mode 100644 index 000000000..55554069b --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalConstant.java @@ -0,0 +1,40 @@ +// Copyright 2025 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.planner; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.runtime.GlobalResolver; + +@Immutable +final class EvalConstant extends PlannedInterpretable { + + @SuppressWarnings("Immutable") // Known CEL constants that aren't mutated are stored + private final Object constant; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + return constant; + } + + static EvalConstant create(CelExpr expr, Object value) { + return new EvalConstant(expr, value); + } + + private EvalConstant(CelExpr expr, Object constant) { + super(expr); + this.constant = constant; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateList.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateList.java new file mode 100644 index 000000000..265da3ab3 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateList.java @@ -0,0 +1,78 @@ +// Copyright 2025 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.planner; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; +import java.util.Optional; + +@Immutable +final class EvalCreateList extends PlannedInterpretable { + + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] values; + + @SuppressWarnings("Immutable") + private final boolean[] isOptional; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + ImmutableList.Builder builder = ImmutableList.builderWithExpectedSize(values.length); + AccumulatedUnknowns unknowns = null; + for (int i = 0; i < values.length; i++) { + Object element = EvalHelpers.evalStrictly(values[i], resolver, frame); + + if (element instanceof AccumulatedUnknowns) { + unknowns = AccumulatedUnknowns.maybeMerge(unknowns, element); + continue; + } + + if (isOptional[i]) { + if (!(element instanceof Optional)) { + throw new IllegalArgumentException( + String.format( + "Cannot initialize optional list element from non-optional value %s", element)); + } + + Optional opt = (Optional) element; + if (!opt.isPresent()) { + continue; + } + element = opt.get(); + } + + builder.add(element); + } + + if (unknowns != null) { + return unknowns; + } + + return builder.build(); + } + + static EvalCreateList create(CelExpr expr, PlannedInterpretable[] values, boolean[] isOptional) { + return new EvalCreateList(expr, values, isOptional); + } + + private EvalCreateList(CelExpr expr, PlannedInterpretable[] values, boolean[] isOptional) { + super(expr); + this.values = values; + this.isOptional = isOptional; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateMap.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateMap.java new file mode 100644 index 000000000..8d34c10d0 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateMap.java @@ -0,0 +1,142 @@ +// Copyright 2025 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.planner; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Sets; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.exceptions.CelDuplicateKeyException; +import dev.cel.common.exceptions.CelInvalidArgumentException; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.GlobalResolver; +import java.util.HashSet; +import java.util.Optional; + +@Immutable +final class EvalCreateMap extends PlannedInterpretable { + + // Array contents are not mutated + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] keys; + + // Array contents are not mutated + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] values; + + // Array contents are not mutated + @SuppressWarnings("Immutable") + private final boolean[] isOptional; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + ImmutableMap.Builder builder = + ImmutableMap.builderWithExpectedSize(keys.length); + HashSet keysSeen = Sets.newHashSetWithExpectedSize(keys.length); + AccumulatedUnknowns unknowns = null; + + for (int i = 0; i < keys.length; i++) { + PlannedInterpretable keyInterpretable = keys[i]; + Object key = keyInterpretable.eval(resolver, frame); + + if (key instanceof AccumulatedUnknowns) { + unknowns = AccumulatedUnknowns.maybeMerge(unknowns, key); + } else { + if (!(key instanceof String + || key instanceof Long + || key instanceof UnsignedLong + || key instanceof Boolean)) { + throw new LocalizedEvaluationException( + new CelInvalidArgumentException("Unsupported key type: " + key), + keyInterpretable.expr().id()); + } + + boolean isDuplicate = !keysSeen.add(key); + if (!isDuplicate) { + if (key instanceof Long) { + long longVal = (Long) key; + if (longVal >= 0) { + isDuplicate = keysSeen.contains(UnsignedLong.valueOf(longVal)); + } + } else if (key instanceof UnsignedLong) { + UnsignedLong ulongVal = (UnsignedLong) key; + isDuplicate = keysSeen.contains(ulongVal.longValue()); + } + } + + if (isDuplicate) { + throw new LocalizedEvaluationException( + CelDuplicateKeyException.of(key), keyInterpretable.expr().id()); + } + } + + Object val = EvalHelpers.evalStrictly(values[i], resolver, frame); + + unknowns = AccumulatedUnknowns.maybeMerge(unknowns, val); + if (unknowns != null) { + continue; + } + + if (isOptional[i]) { + if (!(val instanceof Optional)) { + throw new IllegalArgumentException( + String.format( + "Cannot initialize optional entry '%s' from non-optional value %s", key, val)); + } + + Optional opt = (Optional) val; + if (!opt.isPresent()) { + // This is a no-op currently but will be semantically correct when extended proto + // support allows proto mutation. + keysSeen.remove(key); + continue; + } + val = opt.get(); + } + + builder.put(key, val); + } + + if (unknowns != null) { + return unknowns; + } + + return builder.buildOrThrow(); + } + + static EvalCreateMap create( + CelExpr expr, + PlannedInterpretable[] keys, + PlannedInterpretable[] values, + boolean[] isOptional) { + return new EvalCreateMap(expr, keys, values, isOptional); + } + + private EvalCreateMap( + CelExpr expr, + PlannedInterpretable[] keys, + PlannedInterpretable[] values, + boolean[] isOptional) { + super(expr); + Preconditions.checkArgument(keys.length == values.length); + Preconditions.checkArgument(keys.length == isOptional.length); + this.keys = keys; + this.values = values; + this.isOptional = isOptional; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateStruct.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateStruct.java new file mode 100644 index 000000000..a2e8a9da6 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateStruct.java @@ -0,0 +1,121 @@ +// Copyright 2025 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.planner; + +import com.google.common.collect.Maps; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.types.CelType; +import dev.cel.common.values.CelValueProvider; +import dev.cel.common.values.StructValue; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; +import java.util.Collections; +import java.util.Map; +import java.util.Optional; + +@Immutable +final class EvalCreateStruct extends PlannedInterpretable { + + private final CelValueProvider valueProvider; + private final CelType structType; + + // Array contents are not mutated + @SuppressWarnings("Immutable") + private final String[] keys; + + // Array contents are not mutated + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] values; + + // Array contents are not mutated + @SuppressWarnings("Immutable") + private final boolean[] isOptional; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + Map fieldValues = Maps.newHashMapWithExpectedSize(keys.length); + AccumulatedUnknowns unknowns = null; + for (int i = 0; i < keys.length; i++) { + Object value = EvalHelpers.evalStrictly(values[i], resolver, frame); + + if (value instanceof AccumulatedUnknowns) { + unknowns = AccumulatedUnknowns.maybeMerge(unknowns, value); + continue; + } + + if (isOptional[i]) { + if (!(value instanceof Optional)) { + throw new IllegalArgumentException( + String.format( + "Cannot initialize optional entry '%s' from non-optional value" + " %s", + keys[i], value)); + } + + Optional opt = (Optional) value; + if (!opt.isPresent()) { + // This is a no-op currently but will be semantically correct when extended proto + // support allows proto mutation. + fieldValues.remove(keys[i]); + continue; + } + value = opt.get(); + } + + fieldValues.put(keys[i], value); + } + + if (unknowns != null) { + return unknowns; + } + + // Either a primitive (wrappers) or a struct is produced + Object value = + valueProvider + .newValue(structType.name(), Collections.unmodifiableMap(fieldValues)) + .orElseThrow( + () -> new IllegalArgumentException("Type name not found: " + structType.name())); + if (value instanceof StructValue) { + return ((StructValue) value).value(); + } + + return value; + } + + static EvalCreateStruct create( + CelExpr expr, + CelValueProvider valueProvider, + CelType structType, + String[] keys, + PlannedInterpretable[] values, + boolean[] isOptional) { + return new EvalCreateStruct(expr, valueProvider, structType, keys, values, isOptional); + } + + private EvalCreateStruct( + CelExpr expr, + CelValueProvider valueProvider, + CelType structType, + String[] keys, + PlannedInterpretable[] values, + boolean[] isOptional) { + super(expr); + this.valueProvider = valueProvider; + this.structType = structType; + this.keys = keys; + this.values = values; + this.isOptional = isOptional; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalExhaustiveAnd.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalExhaustiveAnd.java new file mode 100644 index 000000000..ac3d07200 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalExhaustiveAnd.java @@ -0,0 +1,92 @@ +// 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.planner; + +import static dev.cel.runtime.planner.EvalHelpers.evalNonstrictly; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.values.ErrorValue; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; + +/** + * Implementation of logical AND with exhaustive evaluation (non-short-circuiting). + * + *

It evaluates all arguments, but prioritizes a false result over unknowns and errors to + * maintain semantic consistency with short-circuiting evaluation. + */ +@Immutable +final class EvalExhaustiveAnd extends PlannedInterpretable { + + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] args; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + AccumulatedUnknowns accumulatedUnknowns = null; + ErrorValue errorValue = null; + boolean hasFalse = false; + + for (PlannedInterpretable arg : args) { + Object argVal = evalNonstrictly(arg, resolver, frame); + if (argVal instanceof Boolean) { + if (!((boolean) argVal)) { + hasFalse = true; + } + } + + // If we already encountered a false, we do not need to accumulate unknowns or errors + // from subsequent terms because the final result will be false anyway. + if (hasFalse) { + continue; + } + + if (argVal instanceof AccumulatedUnknowns) { + accumulatedUnknowns = + accumulatedUnknowns == null + ? (AccumulatedUnknowns) argVal + : accumulatedUnknowns.merge((AccumulatedUnknowns) argVal); + } else if (argVal instanceof ErrorValue) { + if (errorValue == null) { + errorValue = (ErrorValue) argVal; + } + } + } + + if (hasFalse) { + return false; + } + + if (accumulatedUnknowns != null) { + return accumulatedUnknowns; + } + + if (errorValue != null) { + return errorValue; + } + + return true; + } + + static EvalExhaustiveAnd create(CelExpr expr, PlannedInterpretable[] args) { + return new EvalExhaustiveAnd(expr, args); + } + + private EvalExhaustiveAnd(CelExpr expr, PlannedInterpretable[] args) { + super(expr); + this.args = args; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalExhaustiveConditional.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalExhaustiveConditional.java new file mode 100644 index 000000000..01e242c0f --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalExhaustiveConditional.java @@ -0,0 +1,68 @@ +// 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.planner; + +import static dev.cel.runtime.planner.EvalHelpers.evalNonstrictly; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.GlobalResolver; + +/** + * Implementation of conditional operator (ternary) with exhaustive evaluation + * (non-short-circuiting). + * + *

It evaluates all three arguments (condition, truthy, and falsy branches) but returns the + * result based on the condition, maintaining semantic consistency with short-circuiting evaluation. + */ +@Immutable +final class EvalExhaustiveConditional extends PlannedInterpretable { + + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] args; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + PlannedInterpretable condition = args[0]; + PlannedInterpretable truthy = args[1]; + PlannedInterpretable falsy = args[2]; + + Object condResult = condition.eval(resolver, frame); + Object truthyVal = evalNonstrictly(truthy, resolver, frame); + Object falsyVal = evalNonstrictly(falsy, resolver, frame); + + if (condResult instanceof AccumulatedUnknowns) { + return condResult; + } + + if (!(condResult instanceof Boolean)) { + throw new IllegalArgumentException( + String.format("Expected boolean value, found :%s", condResult)); + } + + return (boolean) condResult ? truthyVal : falsyVal; + } + + static EvalExhaustiveConditional create(CelExpr expr, PlannedInterpretable[] args) { + return new EvalExhaustiveConditional(expr, args); + } + + private EvalExhaustiveConditional(CelExpr expr, PlannedInterpretable[] args) { + super(expr); + this.args = args; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalExhaustiveOr.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalExhaustiveOr.java new file mode 100644 index 000000000..07164f8c7 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalExhaustiveOr.java @@ -0,0 +1,92 @@ +// 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.planner; + +import static dev.cel.runtime.planner.EvalHelpers.evalNonstrictly; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.values.ErrorValue; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; + +/** + * Implementation of logical OR with exhaustive evaluation (non-short-circuiting). + * + *

It evaluates all arguments, but prioritizes a true result over unknowns and errors to maintain + * semantic consistency with short-circuiting evaluation. + */ +@Immutable +final class EvalExhaustiveOr extends PlannedInterpretable { + + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] args; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + AccumulatedUnknowns accumulatedUnknowns = null; + ErrorValue errorValue = null; + boolean hasTrue = false; + + for (PlannedInterpretable arg : args) { + Object argVal = evalNonstrictly(arg, resolver, frame); + if (argVal instanceof Boolean) { + if ((boolean) argVal) { + hasTrue = true; + } + } + + // If we already encountered a true, we do not need to accumulate unknowns or errors + // from subsequent terms because the final result will be true anyway. + if (hasTrue) { + continue; + } + + if (argVal instanceof AccumulatedUnknowns) { + accumulatedUnknowns = + accumulatedUnknowns == null + ? (AccumulatedUnknowns) argVal + : accumulatedUnknowns.merge((AccumulatedUnknowns) argVal); + } else if (argVal instanceof ErrorValue) { + if (errorValue == null) { + errorValue = (ErrorValue) argVal; + } + } + } + + if (hasTrue) { + return true; + } + + if (accumulatedUnknowns != null) { + return accumulatedUnknowns; + } + + if (errorValue != null) { + return errorValue; + } + + return false; + } + + static EvalExhaustiveOr create(CelExpr expr, PlannedInterpretable[] args) { + return new EvalExhaustiveOr(expr, args); + } + + private EvalExhaustiveOr(CelExpr expr, PlannedInterpretable[] args) { + super(expr); + this.args = args; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalFold.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalFold.java new file mode 100644 index 000000000..2de52e982 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalFold.java @@ -0,0 +1,240 @@ +// Copyright 2025 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.planner; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.exceptions.CelRuntimeException; +import dev.cel.common.values.MutableMapValue; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.ConcatenatedListView; +import dev.cel.runtime.GlobalResolver; +import java.util.Collection; +import java.util.Map; +import org.jspecify.annotations.Nullable; + +@Immutable +final class EvalFold extends PlannedInterpretable { + + private final String accuVar; + private final PlannedInterpretable accuInit; + private final String iterVar; + private final String iterVar2; + private final PlannedInterpretable iterRange; + private final PlannedInterpretable condition; + private final PlannedInterpretable loopStep; + private final PlannedInterpretable result; + + static EvalFold create( + CelExpr expr, + String accuVar, + PlannedInterpretable accuInit, + String iterVar, + String iterVar2, + PlannedInterpretable iterRange, + PlannedInterpretable loopCondition, + PlannedInterpretable loopStep, + PlannedInterpretable result) { + return new EvalFold( + expr, accuVar, accuInit, iterVar, iterVar2, iterRange, loopCondition, loopStep, result); + } + + private EvalFold( + CelExpr expr, + String accuVar, + PlannedInterpretable accuInit, + String iterVar, + String iterVar2, + PlannedInterpretable iterRange, + PlannedInterpretable condition, + PlannedInterpretable loopStep, + PlannedInterpretable result) { + super(expr); + this.accuVar = accuVar; + this.accuInit = accuInit; + this.iterVar = iterVar; + this.iterVar2 = iterVar2; + this.iterRange = iterRange; + this.condition = condition; + this.loopStep = loopStep; + this.result = result; + } + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + Object iterRangeRaw = iterRange.eval(resolver, frame); + if (iterRangeRaw instanceof AccumulatedUnknowns) { + return iterRangeRaw; + } + Folder folder = new Folder(resolver, frame, accuInit, accuVar, iterVar, iterVar2); + + Object result; + if (iterRangeRaw instanceof Map) { + result = evalMap((Map) iterRangeRaw, folder, frame); + } else if (iterRangeRaw instanceof Collection) { + result = evalList((Collection) iterRangeRaw, folder, frame); + } else { + throw new IllegalArgumentException("Unexpected iter_range type: " + iterRangeRaw.getClass()); + } + + return maybeUnwrapAccumulator(result); + } + + private Object evalMap(Map iterRange, Folder folder, ExecutionFrame frame) + throws CelEvaluationException { + for (Map.Entry entry : iterRange.entrySet()) { + frame.incrementIterations(); + + folder.iterVarVal = entry.getKey(); + if (!iterVar2.isEmpty()) { + folder.iterVar2Val = entry.getValue(); + } + + boolean cond = (boolean) condition.eval(folder, frame); + if (!cond) { + folder.computeResult = true; + return result.eval(folder, frame); + } + + folder.accuVal = loopStep.eval(folder, frame); + folder.initialized = true; + } + folder.computeResult = true; + return result.eval(folder, frame); + } + + private Object evalList(Collection iterRange, Folder folder, ExecutionFrame frame) + throws CelEvaluationException { + int index = 0; + for (Object item : iterRange) { + frame.incrementIterations(); + + if (iterVar2.isEmpty()) { + folder.iterVarVal = item; + } else { + folder.iterVarVal = (long) index; + folder.iterVar2Val = item; + } + + boolean cond = (boolean) condition.eval(folder, frame); + if (!cond) { + folder.computeResult = true; + return maybeUnwrapAccumulator(result.eval(folder, frame)); + } + + folder.accuVal = loopStep.eval(folder, frame); + folder.initialized = true; + index++; + } + folder.computeResult = true; + return maybeUnwrapAccumulator(result.eval(folder, frame)); + } + + private static Object maybeWrapAccumulator(Object val) { + if (val instanceof Collection) { + return new ConcatenatedListView<>((Collection) val); + } + if (val instanceof Map) { + return MutableMapValue.create((Map) val); + } + return val; + } + + private static Object maybeUnwrapAccumulator(Object val) { + if (val instanceof ConcatenatedListView) { + return ImmutableList.copyOf((ConcatenatedListView) val); + } + if (val instanceof MutableMapValue) { + return ImmutableMap.copyOf((MutableMapValue) val); + } + return val; + } + + private static class Folder implements ActivationWrapper { + private final GlobalResolver resolver; + private final ExecutionFrame frame; + private final PlannedInterpretable accuInit; + private final String accuVar; + private final String iterVar; + private final String iterVar2; + + private Object iterVarVal; + private Object iterVar2Val; + private Object accuVal; + private boolean initialized = false; + private boolean computeResult = false; + + private Folder( + GlobalResolver resolver, + ExecutionFrame frame, + PlannedInterpretable accuInit, + String accuVar, + String iterVar, + String iterVar2) { + this.resolver = resolver; + this.frame = frame; + this.accuInit = accuInit; + this.accuVar = accuVar; + this.iterVar = iterVar; + this.iterVar2 = iterVar2; + } + + @Override + public GlobalResolver unwrap() { + return resolver; + } + + @Override + public boolean isLocallyBound(String name) { + return name.equals(accuVar) || name.equals(iterVar) || name.equals(iterVar2); + } + + @Override + public @Nullable Object resolve(String name) { + if (name.equals(accuVar)) { + if (!initialized) { + initialized = true; + try { + accuVal = maybeWrapAccumulator(accuInit.eval(resolver, frame)); + } catch (CelEvaluationException e) { + throw new LazyEvaluationRuntimeException(e); + } + } + return accuVal; + } + + if (!computeResult) { + if (name.equals(iterVar)) { + return this.iterVarVal; + } + + if (name.equals(iterVar2)) { + return this.iterVar2Val; + } + } + + return resolver.resolve(name); + } + } + + private static class LazyEvaluationRuntimeException extends CelRuntimeException { + private LazyEvaluationRuntimeException(CelEvaluationException cause) { + super(cause, cause.getErrorCode()); + } + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalHelpers.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalHelpers.java new file mode 100644 index 000000000..f9812793e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalHelpers.java @@ -0,0 +1,116 @@ +// Copyright 2025 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.planner; + +import com.google.common.base.Joiner; +import dev.cel.common.CelErrorCode; +import dev.cel.common.exceptions.CelRuntimeException; +import dev.cel.common.values.CelValueConverter; +import dev.cel.common.values.ErrorValue; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelResolvedOverload; +import dev.cel.runtime.GlobalResolver; + +final class EvalHelpers { + + static Object evalNonstrictly( + PlannedInterpretable interpretable, GlobalResolver resolver, ExecutionFrame frame) { + try { + return interpretable.eval(resolver, frame); + } 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) { + return ErrorValue.create(interpretable.expr().id(), e); + } + } + + static Object evalStrictly( + PlannedInterpretable interpretable, GlobalResolver resolver, ExecutionFrame frame) { + try { + return interpretable.eval(resolver, frame); + } catch (LocalizedEvaluationException e) { + // Already localized - propagate as-is to preserve inner expression ID + throw e; + } catch (CelRuntimeException e) { + // Wrap with current interpretable's location + throw new LocalizedEvaluationException(e, interpretable.expr().id()); + } catch (Exception e) { + // Wrap generic exceptions with location + throw new LocalizedEvaluationException( + e, CelErrorCode.INTERNAL_ERROR, interpretable.expr().id()); + } + } + + static Object dispatch( + String functionName, + CelResolvedOverload overload, + CelValueConverter valueConverter, + Object[] args) + throws CelEvaluationException { + try { + Object result = overload.invoke(args); + return valueConverter.maybeUnwrap(valueConverter.toRuntimeValue(result)); + } catch (RuntimeException e) { + throw handleDispatchException(e, overload, args); + } + } + + static Object dispatch( + String functionName, + CelResolvedOverload overload, + CelValueConverter valueConverter, + Object arg) + throws CelEvaluationException { + try { + Object result = overload.invoke(arg); + return valueConverter.maybeUnwrap(valueConverter.toRuntimeValue(result)); + } catch (RuntimeException e) { + throw handleDispatchException(e, overload, arg); + } + } + + static Object dispatch( + String functionName, + CelResolvedOverload overload, + CelValueConverter valueConverter, + Object arg1, + Object arg2) + throws CelEvaluationException { + try { + Object result = overload.invoke(arg1, arg2); + return valueConverter.maybeUnwrap(valueConverter.toRuntimeValue(result)); + } catch (RuntimeException e) { + throw handleDispatchException(e, overload, arg1, arg2); + } + } + + private static RuntimeException handleDispatchException( + RuntimeException e, CelResolvedOverload overload, Object... args) { + if (e instanceof CelRuntimeException) { + // Function dispatch failure that's already been handled -- just propagate. + return e; + } + // Unexpected function dispatch failure. + return new IllegalArgumentException( + String.format( + "Function '%s' failed with arg(s) '%s'", + overload.getFunctionName(), Joiner.on(", ").join(args)), + e); + } + + private EvalHelpers() {} +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalLateBoundCall.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalLateBoundCall.java new file mode 100644 index 000000000..719b4af21 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalLateBoundCall.java @@ -0,0 +1,83 @@ +// 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.planner; + +import static dev.cel.runtime.planner.EvalHelpers.evalStrictly; + +import com.google.common.collect.ImmutableList; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.exceptions.CelOverloadNotFoundException; +import dev.cel.common.values.CelValueConverter; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelResolvedOverload; +import dev.cel.runtime.GlobalResolver; + +final class EvalLateBoundCall extends PlannedInterpretable { + + private final String functionName; + private final ImmutableList overloadIds; + + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] args; + + private final CelValueConverter celValueConverter; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + Object[] argVals = new Object[args.length]; + AccumulatedUnknowns unknowns = null; + for (int i = 0; i < args.length; i++) { + PlannedInterpretable arg = args[i]; + // Late bound functions are assumed to be strict. + argVals[i] = evalStrictly(arg, resolver, frame); + + unknowns = AccumulatedUnknowns.maybeMerge(unknowns, argVals[i]); + } + + if (unknowns != null) { + return unknowns; + } + + CelResolvedOverload resolvedOverload = + frame + .findOverload(functionName, overloadIds, argVals) + .orElseThrow(() -> new CelOverloadNotFoundException(functionName, overloadIds)); + + return EvalHelpers.dispatch(functionName, resolvedOverload, celValueConverter, argVals); + } + + static EvalLateBoundCall create( + CelExpr expr, + String functionName, + ImmutableList overloadIds, + PlannedInterpretable[] args, + CelValueConverter celValueConverter) { + return new EvalLateBoundCall(expr, functionName, overloadIds, args, celValueConverter); + } + + private EvalLateBoundCall( + CelExpr expr, + String functionName, + ImmutableList overloadIds, + PlannedInterpretable[] args, + CelValueConverter celValueConverter) { + super(expr); + this.functionName = functionName; + this.overloadIds = overloadIds; + this.args = args; + this.celValueConverter = celValueConverter; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalOptionalOr.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalOptionalOr.java new file mode 100644 index 000000000..37e3a8ccb --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalOptionalOr.java @@ -0,0 +1,59 @@ +// 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.planner; + +import com.google.common.base.Preconditions; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.exceptions.CelOverloadNotFoundException; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; +import java.util.Optional; + +@Immutable +final class EvalOptionalOr extends PlannedInterpretable { + private final PlannedInterpretable lhs; + private final PlannedInterpretable rhs; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + Object lhsValue = EvalHelpers.evalStrictly(lhs, resolver, frame); + + if (lhsValue instanceof AccumulatedUnknowns) { + return lhsValue; + } + + if (!(lhsValue instanceof Optional)) { + throw new CelOverloadNotFoundException("or"); + } + + Optional optionalLhs = (Optional) lhsValue; + if (optionalLhs.isPresent()) { + return optionalLhs; + } + + return EvalHelpers.evalStrictly(rhs, resolver, frame); + } + + static EvalOptionalOr create(CelExpr expr, PlannedInterpretable lhs, PlannedInterpretable rhs) { + return new EvalOptionalOr(expr, lhs, rhs); + } + + private EvalOptionalOr(CelExpr expr, PlannedInterpretable lhs, PlannedInterpretable rhs) { + super(expr); + this.lhs = Preconditions.checkNotNull(lhs); + this.rhs = Preconditions.checkNotNull(rhs); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalOptionalOrValue.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalOptionalOrValue.java new file mode 100644 index 000000000..b64c6d433 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalOptionalOrValue.java @@ -0,0 +1,59 @@ +// 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.planner; + +import com.google.common.base.Preconditions; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.exceptions.CelOverloadNotFoundException; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; +import java.util.Optional; + +@Immutable +final class EvalOptionalOrValue extends PlannedInterpretable { + private final PlannedInterpretable lhs; + private final PlannedInterpretable rhs; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + Object lhsValue = EvalHelpers.evalStrictly(lhs, resolver, frame); + if (lhsValue instanceof AccumulatedUnknowns) { + return lhsValue; + } + + if (!(lhsValue instanceof Optional)) { + throw new CelOverloadNotFoundException("orValue"); + } + + Optional optionalLhs = (Optional) lhsValue; + if (optionalLhs.isPresent()) { + return optionalLhs.get(); + } + + return EvalHelpers.evalStrictly(rhs, resolver, frame); + } + + static EvalOptionalOrValue create( + CelExpr expr, PlannedInterpretable lhs, PlannedInterpretable rhs) { + return new EvalOptionalOrValue(expr, lhs, rhs); + } + + private EvalOptionalOrValue(CelExpr expr, PlannedInterpretable lhs, PlannedInterpretable rhs) { + super(expr); + this.lhs = Preconditions.checkNotNull(lhs); + this.rhs = Preconditions.checkNotNull(rhs); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalOptionalSelectField.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalOptionalSelectField.java new file mode 100644 index 000000000..4122a6e8e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalOptionalSelectField.java @@ -0,0 +1,99 @@ +// 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.planner; + +import com.google.common.base.Preconditions; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.values.CelValueConverter; +import dev.cel.common.values.SelectableValue; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; +import java.util.Map; +import java.util.Optional; + +@Immutable +final class EvalOptionalSelectField extends PlannedInterpretable { + private final PlannedInterpretable operand; + private final PlannedInterpretable selectAttribute; + private final String field; + private final CelValueConverter celValueConverter; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + Object operandValue = EvalHelpers.evalStrictly(operand, resolver, frame); + + if (operandValue instanceof Optional) { + Optional opt = (Optional) operandValue; + if (!opt.isPresent()) { + return Optional.empty(); + } + operandValue = opt.get(); + } + + Object runtimeOperandValue = celValueConverter.toRuntimeValue(operandValue); + if (runtimeOperandValue instanceof AccumulatedUnknowns) { + return runtimeOperandValue; + } + + boolean hasField = false; + + if (runtimeOperandValue instanceof SelectableValue) { + // Guaranteed to be a string. Anything other than string is an error. + @SuppressWarnings("unchecked") + SelectableValue selectableValue = (SelectableValue) runtimeOperandValue; + hasField = selectableValue.find(field).isPresent(); + } else if (runtimeOperandValue instanceof Map) { + hasField = ((Map) runtimeOperandValue).containsKey(field); + } + if (!hasField) { + return Optional.empty(); + } + + Object resultValue = EvalHelpers.evalStrictly(selectAttribute, resolver, frame); + + if (resultValue instanceof Optional) { + return resultValue; + } + + if (resultValue instanceof AccumulatedUnknowns) { + return resultValue; + } + + return Optional.of(resultValue); + } + + static EvalOptionalSelectField create( + CelExpr expr, + PlannedInterpretable operand, + String field, + PlannedInterpretable selectAttribute, + CelValueConverter celValueConverter) { + return new EvalOptionalSelectField(expr, operand, field, selectAttribute, celValueConverter); + } + + private EvalOptionalSelectField( + CelExpr expr, + PlannedInterpretable operand, + String field, + PlannedInterpretable selectAttribute, + CelValueConverter celValueConverter) { + super(expr); + this.operand = Preconditions.checkNotNull(operand); + this.field = Preconditions.checkNotNull(field); + this.selectAttribute = Preconditions.checkNotNull(selectAttribute); + this.celValueConverter = Preconditions.checkNotNull(celValueConverter); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalOr.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalOr.java new file mode 100644 index 000000000..849b6e7b4 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalOr.java @@ -0,0 +1,77 @@ +// Copyright 2025 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.planner; + +import static dev.cel.runtime.planner.EvalHelpers.evalNonstrictly; + +import com.google.common.base.Preconditions; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.values.ErrorValue; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; + +final class EvalOr extends PlannedInterpretable { + + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] args; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) { + ErrorValue errorValue = null; + AccumulatedUnknowns unknowns = null; + for (PlannedInterpretable arg : args) { + Object argVal = evalNonstrictly(arg, resolver, frame); + if (argVal instanceof Boolean) { + // Short-circuit on true + if (((boolean) argVal)) { + return true; + } + } else if (argVal instanceof ErrorValue) { + // Preserve the first encountered error instead of overwriting it with subsequent errors. + if (errorValue == null) { + errorValue = (ErrorValue) argVal; + } + } else if (argVal instanceof AccumulatedUnknowns) { + unknowns = AccumulatedUnknowns.maybeMerge(unknowns, argVal); + } else { + errorValue = + ErrorValue.create( + arg.expr().id(), + new IllegalArgumentException( + String.format("Expected boolean value, found: %s", argVal))); + } + } + + if (unknowns != null) { + return unknowns; + } + + if (errorValue != null) { + return errorValue; + } + + return false; + } + + static EvalOr create(CelExpr expr, PlannedInterpretable[] args) { + return new EvalOr(expr, args); + } + + private EvalOr(CelExpr expr, PlannedInterpretable[] args) { + super(expr); + Preconditions.checkArgument(args.length == 2); + this.args = args; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalTestOnly.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalTestOnly.java new file mode 100644 index 000000000..b3d2563f0 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalTestOnly.java @@ -0,0 +1,46 @@ +// Copyright 2025 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.planner; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.GlobalResolver; + +@Immutable +final class EvalTestOnly extends InterpretableAttribute { + + private final InterpretableAttribute attr; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + return attr.eval(resolver, frame); + } + + @Override + public EvalTestOnly addQualifier(CelExpr expr, Qualifier qualifier) { + PresenceTestQualifier presenceTestQualifier = PresenceTestQualifier.create(qualifier.value()); + return new EvalTestOnly(expr(), attr.addQualifier(expr, presenceTestQualifier)); + } + + static EvalTestOnly create(CelExpr expr, InterpretableAttribute attr) { + return new EvalTestOnly(expr, attr); + } + + private EvalTestOnly(CelExpr expr, InterpretableAttribute attr) { + super(expr); + this.attr = attr; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalUnary.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalUnary.java new file mode 100644 index 000000000..867371ff1 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalUnary.java @@ -0,0 +1,63 @@ +// Copyright 2025 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.planner; + +import static dev.cel.runtime.planner.EvalHelpers.evalNonstrictly; +import static dev.cel.runtime.planner.EvalHelpers.evalStrictly; + +import dev.cel.common.ast.CelExpr; +import dev.cel.common.values.CelValueConverter; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelResolvedOverload; +import dev.cel.runtime.GlobalResolver; + +final class EvalUnary extends PlannedInterpretable { + + private final String functionName; + private final CelResolvedOverload resolvedOverload; + private final PlannedInterpretable arg; + private final CelValueConverter celValueConverter; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + Object argVal = + resolvedOverload.isStrict() + ? evalStrictly(arg, resolver, frame) + : evalNonstrictly(arg, resolver, frame); + return EvalHelpers.dispatch(functionName, resolvedOverload, celValueConverter, argVal); + } + + static EvalUnary create( + CelExpr expr, + String functionName, + CelResolvedOverload resolvedOverload, + PlannedInterpretable arg, + CelValueConverter celValueConverter) { + return new EvalUnary(expr, functionName, resolvedOverload, arg, celValueConverter); + } + + private EvalUnary( + CelExpr expr, + String functionName, + CelResolvedOverload resolvedOverload, + PlannedInterpretable arg, + CelValueConverter celValueConverter) { + super(expr); + this.functionName = functionName; + this.resolvedOverload = resolvedOverload; + this.arg = arg; + this.celValueConverter = celValueConverter; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalVarArgsCall.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalVarArgsCall.java new file mode 100644 index 000000000..4b0171b8f --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalVarArgsCall.java @@ -0,0 +1,79 @@ +// Copyright 2025 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.planner; + +import static dev.cel.runtime.planner.EvalHelpers.evalNonstrictly; +import static dev.cel.runtime.planner.EvalHelpers.evalStrictly; + +import dev.cel.common.ast.CelExpr; +import dev.cel.common.values.CelValueConverter; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelResolvedOverload; +import dev.cel.runtime.GlobalResolver; + +final class EvalVarArgsCall extends PlannedInterpretable { + + private final String functionName; + private final CelResolvedOverload resolvedOverload; + + @SuppressWarnings("Immutable") + private final PlannedInterpretable[] args; + + private final CelValueConverter celValueConverter; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + Object[] argVals = new Object[args.length]; + AccumulatedUnknowns unknowns = null; + for (int i = 0; i < args.length; i++) { + PlannedInterpretable arg = args[i]; + argVals[i] = + resolvedOverload.isStrict() + ? evalStrictly(arg, resolver, frame) + : evalNonstrictly(arg, resolver, frame); + + unknowns = AccumulatedUnknowns.maybeMerge(unknowns, argVals[i]); + } + + if (unknowns != null) { + return unknowns; + } + + return EvalHelpers.dispatch(functionName, resolvedOverload, celValueConverter, argVals); + } + + static EvalVarArgsCall create( + CelExpr expr, + String functionName, + CelResolvedOverload resolvedOverload, + PlannedInterpretable[] args, + CelValueConverter celValueConverter) { + return new EvalVarArgsCall(expr, functionName, resolvedOverload, args, celValueConverter); + } + + private EvalVarArgsCall( + CelExpr expr, + String functionName, + CelResolvedOverload resolvedOverload, + PlannedInterpretable[] args, + CelValueConverter celValueConverter) { + super(expr); + this.functionName = functionName; + this.resolvedOverload = resolvedOverload; + this.args = args; + this.celValueConverter = celValueConverter; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalZeroArity.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalZeroArity.java new file mode 100644 index 000000000..6e35bc22b --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/EvalZeroArity.java @@ -0,0 +1,53 @@ +// Copyright 2025 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.planner; + +import dev.cel.common.ast.CelExpr; +import dev.cel.common.values.CelValueConverter; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelResolvedOverload; +import dev.cel.runtime.GlobalResolver; + +final class EvalZeroArity extends PlannedInterpretable { + private static final Object[] EMPTY_ARRAY = new Object[0]; + + private final String functionName; + private final CelResolvedOverload resolvedOverload; + private final CelValueConverter celValueConverter; + + @Override + Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + return EvalHelpers.dispatch(functionName, resolvedOverload, celValueConverter, EMPTY_ARRAY); + } + + static EvalZeroArity create( + CelExpr expr, + String functionName, + CelResolvedOverload resolvedOverload, + CelValueConverter celValueConverter) { + return new EvalZeroArity(expr, functionName, resolvedOverload, celValueConverter); + } + + private EvalZeroArity( + CelExpr expr, + String functionName, + CelResolvedOverload resolvedOverload, + CelValueConverter celValueConverter) { + super(expr); + this.functionName = functionName; + this.resolvedOverload = resolvedOverload; + this.celValueConverter = celValueConverter; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/ExecutionFrame.java b/runtime/src/main/java/dev/cel/runtime/planner/ExecutionFrame.java new file mode 100644 index 000000000..b67f5520c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/ExecutionFrame.java @@ -0,0 +1,94 @@ +// Copyright 2025 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.planner; + +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelIterationLimitExceededException; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelEvaluationListener; +import dev.cel.runtime.CelFunctionResolver; +import dev.cel.runtime.CelResolvedOverload; +import dev.cel.runtime.PartialVars; +import java.util.Collection; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** Tracks execution context within a planned program. */ +final class ExecutionFrame { + + private final int comprehensionIterationLimit; + private final CelFunctionResolver functionResolver; + private final PartialVars partialVars; + private final @Nullable CelEvaluationListener listener; + private int iterationCount; + private BlockMemoizer blockMemoizer; + + Optional findOverload( + String functionName, Collection overloadIds, Object[] args) + throws CelEvaluationException { + if (overloadIds.isEmpty()) { + return functionResolver.findOverloadMatchingArgs(functionName, args); + } + return functionResolver.findOverloadMatchingArgs(functionName, overloadIds, args); + } + + void incrementIterations() { + if (comprehensionIterationLimit < 0) { + return; + } + if (++iterationCount > comprehensionIterationLimit) { + throw new CelIterationLimitExceededException(comprehensionIterationLimit); + } + } + + void setBlockMemoizer(BlockMemoizer blockMemoizer) { + if (this.blockMemoizer != null) { + throw new IllegalStateException("BlockMemoizer is already initialized"); + } + this.blockMemoizer = blockMemoizer; + } + + BlockMemoizer getBlockMemoizer() { + return blockMemoizer; + } + + static ExecutionFrame create( + CelFunctionResolver functionResolver, + CelOptions celOptions, + @Nullable PartialVars partialVars, + @Nullable CelEvaluationListener listener) { + return new ExecutionFrame( + functionResolver, celOptions.comprehensionMaxIterations(), partialVars, listener); + } + + Optional partialVars() { + return Optional.ofNullable(partialVars); + } + + @Nullable CelEvaluationListener getListener() { + return listener; + } + + private ExecutionFrame( + CelFunctionResolver functionResolver, + int limit, + @Nullable PartialVars partialVars, + @Nullable CelEvaluationListener listener) { + this.comprehensionIterationLimit = limit; + this.functionResolver = functionResolver; + this.partialVars = partialVars; + this.listener = listener; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/InterpretableAttribute.java b/runtime/src/main/java/dev/cel/runtime/planner/InterpretableAttribute.java new file mode 100644 index 000000000..9ce726f0e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/InterpretableAttribute.java @@ -0,0 +1,28 @@ +// Copyright 2025 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.planner; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; + +@Immutable +abstract class InterpretableAttribute extends PlannedInterpretable { + + abstract InterpretableAttribute addQualifier(CelExpr expr, Qualifier qualifier); + + InterpretableAttribute(CelExpr expr) { + super(expr); + } +} \ No newline at end of file diff --git a/runtime/src/main/java/dev/cel/runtime/planner/LocalizedEvaluationException.java b/runtime/src/main/java/dev/cel/runtime/planner/LocalizedEvaluationException.java new file mode 100644 index 000000000..603f0b0a5 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/LocalizedEvaluationException.java @@ -0,0 +1,46 @@ +// 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.planner; + +import dev.cel.common.CelErrorCode; +import dev.cel.common.exceptions.CelRuntimeException; + +/** + * Wraps a {@link CelRuntimeException} with its source expression ID for error reporting. + * + *

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. + * + *

Note: This exception should not be surfaced directly to users - it's unwrapped in {@link + * PlannedProgram}. + */ +final class LocalizedEvaluationException extends CelRuntimeException { + + private final long exprId; + + long exprId() { + return exprId; + } + + LocalizedEvaluationException(CelRuntimeException cause, long exprId) { + this(cause, cause.getErrorCode(), exprId); + } + + LocalizedEvaluationException(Throwable cause, CelErrorCode errorCode, long exprId) { + super(cause, errorCode); + this.exprId = exprId; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/MaybeAttribute.java b/runtime/src/main/java/dev/cel/runtime/planner/MaybeAttribute.java new file mode 100644 index 000000000..1506eb180 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/MaybeAttribute.java @@ -0,0 +1,81 @@ +// Copyright 2025 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.planner; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import dev.cel.runtime.GlobalResolver; + +/** + * An attribute that attempts to resolve a variable against a list of potential namespaced + * attributes. This is used during parsed-only evaluation. + */ +@Immutable +final class MaybeAttribute implements Attribute { + private final AttributeFactory attrFactory; + private final ImmutableList attributes; + + @Override + public Object resolve(long exprId, GlobalResolver ctx, ExecutionFrame frame) { + MissingAttribute maybeError = null; + for (NamespacedAttribute attr : attributes) { + Object value = attr.resolve(exprId, ctx, frame); + if (value == null) { + continue; + } + + if (value instanceof MissingAttribute) { + maybeError = (MissingAttribute) value; + // When the variable is missing in a maybe attribute, defer erroring. + // The variable may exist in other namespaced attributes. + continue; + } + + return value; + } + + return maybeError; + } + + @Override + public Attribute addQualifier(Qualifier qualifier) { + Object strQualifier = qualifier.value(); + ImmutableList.Builder augmentedNamesBuilder = ImmutableList.builder(); + ImmutableList.Builder attributesBuilder = ImmutableList.builder(); + for (NamespacedAttribute attr : attributes) { + if (strQualifier instanceof String && attr.qualifiers().isEmpty()) { + for (String varName : attr.candidateVariableNames()) { + augmentedNamesBuilder.add(varName + "." + strQualifier); + } + } + + attributesBuilder.add(attr.addQualifier(qualifier)); + } + ImmutableList augmentedNames = augmentedNamesBuilder.build(); + ImmutableList.Builder namespacedAttributeBuilder = ImmutableList.builder(); + if (!augmentedNames.isEmpty()) { + namespacedAttributeBuilder.add( + attrFactory.newAbsoluteAttribute(augmentedNames.toArray(new String[0]))); + } + + namespacedAttributeBuilder.addAll(attributesBuilder.build()); + return new MaybeAttribute(attrFactory, namespacedAttributeBuilder.build()); + } + + MaybeAttribute(AttributeFactory attrFactory, ImmutableList attributes) { + this.attrFactory = attrFactory; + this.attributes = attributes; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/MissingAttribute.java b/runtime/src/main/java/dev/cel/runtime/planner/MissingAttribute.java new file mode 100644 index 000000000..b7fb8ad72 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/MissingAttribute.java @@ -0,0 +1,65 @@ +// Copyright 2025 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.planner; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.exceptions.CelAttributeNotFoundException; +import dev.cel.runtime.GlobalResolver; + +/** Represents a missing attribute that is surfaced while resolving a struct field or a map key. */ +final class MissingAttribute implements Attribute { + + private final ImmutableSet missingAttributes; + private final Kind kind; + + @Override + public Object resolve(long exprId, GlobalResolver ctx, ExecutionFrame frame) { + switch (kind) { + case ATTRIBUTE_NOT_FOUND: + throw CelAttributeNotFoundException.forMissingAttributes(missingAttributes); + case FIELD_NOT_FOUND: + throw CelAttributeNotFoundException.forFieldResolution(missingAttributes); + } + + throw new IllegalArgumentException("Unexpected kind: " + kind); + } + + @Override + public Attribute addQualifier(Qualifier qualifier) { + throw new UnsupportedOperationException("Unsupported operation"); + } + + static MissingAttribute newMissingAttribute(ImmutableSet attributeNames) { + return new MissingAttribute(attributeNames, Kind.ATTRIBUTE_NOT_FOUND); + } + + static MissingAttribute newMissingField(String... attributeNames) { + return newMissingField(ImmutableSet.copyOf(attributeNames)); + } + + static MissingAttribute newMissingField(ImmutableSet attributeNames) { + return new MissingAttribute(attributeNames, Kind.FIELD_NOT_FOUND); + } + + private MissingAttribute(ImmutableSet missingAttributes, Kind kind) { + this.missingAttributes = missingAttributes; + this.kind = kind; + } + + private enum Kind { + ATTRIBUTE_NOT_FOUND, + FIELD_NOT_FOUND + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/NamespacedAttribute.java b/runtime/src/main/java/dev/cel/runtime/planner/NamespacedAttribute.java new file mode 100644 index 000000000..95a4489fd --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/NamespacedAttribute.java @@ -0,0 +1,245 @@ +// Copyright 2025 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.planner; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.EnumType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelValueConverter; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.CelAttribute; +import dev.cel.runtime.CelAttributePattern; +import dev.cel.runtime.GlobalResolver; +import dev.cel.runtime.InterpreterUtil; +import dev.cel.runtime.PartialVars; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +@Immutable +final class NamespacedAttribute implements Attribute { + private final boolean disambiguateNames; + private final ImmutableMap candidateAttributes; + private final ImmutableList qualifiers; + private final CelValueConverter celValueConverter; + private final CelTypeProvider typeProvider; + + ImmutableList qualifiers() { + return qualifiers; + } + + ImmutableSet candidateVariableNames() { + return candidateAttributes.keySet(); + } + + @Override + public Object resolve(long exprId, GlobalResolver ctx, ExecutionFrame frame) { + GlobalResolver inputVars = ctx; + // Unwrap any local activations to ensure that we reach the variables provided as input + // to the expression in the event that we need to disambiguate between global and local + // variables. + if (disambiguateNames) { + inputVars = unwrapToNonLocal(ctx); + } + + for (Map.Entry entry : candidateAttributes.entrySet()) { + String name = entry.getKey(); + CelAttribute attr = entry.getValue(); + + GlobalResolver resolver = ctx; + if (disambiguateNames) { + resolver = inputVars; + } + + Object value = resolver.resolve(name); + value = InterpreterUtil.maybeAdaptToAccumulatedUnknowns(value); + + PartialVars partialVars = frame.partialVars().orElse(null); + + if (partialVars != null && !isLocallyBound(resolver, name)) { + ImmutableList patterns = partialVars.unknowns(); + // Avoid enhanced for loop to prevent UnmodifiableIterator from being allocated + for (int i = 0; i < qualifiers.size(); i++) { + attr = attr.qualify(CelAttribute.Qualifier.fromGeneric(qualifiers.get(i).value())); + } + + CelAttributePattern partialMatch = findPartialMatchingPattern(attr, patterns).orElse(null); + if (partialMatch != null) { + return AccumulatedUnknowns.create( + ImmutableList.of(exprId), ImmutableList.of(partialMatch.simplify(attr))); + } + } + + if (value != null) { + return applyQualifiers(value, celValueConverter, qualifiers); + } + + // Attempt to resolve the qualify type name if the name is not a variable identifier + value = findIdent(name); + if (value != null) { + return value; + } + } + + return MissingAttribute.newMissingAttribute(candidateAttributes.keySet()); + } + + private @Nullable Object findIdent(String name) { + CelType type = typeProvider.findType(name).orElse(null); + // If the name resolves directly, this is a fully qualified type name + // (ex: 'int' or 'google.protobuf.Timestamp') + if (type != null) { + if (qualifiers.isEmpty()) { + // Resolution of a fully qualified type name: foo.bar.baz + if (type instanceof TypeType) { + // Coalesce all type(foo) "type" into a sentinel runtime type to allow for + // erasure based type comparisons + return TypeType.create(SimpleType.DYN); + } + + return TypeType.create(type); + } + + throw new IllegalStateException( + "Unexpected type resolution when there were remaining qualifiers: " + type.name()); + } + + // The name itself could be a fully qualified reference to an enum value + // (e.g: my.enum_type.BAR) + int lastDotIndex = name.lastIndexOf('.'); + if (lastDotIndex > 0) { + String enumTypeName = name.substring(0, lastDotIndex); + String enumValueQualifier = name.substring(lastDotIndex + 1); + + return typeProvider + .findType(enumTypeName) + .filter(EnumType.class::isInstance) + .map(EnumType.class::cast) + .map(enumType -> getEnumValue(enumType, enumValueQualifier)) + .orElse(null); + } + + return null; + } + + private static Long getEnumValue(EnumType enumType, String field) { + return enumType + .findNumberByName(field) + .map(Integer::longValue) + .orElseThrow( + () -> + new NoSuchElementException( + String.format("Field %s was not found on enum %s", enumType.name(), field))); + } + + private boolean isLocallyBound(GlobalResolver resolver, String name) { + while (resolver instanceof ActivationWrapper) { + ActivationWrapper wrapper = (ActivationWrapper) resolver; + if (wrapper.isLocallyBound(name)) { + return true; + } + resolver = wrapper.unwrap(); + } + return false; + } + + private GlobalResolver unwrapToNonLocal(GlobalResolver resolver) { + while (resolver instanceof ActivationWrapper) { + resolver = ((ActivationWrapper) resolver).unwrap(); + } + return resolver; + } + + @Override + public NamespacedAttribute addQualifier(Qualifier qualifier) { + return new NamespacedAttribute( + typeProvider, + celValueConverter, + candidateAttributes, + disambiguateNames, + ImmutableList.builderWithExpectedSize(qualifiers.size() + 1) + .addAll(qualifiers) + .add(qualifier) + .build()); + } + + private static Object applyQualifiers( + Object value, CelValueConverter celValueConverter, ImmutableList qualifiers) { + Object obj = celValueConverter.toRuntimeValue(value); + + // Avoid enhanced for loop to prevent UnmodifiableIterator from being allocated + for (int i = 0; i < qualifiers.size(); i++) { + Qualifier element = qualifiers.get(i); + obj = element.qualify(obj); + obj = celValueConverter.toRuntimeValue(obj); + } + + return celValueConverter.maybeUnwrap(obj); + } + + private static Optional findPartialMatchingPattern( + CelAttribute attr, ImmutableList patterns) { + for (CelAttributePattern pattern : patterns) { + if (pattern.isPartialMatch(attr)) { + return Optional.of(pattern); + } + } + return Optional.empty(); + } + + static NamespacedAttribute create( + CelTypeProvider typeProvider, + CelValueConverter celValueConverter, + ImmutableSet namespacedNames) { + ImmutableMap.Builder attributesBuilder = ImmutableMap.builder(); + boolean disambiguateNames = false; + + for (String name : namespacedNames) { + String baseName = name; + if (name.startsWith(".")) { + disambiguateNames = true; + baseName = name.substring(1); + } + attributesBuilder.put(baseName, CelAttribute.fromQualifiedIdentifier(baseName)); + } + + return new NamespacedAttribute( + typeProvider, + celValueConverter, + attributesBuilder.buildOrThrow(), + disambiguateNames, + ImmutableList.of()); + } + + private NamespacedAttribute( + CelTypeProvider typeProvider, + CelValueConverter celValueConverter, + ImmutableMap candidateAttributes, + boolean disambiguateNames, + ImmutableList qualifiers) { + this.typeProvider = typeProvider; + this.celValueConverter = celValueConverter; + this.candidateAttributes = candidateAttributes; + this.disambiguateNames = disambiguateNames; + this.qualifiers = qualifiers; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/PlannedInterpretable.java b/runtime/src/main/java/dev/cel/runtime/planner/PlannedInterpretable.java new file mode 100644 index 000000000..6bdeaf1df --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/PlannedInterpretable.java @@ -0,0 +1,48 @@ +// Copyright 2025 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.planner; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.ast.CelExpr; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelEvaluationListener; +import dev.cel.runtime.GlobalResolver; +import dev.cel.runtime.InterpreterUtil; + +@Immutable +abstract class PlannedInterpretable { + private final CelExpr expr; + + /** Runs interpretation with the given activation which supplies name/value bindings. */ + final Object eval(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException { + Object result = evalInternal(resolver, frame); + CelEvaluationListener listener = frame.getListener(); + if (listener != null) { + listener.callback(expr, InterpreterUtil.maybeAdaptToCelUnknownSet(result)); + } + return result; + } + + abstract Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) + throws CelEvaluationException; + + CelExpr expr() { + return expr; + } + + PlannedInterpretable(CelExpr expr) { + this.expr = expr; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/PlannedProgram.java b/runtime/src/main/java/dev/cel/runtime/planner/PlannedProgram.java new file mode 100644 index 000000000..1470e4909 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/PlannedProgram.java @@ -0,0 +1,194 @@ +// Copyright 2025 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.planner; + +import com.google.auto.value.AutoValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelOptions; +import dev.cel.common.annotations.Internal; +import dev.cel.common.exceptions.CelRuntimeException; +import dev.cel.common.values.ErrorValue; +import dev.cel.runtime.Activation; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelEvaluationExceptionBuilder; +import dev.cel.runtime.CelEvaluationListener; +import dev.cel.runtime.CelFunctionResolver; +import dev.cel.runtime.CelResolvedOverload; +import dev.cel.runtime.CelVariableResolver; +import dev.cel.runtime.GlobalResolver; +import dev.cel.runtime.InterpreterUtil; +import dev.cel.runtime.PartialVars; +import dev.cel.runtime.Program; +import java.util.Collection; +import java.util.Map; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** + * Internal implementation of a {@link Program} that executes a planned interpretable tree. + * + *

CEL-Java internals. Do not use. + */ +@Internal +@Immutable +@AutoValue +public abstract class PlannedProgram implements Program { + + private static final CelFunctionResolver EMPTY_FUNCTION_RESOLVER = + new CelFunctionResolver() { + @Override + public Optional findOverloadMatchingArgs( + String functionName, Collection overloadIds, Object[] args) { + return Optional.empty(); + } + + @Override + public Optional findOverloadMatchingArgs( + String functionName, Object[] args) { + return Optional.empty(); + } + }; + + public abstract PlannedInterpretable interpretable(); + + abstract ErrorMetadata metadata(); + + public abstract CelOptions options(); + + @Override + public Object eval() throws CelEvaluationException { + return evalOrThrow( + interpretable(), + GlobalResolver.EMPTY, + EMPTY_FUNCTION_RESOLVER, + /* partialVars= */ null, + /* listener= */ null); + } + + @Override + public Object eval(Map mapValue) throws CelEvaluationException { + return evalOrThrow( + interpretable(), + Activation.copyOf(mapValue), + EMPTY_FUNCTION_RESOLVER, + /* partialVars= */ null, + /* listener= */ null); + } + + @Override + public Object eval(Map mapValue, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException { + return evalOrThrow( + interpretable(), + Activation.copyOf(mapValue), + lateBoundFunctionResolver, + /* partialVars= */ null, + /* listener= */ null); + } + + @Override + public Object eval(CelVariableResolver resolver) throws CelEvaluationException { + return evalOrThrow( + interpretable(), + (name) -> resolver.find(name).orElse(null), + EMPTY_FUNCTION_RESOLVER, + /* partialVars= */ null, + /* listener= */ null); + } + + @Override + public Object eval(CelVariableResolver resolver, CelFunctionResolver lateBoundFunctionResolver) + throws CelEvaluationException { + return evalOrThrow( + interpretable(), + (name) -> resolver.find(name).orElse(null), + lateBoundFunctionResolver, + /* partialVars= */ null, + /* listener= */ null); + } + + @Override + public Object eval(PartialVars partialVars) throws CelEvaluationException { + return evalOrThrow( + interpretable(), + (name) -> partialVars.resolver().find(name).orElse(null), + EMPTY_FUNCTION_RESOLVER, + partialVars, + /* listener= */ null); + } + + public Object evalOrThrow( + PlannedInterpretable interpretable, + GlobalResolver resolver, + CelFunctionResolver functionResolver, + @Nullable PartialVars partialVars, + @Nullable CelEvaluationListener listener) + throws CelEvaluationException { + try { + ExecutionFrame frame = + ExecutionFrame.create(functionResolver, options(), partialVars, listener); + Object evalResult = interpretable.eval(resolver, frame); + if (evalResult instanceof ErrorValue) { + ErrorValue errorValue = (ErrorValue) evalResult; + throw newCelEvaluationException(errorValue.exprId(), errorValue.value()); + } + + return InterpreterUtil.maybeAdaptToCelUnknownSet(evalResult); + } catch (RuntimeException e) { + throw newCelEvaluationException(interpretable.expr().id(), e); + } + } + + public Object trace( + GlobalResolver resolver, + CelFunctionResolver functionResolver, + PartialVars partialVars, + CelEvaluationListener listener) + throws CelEvaluationException { + return evalOrThrow(interpretable(), resolver, functionResolver, partialVars, listener); + } + + private CelEvaluationException newCelEvaluationException(long exprId, Exception e) { + CelEvaluationExceptionBuilder builder; + if (e instanceof LocalizedEvaluationException) { + // Use the localized expr ID (most specific error location) + LocalizedEvaluationException localized = (LocalizedEvaluationException) e; + exprId = localized.exprId(); + Throwable cause = localized.getCause(); + if (cause instanceof CelRuntimeException) { + builder = + CelEvaluationExceptionBuilder.newBuilder((CelRuntimeException) localized.getCause()); + } else { + builder = CelEvaluationExceptionBuilder.newBuilder(cause.getMessage()).setCause(cause); + } + } else if (e instanceof CelRuntimeException) { + builder = CelEvaluationExceptionBuilder.newBuilder((CelRuntimeException) e); + } else { + // Unhandled function dispatch failures wraps the original exception with a descriptive + // message + // (e.g: "Function foo failed with...") + // We need to unwrap the cause here to preserve the original exception message and its cause. + Throwable cause = e.getCause() != null ? e.getCause() : e; + builder = CelEvaluationExceptionBuilder.newBuilder(e.getMessage()).setCause(cause); + } + + return builder.setMetadata(metadata(), exprId).build(); + } + + static Program create( + PlannedInterpretable interpretable, ErrorMetadata metadata, CelOptions options) { + return new AutoValue_PlannedProgram(interpretable, metadata, options); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/PresenceTestQualifier.java b/runtime/src/main/java/dev/cel/runtime/planner/PresenceTestQualifier.java new file mode 100644 index 000000000..5c2cba1ed --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/PresenceTestQualifier.java @@ -0,0 +1,53 @@ +// Copyright 2025 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.planner; + +import static dev.cel.runtime.planner.MissingAttribute.newMissingField; + +import dev.cel.common.values.SelectableValue; +import java.util.Map; + +/** A qualifier for presence testing a field or a map key. */ +final class PresenceTestQualifier implements Qualifier { + + @SuppressWarnings("Immutable") + private final Object value; + + @Override + public Object value() { + return value; + } + + @Override + @SuppressWarnings("unchecked") // SelectableValue cast is safe + public Object qualify(Object obj) { + if (obj instanceof SelectableValue) { + return ((SelectableValue) obj).find(value).isPresent(); + } else if (obj instanceof Map) { + Map map = (Map) obj; + return map.containsKey(value); + } + + return newMissingField(value.toString()); + } + + static PresenceTestQualifier create(Object value) { + return new PresenceTestQualifier(value); + } + + private PresenceTestQualifier(Object value) { + this.value = value; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/ProgramPlanner.java b/runtime/src/main/java/dev/cel/runtime/planner/ProgramPlanner.java new file mode 100644 index 000000000..e38d08f8f --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/ProgramPlanner.java @@ -0,0 +1,731 @@ +// Copyright 2025 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.planner; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.Operator; +import dev.cel.common.annotations.Internal; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelCall; +import dev.cel.common.ast.CelExpr.CelComprehension; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.common.ast.CelExpr.CelStruct.Entry; +import dev.cel.common.ast.CelReference; +import dev.cel.common.exceptions.CelOverloadNotFoundException; +import dev.cel.common.types.CelKind; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelValueConverter; +import dev.cel.common.values.CelValueProvider; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelEvaluationExceptionBuilder; +import dev.cel.runtime.CelResolvedOverload; +import dev.cel.runtime.DefaultDispatcher; +import dev.cel.runtime.Program; +import java.util.HashMap; +import java.util.NoSuchElementException; +import java.util.Optional; +import org.jspecify.annotations.Nullable; + +/** + * {@code ProgramPlanner} resolves functions, types, and identifiers at plan time given a + * parsed-only or a type-checked expression. + */ +@Immutable +@Internal +public final class ProgramPlanner { + private final CelTypeProvider typeProvider; + private final CelValueProvider valueProvider; + private final DefaultDispatcher dispatcher; + private final AttributeFactory attributeFactory; + private final CelContainer container; + private final CelOptions options; + private final CelValueConverter celValueConverter; + private final ImmutableSet lateBoundFunctionNames; + + /** + * Plans a {@link Program} from the provided parsed-only or type-checked {@link + * CelAbstractSyntaxTree}. + */ + public Program plan(CelAbstractSyntaxTree ast) throws CelEvaluationException { + PlannedInterpretable plannedInterpretable; + ErrorMetadata errorMetadata = + ErrorMetadata.create(ast.getSource().getPositionsMap(), ast.getSource().getDescription()); + try { + plannedInterpretable = plan(ast.getExpr(), PlannerContext.create(ast)); + } catch (RuntimeException e) { + throw CelEvaluationExceptionBuilder.newBuilder(e.getMessage()) + .setMetadata(errorMetadata, ast.getExpr().id()) + .setCause(e) + .build(); + } + + return PlannedProgram.create(plannedInterpretable, errorMetadata, options); + } + + private PlannedInterpretable plan(CelExpr celExpr, PlannerContext ctx) { + switch (celExpr.getKind()) { + case CONSTANT: + return planConstant(celExpr, celExpr.constant()); + case IDENT: + return planIdent(celExpr, ctx); + case SELECT: + return planSelect(celExpr, ctx); + case CALL: + return planCall(celExpr, ctx); + case LIST: + return planCreateList(celExpr, ctx); + case STRUCT: + return planCreateStruct(celExpr, ctx); + case MAP: + return planCreateMap(celExpr, ctx); + case COMPREHENSION: + return planComprehension(celExpr, ctx); + case NOT_SET: + throw new UnsupportedOperationException("Unsupported kind: " + celExpr.getKind()); + default: + throw new UnsupportedOperationException("Unexpected kind: " + celExpr.getKind()); + } + } + + private PlannedInterpretable planSelect(CelExpr celExpr, PlannerContext ctx) { + CelSelect select = celExpr.select(); + PlannedInterpretable operand = plan(select.operand(), ctx); + + InterpretableAttribute attribute; + if (operand instanceof EvalAttribute) { + attribute = (EvalAttribute) operand; + } else { + attribute = EvalAttribute.create(celExpr, attributeFactory.newRelativeAttribute(operand)); + } + + if (select.testOnly()) { + attribute = EvalTestOnly.create(celExpr, attribute); + } + + Qualifier qualifier = StringQualifier.create(select.field()); + + return attribute.addQualifier(celExpr, qualifier); + } + + private PlannedInterpretable planConstant(CelExpr expr, CelConstant celConstant) { + switch (celConstant.getKind()) { + case NULL_VALUE: + return EvalConstant.create(expr, celConstant.nullValue()); + case BOOLEAN_VALUE: + return EvalConstant.create(expr, celConstant.booleanValue()); + case INT64_VALUE: + return EvalConstant.create(expr, celConstant.int64Value()); + case UINT64_VALUE: + return EvalConstant.create(expr, celConstant.uint64Value()); + case DOUBLE_VALUE: + return EvalConstant.create(expr, celConstant.doubleValue()); + case STRING_VALUE: + return EvalConstant.create(expr, celConstant.stringValue()); + case BYTES_VALUE: + return EvalConstant.create(expr, celConstant.bytesValue()); + default: + throw new IllegalStateException("Unsupported kind: " + celConstant.getKind()); + } + } + + private PlannedInterpretable planIdent(CelExpr celExpr, PlannerContext ctx) { + CelReference ref = ctx.referenceMap().get(celExpr.id()); + if (ref != null) { + return planCheckedIdent(celExpr, ref, ctx.typeMap()); + } + + String identName = celExpr.ident().name(); + PlannedInterpretable blockSlot = maybeInterceptBlockSlot(celExpr, identName).orElse(null); + if (blockSlot != null) { + return blockSlot; + } + + if (ctx.isLocalVar(identName)) { + return EvalAttribute.create(celExpr, attributeFactory.newAbsoluteAttribute(identName)); + } + + return EvalAttribute.create(celExpr, attributeFactory.newMaybeAttribute(identName)); + } + + private PlannedInterpretable planCheckedIdent( + CelExpr expr, CelReference identRef, ImmutableMap typeMap) { + if (identRef.value().isPresent()) { + return planConstant(expr, identRef.value().get()); + } + + CelType type = typeMap.get(expr.id()); + if (type.kind().equals(CelKind.TYPE)) { + TypeType identType = + typeProvider + .findType(identRef.name()) + .map( + t -> + (t instanceof TypeType) + // Coalesce all type(foo) "type" into a sentinel runtime type to allow for + // erasure based type comparisons + ? TypeType.create(SimpleType.DYN) + : TypeType.create(t)) + .orElseThrow( + () -> + new NoSuchElementException( + "Reference to an undefined type: " + identRef.name())); + return EvalConstant.create(expr, identType); + } + + String identName = identRef.name(); + PlannedInterpretable blockSlot = maybeInterceptBlockSlot(expr, identName).orElse(null); + if (blockSlot != null) { + return blockSlot; + } + + return EvalAttribute.create(expr, attributeFactory.newAbsoluteAttribute(identRef.name())); + } + + private Optional maybeInterceptBlockSlot(CelExpr expr, String identName) { + if (!identName.startsWith("@index")) { + return Optional.empty(); + } + if (identName.length() <= 6) { + throw new IllegalArgumentException("Malformed block slot identifier: " + identName); + } + try { + int slotIndex = Integer.parseInt(identName.substring(6)); + if (slotIndex < 0) { + throw new IllegalArgumentException("Negative block slot index: " + identName); + } + return Optional.of(EvalBlock.EvalBlockSlot.create(expr, slotIndex)); + } catch (NumberFormatException e) { + throw new IllegalArgumentException("Invalid block slot index: " + identName, e); + } + } + + private PlannedInterpretable planCall(CelExpr expr, PlannerContext ctx) { + ResolvedFunction resolvedFunction = resolveFunction(expr, ctx.referenceMap()); + String functionName = resolvedFunction.functionName(); + + PlannedInterpretable blockCall = maybeInterceptBlockCall(functionName, expr, ctx).orElse(null); + if (blockCall != null) { + return blockCall; + } + + CelExpr target = resolvedFunction.target().orElse(null); + int argCount = expr.call().args().size(); + if (target != null) { + argCount++; + } + + PlannedInterpretable[] evaluatedArgs = new PlannedInterpretable[argCount]; + + int offset = 0; + if (target != null) { + evaluatedArgs[0] = plan(target, ctx); + offset++; + } + + ImmutableList args = expr.call().args(); + for (int argIndex = 0; argIndex < args.size(); argIndex++) { + evaluatedArgs[argIndex + offset] = plan(args.get(argIndex), ctx); + } + + Operator operator = Operator.findReverse(functionName).orElse(null); + if (operator != null) { + switch (operator) { + case LOGICAL_OR: + return options.enableShortCircuiting() + ? EvalOr.create(expr, evaluatedArgs) + : EvalExhaustiveOr.create(expr, evaluatedArgs); + case LOGICAL_AND: + return options.enableShortCircuiting() + ? EvalAnd.create(expr, evaluatedArgs) + : EvalExhaustiveAnd.create(expr, evaluatedArgs); + case CONDITIONAL: + return options.enableShortCircuiting() + ? EvalConditional.create(expr, evaluatedArgs) + : EvalExhaustiveConditional.create(expr, evaluatedArgs); + default: + // fall-through + } + } + + CelResolvedOverload resolvedOverload = null; + if (resolvedFunction.overloadId().isPresent()) { + resolvedOverload = dispatcher.findOverload(resolvedFunction.overloadId().get()).orElse(null); + } + + if (resolvedOverload == null) { + // Parsed-only function dispatch + resolvedOverload = dispatcher.findOverload(functionName).orElse(null); + } + + PlannedInterpretable optionalCall = + maybeInterceptOptionalCalls(resolvedOverload, functionName, evaluatedArgs, expr) + .orElse(null); + if (optionalCall != null) { + return optionalCall; + } + + if (resolvedOverload == null) { + if (!lateBoundFunctionNames.contains(functionName)) { + CelReference reference = ctx.referenceMap().get(expr.id()); + if (reference != null) { + throw new CelOverloadNotFoundException(functionName, reference.overloadIds()); + } else { + throw new CelOverloadNotFoundException(functionName); + } + } + + ImmutableList overloadIds = ImmutableList.of(); + if (resolvedFunction.overloadId().isPresent()) { + overloadIds = ImmutableList.of(resolvedFunction.overloadId().get()); + } + + return EvalLateBoundCall.create( + expr, functionName, overloadIds, evaluatedArgs, celValueConverter); + } + + switch (argCount) { + case 0: + return EvalZeroArity.create(expr, functionName, resolvedOverload, celValueConverter); + case 1: + return EvalUnary.create( + expr, functionName, resolvedOverload, evaluatedArgs[0], celValueConverter); + case 2: + return EvalBinary.create( + expr, + functionName, + resolvedOverload, + evaluatedArgs[0], + evaluatedArgs[1], + celValueConverter); + default: + return EvalVarArgsCall.create( + expr, functionName, resolvedOverload, evaluatedArgs, celValueConverter); + } + } + + private Optional maybeInterceptBlockCall( + String functionName, CelExpr expr, PlannerContext ctx) { + if (!functionName.equals("cel.@block")) { + return Optional.empty(); + } + + CelCall blockCall = expr.call(); + + if (blockCall.args().size() != 2) { + throw new IllegalArgumentException( + "Expected 2 arguments for cel.@block call. Got: " + blockCall.args().size()); + } + + CelList exprList = blockCall.args().get(0).list(); + PlannedInterpretable[] slotExprs = new PlannedInterpretable[exprList.elements().size()]; + for (int i = 0; i < slotExprs.length; i++) { + slotExprs[i] = plan(exprList.elements().get(i), ctx); + } + PlannedInterpretable resultExpr = plan(blockCall.args().get(1), ctx); + return Optional.of(EvalBlock.create(expr, slotExprs, resultExpr)); + } + + /** + * Intercepts a potential optional function call. + * + *

This is analogous to cel-go's decorator. This could be moved to {@code CelOptionalLibrary} + * once we add the support for it. + */ + private Optional maybeInterceptOptionalCalls( + @Nullable CelResolvedOverload resolvedOverload, + String functionName, + PlannedInterpretable[] evaluatedArgs, + CelExpr expr) { + if (evaluatedArgs.length != 2) { + return Optional.empty(); + } + + String overloadId = resolvedOverload == null ? "" : resolvedOverload.getOverloadId(); + + switch (functionName) { + case "or": + if (overloadId.isEmpty() || overloadId.equals("optional_or_optional")) { + return Optional.of(EvalOptionalOr.create(expr, evaluatedArgs[0], evaluatedArgs[1])); + } + + return Optional.empty(); + case "orValue": + if (overloadId.isEmpty() || overloadId.equals("optional_orValue_value")) { + return Optional.of(EvalOptionalOrValue.create(expr, evaluatedArgs[0], evaluatedArgs[1])); + } + + return Optional.empty(); + default: + break; + } + + if (Operator.OPTIONAL_SELECT.getFunction().equals(functionName)) { + String field = expr.call().args().get(1).constant().stringValue(); + InterpretableAttribute attribute; + if (evaluatedArgs[0] instanceof EvalAttribute) { + attribute = (EvalAttribute) evaluatedArgs[0]; + } else { + attribute = + EvalAttribute.create(expr, attributeFactory.newRelativeAttribute(evaluatedArgs[0])); + } + Qualifier qualifier = StringQualifier.create(field); + PlannedInterpretable selectAttribute = attribute.addQualifier(expr, qualifier); + + return Optional.of( + EvalOptionalSelectField.create( + expr, evaluatedArgs[0], field, selectAttribute, celValueConverter)); + } + + return Optional.empty(); + } + + private PlannedInterpretable planCreateStruct(CelExpr celExpr, PlannerContext ctx) { + CelStruct struct = celExpr.struct(); + CelType structType = resolveStructType(celExpr, ctx); + + ImmutableList entries = struct.entries(); + String[] keys = new String[entries.size()]; + PlannedInterpretable[] values = new PlannedInterpretable[entries.size()]; + boolean[] isOptional = new boolean[entries.size()]; + + for (int i = 0; i < entries.size(); i++) { + Entry entry = entries.get(i); + keys[i] = entry.fieldKey(); + values[i] = plan(entry.value(), ctx); + isOptional[i] = entry.optionalEntry(); + } + + return EvalCreateStruct.create(celExpr, valueProvider, structType, keys, values, isOptional); + } + + private PlannedInterpretable planCreateList(CelExpr celExpr, PlannerContext ctx) { + CelList list = celExpr.list(); + ImmutableList elements = list.elements(); + PlannedInterpretable[] values = new PlannedInterpretable[elements.size()]; + + for (int i = 0; i < elements.size(); i++) { + values[i] = plan(elements.get(i), ctx); + } + + boolean[] isOptional = new boolean[elements.size()]; + for (int optionalIndex : list.optionalIndices()) { + isOptional[optionalIndex] = true; + } + + return EvalCreateList.create(celExpr, values, isOptional); + } + + private PlannedInterpretable planCreateMap(CelExpr celExpr, PlannerContext ctx) { + CelMap map = celExpr.map(); + + ImmutableList entries = map.entries(); + PlannedInterpretable[] keys = new PlannedInterpretable[entries.size()]; + PlannedInterpretable[] values = new PlannedInterpretable[entries.size()]; + boolean[] isOptional = new boolean[entries.size()]; + + for (int i = 0; i < entries.size(); i++) { + CelMap.Entry entry = entries.get(i); + keys[i] = plan(entry.key(), ctx); + values[i] = plan(entry.value(), ctx); + isOptional[i] = entry.optionalEntry(); + } + + return EvalCreateMap.create(celExpr, keys, values, isOptional); + } + + private PlannedInterpretable planComprehension(CelExpr expr, PlannerContext ctx) { + CelComprehension comprehension = expr.comprehension(); + + PlannedInterpretable accuInit = plan(comprehension.accuInit(), ctx); + PlannedInterpretable iterRange = plan(comprehension.iterRange(), ctx); + + ctx.pushLocalVars(comprehension.accuVar(), comprehension.iterVar(), comprehension.iterVar2()); + + PlannedInterpretable loopCondition = plan(comprehension.loopCondition(), ctx); + PlannedInterpretable loopStep = plan(comprehension.loopStep(), ctx); + + ctx.popLocalVars(comprehension.iterVar(), comprehension.iterVar2()); + + PlannedInterpretable result = plan(comprehension.result(), ctx); + + ctx.popLocalVars(comprehension.accuVar()); + + return EvalFold.create( + expr, + comprehension.accuVar(), + accuInit, + comprehension.iterVar(), + comprehension.iterVar2(), + iterRange, + loopCondition, + loopStep, + result); + } + + /** + * resolveFunction determines the call target, function name, and overload name (when unambiguous) + * from the given call expr. + */ + private ResolvedFunction resolveFunction( + CelExpr expr, ImmutableMap referenceMap) { + CelCall call = expr.call(); + Optional maybeTarget = call.target(); + String functionName = call.function(); + + CelReference reference = referenceMap.get(expr.id()); + if (reference != null) { + // Checked expression + if (reference.overloadIds().size() == 1) { + ResolvedFunction.Builder builder = + ResolvedFunction.newBuilder() + .setFunctionName(functionName) + .setOverloadId(reference.overloadIds().get(0)); + + maybeTarget.ifPresent(builder::setTarget); + + return builder.build(); + } + } + + // Parsed-only function resolution. + // + // There are two distinct cases we must handle: + // + // 1. Non-qualified function calls. This will resolve into either: + // - A simple global call foo() + // - A fully qualified global call through normal container resolution foo.bar.qux() + // 2. Qualified function calls: + // - A member call on an identifier foo.bar() + // - A fully qualified global call, through normal container resolution or abbreviations + // foo.bar.qux() + if (!maybeTarget.isPresent()) { + for (String cand : container.resolveCandidateNames(functionName)) { + CelResolvedOverload overload = dispatcher.findOverload(cand).orElse(null); + if (overload != null) { + return ResolvedFunction.newBuilder().setFunctionName(cand).build(); + } + } + + // Normal global call + return ResolvedFunction.newBuilder().setFunctionName(functionName).build(); + } + + CelExpr target = maybeTarget.get(); + String qualifiedPrefix = toQualifiedName(target).orElse(null); + if (qualifiedPrefix != null) { + String qualifiedName = qualifiedPrefix + "." + functionName; + for (String cand : container.resolveCandidateNames(qualifiedName)) { + CelResolvedOverload overload = dispatcher.findOverload(cand).orElse(null); + if (overload != null) { + return ResolvedFunction.newBuilder().setFunctionName(cand).build(); + } + } + } + + // Normal member call + return ResolvedFunction.newBuilder().setFunctionName(functionName).setTarget(target).build(); + } + + private CelType resolveStructType(CelExpr expr, PlannerContext ctx) { + CelType checkedType = ctx.typeMap().get(expr.id()); + if (checkedType != null) { + CelKind kind = checkedType.kind(); + // Type-checked ASTs do not need a type-provider lookup as long as it's of expected kind. + if (isValidStructKind(kind)) { + return checkedType; + } + } + + CelStruct struct = expr.struct(); + String messageName = struct.messageName(); + for (String typeName : container.resolveCandidateNames(messageName)) { + CelType structType = typeProvider.findType(typeName).orElse(null); + if (structType == null) { + continue; + } + + CelKind kind = structType.kind(); + + if (!isValidStructKind(kind)) { + throw new IllegalArgumentException( + String.format( + "Expected struct type for %s, got %s", structType.name(), structType.kind())); + } + + return structType; + } + + throw new IllegalArgumentException("Undefined type name: " + messageName); + } + + private static boolean isValidStructKind(CelKind kind) { + return kind.equals(CelKind.STRUCT) + || kind.equals(CelKind.TIMESTAMP) + || kind.equals(CelKind.DURATION); + } + + /** Converts a given expression into a qualified name, if possible. */ + private Optional toQualifiedName(CelExpr operand) { + switch (operand.getKind()) { + case IDENT: + return Optional.of(operand.ident().name()); + case SELECT: + CelSelect select = operand.select(); + String maybeQualified = toQualifiedName(select.operand()).orElse(null); + if (maybeQualified != null) { + return Optional.of(maybeQualified + "." + select.field()); + } + + break; + default: + // fall-through + } + + return Optional.empty(); + } + + @AutoValue + abstract static class ResolvedFunction { + + abstract String functionName(); + + abstract Optional target(); + + abstract Optional overloadId(); + + @AutoValue.Builder + abstract static class Builder { + abstract Builder setFunctionName(String functionName); + + abstract Builder setTarget(CelExpr target); + + abstract Builder setOverloadId(String overloadId); + + @CheckReturnValue + abstract ResolvedFunction build(); + } + + private static Builder newBuilder() { + return new AutoValue_ProgramPlanner_ResolvedFunction.Builder(); + } + } + + static final class PlannerContext { + private final ImmutableMap referenceMap; + private final ImmutableMap typeMap; + private final HashMap localVars = new HashMap<>(); + + ImmutableMap referenceMap() { + return referenceMap; + } + + ImmutableMap typeMap() { + return typeMap; + } + + private void pushLocalVars(String... names) { + for (String name : names) { + if (Strings.isNullOrEmpty(name)) { + continue; + } + localVars.merge(name, 1, Integer::sum); + } + } + + private void popLocalVars(String... names) { + for (String name : names) { + if (Strings.isNullOrEmpty(name)) { + continue; + } + Integer count = localVars.get(name); + if (count != null) { + if (count == 1) { + localVars.remove(name); + } else { + localVars.put(name, count - 1); + } + } + } + } + + /** Checks if the given name is a local variable in the current scope. */ + private boolean isLocalVar(String name) { + return localVars.containsKey(name); + } + + private PlannerContext( + ImmutableMap referenceMap, ImmutableMap typeMap) { + this.referenceMap = referenceMap; + this.typeMap = typeMap; + } + + static PlannerContext create(CelAbstractSyntaxTree ast) { + return new PlannerContext(ast.getReferenceMap(), ast.getTypeMap()); + } + } + + public static ProgramPlanner newPlanner( + CelTypeProvider typeProvider, + CelValueProvider valueProvider, + DefaultDispatcher dispatcher, + CelValueConverter celValueConverter, + CelContainer container, + CelOptions options, + ImmutableSet lateBoundFunctionNames) { + return new ProgramPlanner( + typeProvider, + valueProvider, + dispatcher, + celValueConverter, + container, + options, + lateBoundFunctionNames); + } + + private ProgramPlanner( + CelTypeProvider typeProvider, + CelValueProvider valueProvider, + DefaultDispatcher dispatcher, + CelValueConverter celValueConverter, + CelContainer container, + CelOptions options, + ImmutableSet lateBoundFunctionNames) { + this.typeProvider = typeProvider; + this.valueProvider = valueProvider; + this.dispatcher = dispatcher; + this.celValueConverter = celValueConverter; + this.container = container; + this.options = options; + this.lateBoundFunctionNames = lateBoundFunctionNames; + this.attributeFactory = + AttributeFactory.newAttributeFactory(container, typeProvider, celValueConverter); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/Qualifier.java b/runtime/src/main/java/dev/cel/runtime/planner/Qualifier.java new file mode 100644 index 000000000..82e48e95a --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/Qualifier.java @@ -0,0 +1,28 @@ +// Copyright 2025 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.planner; + +import com.google.errorprone.annotations.Immutable; + +/** + * Represents a qualification step (such as a field selection or map key lookup) applied to an + * intermediate value during attribute resolution. + */ +@Immutable +interface Qualifier { + Object value(); + + Object qualify(Object value); +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/RelativeAttribute.java b/runtime/src/main/java/dev/cel/runtime/planner/RelativeAttribute.java new file mode 100644 index 000000000..38f733c79 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/RelativeAttribute.java @@ -0,0 +1,76 @@ +// Copyright 2025 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.planner; + +import com.google.common.collect.ImmutableList; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.values.CelValueConverter; +import dev.cel.runtime.AccumulatedUnknowns; +import dev.cel.runtime.GlobalResolver; + +/** + * An attribute resolved relative to a base expression (operand) by applying a sequence of + * qualifiers. + */ +@Immutable +final class RelativeAttribute implements Attribute { + + private final PlannedInterpretable operand; + private final CelValueConverter celValueConverter; + private final ImmutableList qualifiers; + + @Override + public Object resolve(long exprId, GlobalResolver ctx, ExecutionFrame frame) { + Object obj = EvalHelpers.evalStrictly(operand, ctx, frame); + if (obj instanceof AccumulatedUnknowns) { + return obj; + } + + obj = celValueConverter.toRuntimeValue(obj); + + // Avoid enhanced for loop to prevent UnmodifiableIterator from being allocated + for (int i = 0; i < qualifiers.size(); i++) { + Qualifier element = qualifiers.get(i); + obj = element.qualify(obj); + obj = celValueConverter.toRuntimeValue(obj); + } + + return celValueConverter.maybeUnwrap(obj); + } + + @Override + public Attribute addQualifier(Qualifier qualifier) { + return new RelativeAttribute( + this.operand, + celValueConverter, + ImmutableList.builderWithExpectedSize(qualifiers.size() + 1) + .addAll(this.qualifiers) + .add(qualifier) + .build()); + } + + RelativeAttribute(PlannedInterpretable operand, CelValueConverter celValueConverter) { + this(operand, celValueConverter, ImmutableList.of()); + } + + private RelativeAttribute( + PlannedInterpretable operand, + CelValueConverter celValueConverter, + ImmutableList qualifiers) { + this.operand = operand; + this.celValueConverter = celValueConverter; + this.qualifiers = qualifiers; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/planner/StringQualifier.java b/runtime/src/main/java/dev/cel/runtime/planner/StringQualifier.java new file mode 100644 index 000000000..293ca5c7d --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/planner/StringQualifier.java @@ -0,0 +1,75 @@ +// Copyright 2025 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.planner; + +import dev.cel.common.exceptions.CelAttributeNotFoundException; +import dev.cel.common.values.OptionalValue; +import dev.cel.common.values.SelectableValue; +import java.util.Map; + +/** A qualifier that accesses fields or map keys using a string identifier. */ +final class StringQualifier implements Qualifier { + + private final String value; + + @Override + public String value() { + return value; + } + + @Override + @SuppressWarnings("unchecked") // Qualifications on maps/structs must be a string + public Object qualify(Object obj) { + if (obj instanceof OptionalValue) { + OptionalValue opt = (OptionalValue) obj; + if (!opt.isZeroValue()) { + Object inner = opt.value(); + if (!(inner instanceof SelectableValue) && !(inner instanceof Map)) { + throw CelAttributeNotFoundException.forFieldResolution(value); + } + } + } + + if (obj instanceof SelectableValue) { + return ((SelectableValue) obj).select(value); + } + + if (obj instanceof Map) { + Map map = (Map) obj; + Object mapVal = map.get(value); + + if (mapVal != null) { + return mapVal; + } + + if (!map.containsKey(value)) { + throw CelAttributeNotFoundException.forMissingMapKey(value); + } + + throw CelAttributeNotFoundException.of( + String.format("Map value cannot be null for key: %s", value)); + } + + throw CelAttributeNotFoundException.forFieldResolution(value); + } + + static StringQualifier create(String value) { + return new StringQualifier(value); + } + + private StringQualifier(String value) { + this.value = value; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/AddOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/AddOperator.java new file mode 100644 index 000000000..c4e0bec42 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/AddOperator.java @@ -0,0 +1,175 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.ADD; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.common.internal.DateTimeHelpers; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.time.Instant; +import java.util.Arrays; +import java.util.List; + +/** Standard function for the addition (+) operator. */ +public final class AddOperator extends CelStandardFunction { + private static final AddOperator ALL_OVERLOADS = create(AddOverload.values()); + + public static AddOperator create() { + return ALL_OVERLOADS; + } + + public static AddOperator create(AddOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static AddOperator create(Iterable overloads) { + return new AddOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum AddOverload implements CelStandardOverload { + ADD_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "add_int64", + Long.class, + Long.class, + (Long x, Long y) -> { + try { + return RuntimeHelpers.int64Add(x, y, celOptions); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + })), + ADD_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "add_uint64", + UnsignedLong.class, + UnsignedLong.class, + (UnsignedLong x, UnsignedLong y) -> { + try { + return RuntimeHelpers.uint64Add(x, y); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + }); + } else { + return CelFunctionBinding.from( + "add_uint64", + Long.class, + Long.class, + (Long x, Long y) -> { + try { + return RuntimeHelpers.uint64Add(x, y, celOptions); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + }); + } + }), + ADD_BYTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "add_bytes", CelByteString.class, CelByteString.class, CelByteString::concat); + } else { + return CelFunctionBinding.from( + "add_bytes", ByteString.class, ByteString.class, ByteString::concat); + } + }), + ADD_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("add_double", Double.class, Double.class, Double::sum)), + ADD_DURATION_DURATION( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "add_duration_duration", + java.time.Duration.class, + java.time.Duration.class, + DateTimeHelpers::add); + } else { + return CelFunctionBinding.from( + "add_duration_duration", Duration.class, Duration.class, ProtoTimeUtils::add); + } + }), + ADD_TIMESTAMP_DURATION( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "add_timestamp_duration", + Instant.class, + java.time.Duration.class, + DateTimeHelpers::add); + } else { + return CelFunctionBinding.from( + "add_timestamp_duration", Timestamp.class, Duration.class, ProtoTimeUtils::add); + } + }), + ADD_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "add_string", String.class, String.class, (String x, String y) -> x + y)), + ADD_DURATION_TIMESTAMP( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "add_duration_timestamp", + java.time.Duration.class, + Instant.class, + (java.time.Duration d, Instant i) -> DateTimeHelpers.add(i, d)); + } else { + return CelFunctionBinding.from( + "add_duration_timestamp", + Duration.class, + Timestamp.class, + (Duration d, Timestamp t) -> ProtoTimeUtils.add(t, d)); + } + }), + @SuppressWarnings({"unchecked"}) + ADD_LIST( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("add_list", List.class, List.class, RuntimeHelpers::concat)); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + AddOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private AddOperator(ImmutableSet overloads) { + super(ADD.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/BUILD.bazel b/runtime/src/main/java/dev/cel/runtime/standard/BUILD.bazel new file mode 100644 index 000000000..0a76b6135 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/BUILD.bazel @@ -0,0 +1,1520 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//publish:__pkg__", + "//runtime/standard:__pkg__", + ], +) + +java_library( + name = "standard_function", + srcs = ["CelStandardFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "standard_function_android", + srcs = ["CelStandardFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "add", + srcs = ["AddOperator.java"], + tags = [ + ], + deps = [ + ":standard_function", + ":standard_overload", + "//common:operator", + "//common:options", + "//common/exceptions:numeric_overflow", + "//common/internal:date_time_helpers", + "//common/internal:proto_time_utils", + "//common/values:cel_byte_string", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "add_android", + srcs = ["AddOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/exceptions:numeric_overflow", + "//common/internal:date_time_helpers_android", + "//common/internal:proto_time_utils_android", + "//common/values:cel_byte_string", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "subtract", + srcs = ["SubtractOperator.java"], + tags = [ + ], + deps = [ + ":standard_function", + ":standard_overload", + "//common:operator", + "//common:options", + "//common/exceptions:numeric_overflow", + "//common/internal:date_time_helpers", + "//common/internal:proto_time_utils", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "subtract_android", + srcs = ["SubtractOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/exceptions:numeric_overflow", + "//common/internal:date_time_helpers_android", + "//common/internal:proto_time_utils_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "bool", + srcs = ["BoolFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/exceptions:bad_format", + "//common/internal:safe_string_formatter", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "bool_android", + srcs = ["BoolFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/exceptions:bad_format", + "//common/internal:safe_string_formatter", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "bytes", + srcs = ["BytesFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/values:cel_byte_string", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "bytes_android", + srcs = ["BytesFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/values:cel_byte_string", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "contains", + srcs = ["ContainsFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "contains_android", + srcs = ["ContainsFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "double", + srcs = ["DoubleFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/exceptions:bad_format", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "double_android", + srcs = ["DoubleFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/exceptions:bad_format", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "duration", + srcs = ["DurationFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/exceptions:bad_format", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "duration_android", + srcs = ["DurationFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/exceptions:bad_format", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "dyn", + srcs = ["DynFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "dyn_android", + srcs = ["DynFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "ends_with", + srcs = ["EndsWithFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "ends_with_android", + srcs = ["EndsWithFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "equals", + srcs = ["EqualsOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "equals_android", + srcs = ["EqualsOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "get_day_of_year", + srcs = ["GetDayOfYearFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_day_of_year_android", + srcs = ["GetDayOfYearFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "get_day_of_month", + srcs = ["GetDayOfMonthFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_day_of_month_android", + srcs = ["GetDayOfMonthFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "get_day_of_week", + srcs = ["GetDayOfWeekFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_day_of_week_android", + srcs = ["GetDayOfWeekFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "get_date", + srcs = ["GetDateFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_date_android", + srcs = ["GetDateFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "get_full_year", + srcs = ["GetFullYearFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_full_year_android", + srcs = ["GetFullYearFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "get_hours", + srcs = ["GetHoursFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//common/internal:proto_time_utils", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_hours_android", + srcs = ["GetHoursFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//common/internal:proto_time_utils_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "get_milliseconds", + srcs = ["GetMillisecondsFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//common/internal:proto_time_utils", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_milliseconds_android", + srcs = ["GetMillisecondsFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//common/internal:proto_time_utils_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "get_minutes", + srcs = ["GetMinutesFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//common/internal:proto_time_utils", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_minutes_android", + srcs = ["GetMinutesFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//common/internal:proto_time_utils_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "get_month", + srcs = ["GetMonthFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_month_android", + srcs = ["GetMonthFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "get_seconds", + srcs = ["GetSecondsFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/internal:date_time_helpers", + "//common/internal:proto_time_utils", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "get_seconds_android", + srcs = ["GetSecondsFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/internal:date_time_helpers_android", + "//common/internal:proto_time_utils_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "greater", + srcs = ["GreaterOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//common/internal:comparison_functions", + "//common/internal:proto_time_utils", + "//common/values:cel_byte_string", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "greater_android", + srcs = ["GreaterOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/internal:comparison_functions_android", + "//common/internal:proto_time_utils_android", + "//common/values:cel_byte_string", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "greater_equals", + srcs = ["GreaterEqualsOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//common/internal:comparison_functions", + "//common/internal:proto_time_utils", + "//common/values:cel_byte_string", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "greater_equals_android", + srcs = ["GreaterEqualsOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/internal:comparison_functions_android", + "//common/internal:proto_time_utils_android", + "//common/values:cel_byte_string", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "in", + srcs = ["InOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "in_android", + srcs = ["InOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "index", + srcs = ["IndexOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "index_android", + srcs = ["IndexOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "int", + srcs = ["IntFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/exceptions:bad_format", + "//common/exceptions:numeric_overflow", + "//common/internal:proto_time_utils", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "int_android", + srcs = ["IntFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/exceptions:bad_format", + "//common/exceptions:numeric_overflow", + "//common/internal:proto_time_utils_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "less", + srcs = ["LessOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//common/internal:comparison_functions", + "//common/internal:proto_time_utils", + "//common/values:cel_byte_string", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "less_android", + srcs = ["LessOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/internal:comparison_functions_android", + "//common/internal:proto_time_utils_android", + "//common/values:cel_byte_string", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "less_equals", + srcs = ["LessEqualsOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//common/internal:comparison_functions", + "//common/internal:proto_time_utils", + "//common/values:cel_byte_string", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "less_equals_android", + srcs = ["LessEqualsOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/internal:comparison_functions_android", + "//common/internal:proto_time_utils_android", + "//common/values:cel_byte_string", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "logical_not", + srcs = ["LogicalNotOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "logical_not_android", + srcs = ["LogicalNotOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "matches", + srcs = ["MatchesFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/exceptions:invalid_argument", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "matches_android", + srcs = ["MatchesFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/exceptions:invalid_argument", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "modulo", + srcs = ["ModuloOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//common/exceptions:divide_by_zero", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "modulo_android", + srcs = ["ModuloOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/exceptions:divide_by_zero", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "multiply", + srcs = ["MultiplyOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//common/exceptions:numeric_overflow", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "multiply_android", + srcs = ["MultiplyOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/exceptions:numeric_overflow", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "divide", + srcs = ["DivideOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//common/exceptions:divide_by_zero", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "divide_android", + srcs = ["DivideOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/exceptions:divide_by_zero", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "negate", + srcs = ["NegateOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//common/exceptions:numeric_overflow", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "negate_android", + srcs = ["NegateOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//common/exceptions:numeric_overflow", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "not_equals", + srcs = ["NotEqualsOperator.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "not_equals_android", + srcs = ["NotEqualsOperator.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "size", + srcs = ["SizeFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/values:cel_byte_string", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "size_android", + srcs = ["SizeFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/values:cel_byte_string", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "starts_with", + srcs = ["StartsWithFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "starts_with_android", + srcs = ["StartsWithFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "string", + srcs = ["StringFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/exceptions:bad_format", + "//common/internal:date_time_helpers", + "//common/internal:proto_time_utils", + "//common/values:cel_byte_string", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "string_android", + srcs = ["StringFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/exceptions:bad_format", + "//common/internal:date_time_helpers_android", + "//common/internal:proto_time_utils_android", + "//common/values:cel_byte_string", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "timestamp", + srcs = ["TimestampFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/exceptions:bad_format", + "//common/internal:date_time_helpers", + "//common/internal:proto_time_utils", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +cel_android_library( + name = "timestamp_android", + srcs = ["TimestampFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/exceptions:bad_format", + "//common/internal:date_time_helpers_android", + "//common/internal:proto_time_utils_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "type", + srcs = ["TypeFunction.java"], + tags = [ + ], + deps = [ + ":standard_function", + ":standard_overload", + "//common:options", + "//common/types", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:type_resolver", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "type_android", + srcs = ["TypeFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/types:types_android", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:type_resolver_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "uint", + srcs = ["UintFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:options", + "//common/exceptions:bad_format", + "//common/exceptions:numeric_overflow", + "//runtime:function_binding", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "uint_android", + srcs = ["UintFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:options", + "//common/exceptions:bad_format", + "//common/exceptions:numeric_overflow", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "//runtime:runtime_helpers_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "not_strictly_false", + srcs = ["NotStrictlyFalseFunction.java"], + tags = [ + ], + deps = [ + ":standard_overload", + "//common:operator", + "//common:options", + "//runtime:function_binding", + "//runtime:internal_function_binder", + "//runtime:runtime_equality", + "//runtime/standard:standard_function", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "not_strictly_false_android", + srcs = ["NotStrictlyFalseFunction.java"], + tags = [ + ], + deps = [ + ":standard_function_android", + ":standard_overload_android", + "//common:operator_android", + "//common:options", + "//runtime:function_binding_android", + "//runtime:internal_function_binder_android", + "//runtime:runtime_equality_android", + "@maven_android//:com_google_guava_guava", + ], +) + +java_library( + name = "standard_overload", + srcs = ["CelStandardOverload.java"], + tags = [ + ], + deps = [ + "//common:options", + "//runtime:function_binding", + "//runtime:runtime_equality", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +cel_android_library( + name = "standard_overload_android", + srcs = ["CelStandardOverload.java"], + tags = [ + ], + deps = [ + "//common:options", + "//runtime:function_binding_android", + "//runtime:runtime_equality_android", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) diff --git a/runtime/src/main/java/dev/cel/runtime/standard/BoolFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/BoolFunction.java new file mode 100644 index 000000000..668934aac --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/BoolFunction.java @@ -0,0 +1,89 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.common.internal.SafeStringFormatter; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for {@code bool} conversion function. */ +public final class BoolFunction extends CelStandardFunction { + private static final BoolFunction ALL_OVERLOADS = create(BoolOverload.values()); + + public static BoolFunction create() { + return ALL_OVERLOADS; + } + + public static BoolFunction create(BoolFunction.BoolOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static BoolFunction create(Iterable overloads) { + return new BoolFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum BoolOverload implements CelStandardOverload { + BOOL_TO_BOOL( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("bool_to_bool", Boolean.class, (Boolean x) -> x)), + STRING_TO_BOOL( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "string_to_bool", + String.class, + (String str) -> { + switch (str) { + case "true": + case "TRUE": + case "True": + case "t": + case "1": + return true; + case "false": + case "FALSE": + case "False": + case "f": + case "0": + return false; + default: + throw new CelBadFormatException( + SafeStringFormatter.format( + "Type conversion error from 'string' to 'bool': [%s]", str)); + } + })); + + private final CelStandardOverload standardOverload; + ; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + BoolOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private BoolFunction(ImmutableSet overloads) { + super("bool", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/BytesFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/BytesFunction.java new file mode 100644 index 000000000..7e3ab2b2f --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/BytesFunction.java @@ -0,0 +1,81 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.ByteString; +import dev.cel.common.CelOptions; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for {@code bytes} conversion function. */ +public final class BytesFunction extends CelStandardFunction { + private static final BytesFunction ALL_OVERLOADS = create(BytesOverload.values()); + + public static BytesFunction create() { + return ALL_OVERLOADS; + } + + public static BytesFunction create(BytesFunction.BytesOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static BytesFunction create(Iterable overloads) { + return new BytesFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum BytesOverload implements CelStandardOverload { + BYTES_TO_BYTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "bytes_to_bytes", CelByteString.class, (CelByteString x) -> x); + } else { + return CelFunctionBinding.from("bytes_to_bytes", ByteString.class, (ByteString x) -> x); + } + }), + STRING_TO_BYTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "string_to_bytes", String.class, CelByteString::copyFromUtf8); + } else { + return CelFunctionBinding.from( + "string_to_bytes", String.class, ByteString::copyFromUtf8); + } + }), + ; + + private final CelStandardOverload standardOverload; + ; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + BytesOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private BytesFunction(ImmutableSet overloads) { + super("bytes", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/CelStandardFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/CelStandardFunction.java new file mode 100644 index 000000000..f9f919413 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/CelStandardFunction.java @@ -0,0 +1,52 @@ +// Copyright 2025 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.standard; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; + +/** + * An abstract class that describes a CEL standard function. An implementation should provide a set + * of overloads for the standard function + */ +@Immutable +public abstract class CelStandardFunction { + private final String name; + private final ImmutableSet overloads; + + public ImmutableSet newFunctionBindings( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + ImmutableSet overloadBindings = + overloads.stream() + .map(overload -> overload.newFunctionBinding(celOptions, runtimeEquality)) + .collect(toImmutableSet()); + + return CelFunctionBinding.fromOverloads(name, overloadBindings); + } + + CelStandardFunction(String name, ImmutableSet overloads) { + checkArgument(!Strings.isNullOrEmpty(name), "Function name must be provided."); + checkArgument(!overloads.isEmpty(), "At least 1 overload must be provided."); + this.overloads = overloads; + this.name = name; + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/CelStandardOverload.java b/runtime/src/main/java/dev/cel/runtime/standard/CelStandardOverload.java new file mode 100644 index 000000000..aad6e468b --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/CelStandardOverload.java @@ -0,0 +1,33 @@ +// Copyright 2025 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.standard; + +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; + +/** + * {@code CelStandardOverload} defines an interface for a standard function's overload. The + * implementation should produce a concrete {@link CelFunctionBinding} for the standard function's + * overload. + */ +@Immutable +@FunctionalInterface +public interface CelStandardOverload { + + /** Constructs a new {@link CelFunctionBinding} for this CEL standard overload. */ + CelFunctionBinding newFunctionBinding(CelOptions celOptions, RuntimeEquality runtimeEquality); +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/ContainsFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/ContainsFunction.java new file mode 100644 index 000000000..bf3f9f7a7 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/ContainsFunction.java @@ -0,0 +1,63 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for {@code contains}. */ +public final class ContainsFunction extends CelStandardFunction { + private static final ContainsFunction ALL_OVERLOADS = create(ContainsOverload.values()); + + public static ContainsFunction create() { + return ALL_OVERLOADS; + } + + public static ContainsFunction create(ContainsFunction.ContainsOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static ContainsFunction create(Iterable overloads) { + return new ContainsFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum ContainsOverload implements CelStandardOverload { + CONTAINS_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "contains_string", String.class, String.class, String::contains)), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + ContainsOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private ContainsFunction(ImmutableSet overloads) { + super("contains", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/DivideOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/DivideOperator.java new file mode 100644 index 000000000..ddd78cef8 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/DivideOperator.java @@ -0,0 +1,95 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.DIVIDE; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelDivideByZeroException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.util.Arrays; + +/** Standard function for the division (/) operator. */ +public final class DivideOperator extends CelStandardFunction { + private static final DivideOperator ALL_OVERLOADS = create(DivideOverload.values()); + + public static DivideOperator create() { + return ALL_OVERLOADS; + } + + public static DivideOperator create(DivideOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static DivideOperator create(Iterable overloads) { + return new DivideOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum DivideOverload implements CelStandardOverload { + DIVIDE_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "divide_double", Double.class, Double.class, (Double x, Double y) -> x / y)), + DIVIDE_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "divide_int64", + Long.class, + Long.class, + (Long x, Long y) -> { + try { + return RuntimeHelpers.int64Divide(x, y, celOptions); + } catch (ArithmeticException e) { + throw new CelDivideByZeroException(e); + } + })), + DIVIDE_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "divide_uint64", + UnsignedLong.class, + UnsignedLong.class, + RuntimeHelpers::uint64Divide); + } else { + return CelFunctionBinding.from( + "divide_uint64", + Long.class, + Long.class, + (Long x, Long y) -> RuntimeHelpers.uint64Divide(x, y, celOptions)); + } + }); + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + DivideOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private DivideOperator(ImmutableSet overloads) { + super(DIVIDE.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/DoubleFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/DoubleFunction.java new file mode 100644 index 000000000..b8d4b74c0 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/DoubleFunction.java @@ -0,0 +1,91 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for {@code double} conversion function. */ +public final class DoubleFunction extends CelStandardFunction { + private static final DoubleFunction ALL_OVERLOADS = create(DoubleOverload.values()); + + public static DoubleFunction create() { + return ALL_OVERLOADS; + } + + public static DoubleFunction create(DoubleFunction.DoubleOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static DoubleFunction create(Iterable overloads) { + return new DoubleFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum DoubleOverload implements CelStandardOverload { + DOUBLE_TO_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("double_to_double", Double.class, (Double x) -> x)), + INT64_TO_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("int64_to_double", Long.class, Long::doubleValue)), + STRING_TO_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "string_to_double", + String.class, + (String arg) -> { + try { + return Double.parseDouble(arg); + } catch (NumberFormatException e) { + throw new CelBadFormatException(e); + } + })), + UINT64_TO_DOUBLE( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "uint64_to_double", UnsignedLong.class, UnsignedLong::doubleValue); + } else { + return CelFunctionBinding.from( + "uint64_to_double", + Long.class, + (Long arg) -> UnsignedLong.fromLongBits(arg).doubleValue()); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + DoubleOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private DoubleFunction(ImmutableSet overloads) { + super("double", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/DurationFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/DurationFunction.java new file mode 100644 index 000000000..e1f11644e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/DurationFunction.java @@ -0,0 +1,92 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Duration; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.util.Arrays; + +/** Standard function for {@code duration} conversion function. */ +public final class DurationFunction extends CelStandardFunction { + private static final DurationFunction ALL_OVERLOADS = create(DurationOverload.values()); + + public static DurationFunction create() { + return ALL_OVERLOADS; + } + + public static DurationFunction create(DurationFunction.DurationOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static DurationFunction create(Iterable overloads) { + return new DurationFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum DurationOverload implements CelStandardOverload { + DURATION_TO_DURATION( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "duration_to_duration", java.time.Duration.class, (java.time.Duration d) -> d); + } else { + return CelFunctionBinding.from( + "duration_to_duration", Duration.class, (Duration d) -> d); + } + }), + STRING_TO_DURATION( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "string_to_duration", + String.class, + (String d) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + try { + return RuntimeHelpers.createJavaDurationFromString(d); + } catch (IllegalArgumentException e) { + throw new CelBadFormatException(e); + } + } else { + try { + return RuntimeHelpers.createDurationFromString(d); + } catch (IllegalArgumentException e) { + throw new CelBadFormatException(e); + } + } + })), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + DurationOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private DurationFunction(ImmutableSet overloads) { + super("duration", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/DynFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/DynFunction.java new file mode 100644 index 000000000..da855de82 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/DynFunction.java @@ -0,0 +1,62 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for {@code dyn} conversion function. */ +public final class DynFunction extends CelStandardFunction { + + private static final DynFunction ALL_OVERLOADS = create(DynOverload.values()); + + public static DynFunction create() { + return ALL_OVERLOADS; + } + + public static DynFunction create(DynFunction.DynOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static DynFunction create(Iterable overloads) { + return new DynFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum DynOverload implements CelStandardOverload { + TO_DYN( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("to_dyn", Object.class, (Object arg) -> arg)); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + DynOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private DynFunction(ImmutableSet overloads) { + super("dyn", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/EndsWithFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/EndsWithFunction.java new file mode 100644 index 000000000..7f4e8c035 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/EndsWithFunction.java @@ -0,0 +1,64 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for {@code endsWith}. */ +public final class EndsWithFunction extends CelStandardFunction { + private static final EndsWithFunction ALL_OVERLOADS = create(EndsWithOverload.values()); + + public static EndsWithFunction create() { + return ALL_OVERLOADS; + } + + public static EndsWithFunction create(EndsWithFunction.EndsWithOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static EndsWithFunction create(Iterable overloads) { + return new EndsWithFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum EndsWithOverload implements CelStandardOverload { + ENDS_WITH_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "ends_with_string", String.class, String.class, String::endsWith)), + ; + + private final CelStandardOverload standardOverload; + ; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + EndsWithOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private EndsWithFunction(ImmutableSet overloads) { + super("endsWith", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/EqualsOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/EqualsOperator.java new file mode 100644 index 000000000..c505e069e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/EqualsOperator.java @@ -0,0 +1,65 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.EQUALS; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for the equals (=) operator. */ +public final class EqualsOperator extends CelStandardFunction { + private static final EqualsOperator ALL_OVERLOADS = create(EqualsOverload.values()); + + public static EqualsOperator create() { + return ALL_OVERLOADS; + } + + public static EqualsOperator create(EqualsOperator.EqualsOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static EqualsOperator create(Iterable overloads) { + return new EqualsOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum EqualsOverload implements CelStandardOverload { + EQUALS( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "equals", Object.class, Object.class, runtimeEquality::objectEquals)), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + EqualsOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private EqualsOperator(ImmutableSet overloads) { + super(EQUALS.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetDateFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetDateFunction.java new file mode 100644 index 000000000..bb0fb0d79 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetDateFunction.java @@ -0,0 +1,94 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code getDate}. */ +public final class GetDateFunction extends CelStandardFunction { + private static final GetDateFunction ALL_OVERLOADS = create(GetDateOverload.values()); + + public static GetDateFunction create() { + return ALL_OVERLOADS; + } + + public static GetDateFunction create(GetDateFunction.GetDateOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetDateFunction create(Iterable overloads) { + return new GetDateFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetDateOverload implements CelStandardOverload { + TIMESTAMP_TO_DAY_OF_MONTH_1_BASED( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_day_of_month_1_based", + Instant.class, + (Instant ts) -> (long) newLocalDateTime(ts, UTC).getDayOfMonth()); + } else { + return CelFunctionBinding.from( + "timestamp_to_day_of_month_1_based", + Timestamp.class, + (Timestamp ts) -> (long) newLocalDateTime(ts, UTC).getDayOfMonth()); + } + }), + TIMESTAMP_TO_DAY_OF_MONTH_1_BASED_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_day_of_month_1_based_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> (long) newLocalDateTime(ts, tz).getDayOfMonth()); + } else { + return CelFunctionBinding.from( + "timestamp_to_day_of_month_1_based_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> (long) newLocalDateTime(ts, tz).getDayOfMonth()); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetDateOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetDateFunction(ImmutableSet overloads) { + super("getDate", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetDayOfMonthFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetDayOfMonthFunction.java new file mode 100644 index 000000000..e35888fb5 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetDayOfMonthFunction.java @@ -0,0 +1,95 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code getDayOfMonth}. */ +public final class GetDayOfMonthFunction extends CelStandardFunction { + private static final GetDayOfMonthFunction ALL_OVERLOADS = create(GetDayOfMonthOverload.values()); + + public static GetDayOfMonthFunction create() { + return ALL_OVERLOADS; + } + + public static GetDayOfMonthFunction create( + GetDayOfMonthFunction.GetDayOfMonthOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetDayOfMonthFunction create( + Iterable overloads) { + return new GetDayOfMonthFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetDayOfMonthOverload implements CelStandardOverload { + TIMESTAMP_TO_DAY_OF_MONTH( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_day_of_month", + Instant.class, + (Instant ts) -> (long) newLocalDateTime(ts, UTC).getDayOfMonth() - 1); + } else { + return CelFunctionBinding.from( + "timestamp_to_day_of_month", + Timestamp.class, + (Timestamp ts) -> (long) newLocalDateTime(ts, UTC).getDayOfMonth() - 1); + } + }), + TIMESTAMP_TO_DAY_OF_MONTH_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_day_of_month_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> (long) newLocalDateTime(ts, tz).getDayOfMonth() - 1); + } else { + return CelFunctionBinding.from( + "timestamp_to_day_of_month_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> (long) newLocalDateTime(ts, tz).getDayOfMonth() - 1); + } + }), + ; + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetDayOfMonthOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetDayOfMonthFunction(ImmutableSet overloads) { + super("getDayOfMonth", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetDayOfWeekFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetDayOfWeekFunction.java new file mode 100644 index 000000000..e2fa02961 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetDayOfWeekFunction.java @@ -0,0 +1,111 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.DayOfWeek; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code getDayOfWeek}. */ +public final class GetDayOfWeekFunction extends CelStandardFunction { + private static final GetDayOfWeekFunction ALL_OVERLOADS = create(GetDayOfWeekOverload.values()); + + public static GetDayOfWeekFunction create() { + return ALL_OVERLOADS; + } + + public static GetDayOfWeekFunction create( + GetDayOfWeekFunction.GetDayOfWeekOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetDayOfWeekFunction create( + Iterable overloads) { + return new GetDayOfWeekFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetDayOfWeekOverload implements CelStandardOverload { + TIMESTAMP_TO_DAY_OF_WEEK( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_day_of_week", + Instant.class, + (Instant ts) -> { + // CEL treats Sunday as day 0, but Java.time treats it as day 7. + DayOfWeek dayOfWeek = newLocalDateTime(ts, UTC).getDayOfWeek(); + return (long) dayOfWeek.getValue() % 7; + }); + } else { + return CelFunctionBinding.from( + "timestamp_to_day_of_week", + Timestamp.class, + (Timestamp ts) -> { + // CEL treats Sunday as day 0, but Java.time treats it as day 7. + DayOfWeek dayOfWeek = newLocalDateTime(ts, UTC).getDayOfWeek(); + return (long) dayOfWeek.getValue() % 7; + }); + } + }), + TIMESTAMP_TO_DAY_OF_WEEK_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_day_of_week_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> { + // CEL treats Sunday as day 0, but Java.time treats it as day 7. + DayOfWeek dayOfWeek = newLocalDateTime(ts, tz).getDayOfWeek(); + return (long) dayOfWeek.getValue() % 7; + }); + } else { + return CelFunctionBinding.from( + "timestamp_to_day_of_week_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> { + // CEL treats Sunday as day 0, but Java.time treats it as day 7. + DayOfWeek dayOfWeek = newLocalDateTime(ts, tz).getDayOfWeek(); + return (long) dayOfWeek.getValue() % 7; + }); + } + }); + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetDayOfWeekOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetDayOfWeekFunction(ImmutableSet overloads) { + super("getDayOfWeek", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetDayOfYearFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetDayOfYearFunction.java new file mode 100644 index 000000000..4c0e62637 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetDayOfYearFunction.java @@ -0,0 +1,96 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code getDayOfYear}. */ +public final class GetDayOfYearFunction extends CelStandardFunction { + private static final GetDayOfYearFunction ALL_OVERLOADS = create(GetDayOfYearOverload.values()); + + public static GetDayOfYearFunction create() { + return ALL_OVERLOADS; + } + + public static GetDayOfYearFunction create( + GetDayOfYearFunction.GetDayOfYearOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetDayOfYearFunction create( + Iterable overloads) { + return new GetDayOfYearFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetDayOfYearOverload implements CelStandardOverload { + TIMESTAMP_TO_DAY_OF_YEAR( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_day_of_year", + Instant.class, + (Instant ts) -> (long) newLocalDateTime(ts, UTC).getDayOfYear() - 1); + } else { + return CelFunctionBinding.from( + "timestamp_to_day_of_year", + Timestamp.class, + (Timestamp ts) -> (long) newLocalDateTime(ts, UTC).getDayOfYear() - 1); + } + }), + TIMESTAMP_TO_DAY_OF_YEAR_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_day_of_year_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> (long) newLocalDateTime(ts, tz).getDayOfYear() - 1); + } else { + return CelFunctionBinding.from( + "timestamp_to_day_of_year_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> (long) newLocalDateTime(ts, tz).getDayOfYear() - 1); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetDayOfYearOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetDayOfYearFunction(ImmutableSet overloads) { + super("getDayOfYear", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetFullYearFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetFullYearFunction.java new file mode 100644 index 000000000..925f61307 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetFullYearFunction.java @@ -0,0 +1,95 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code getFullYear}. */ +public final class GetFullYearFunction extends CelStandardFunction { + private static final GetFullYearFunction ALL_OVERLOADS = create(GetFullYearOverload.values()); + + public static GetFullYearFunction create() { + return ALL_OVERLOADS; + } + + public static GetFullYearFunction create(GetFullYearFunction.GetFullYearOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetFullYearFunction create( + Iterable overloads) { + return new GetFullYearFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetFullYearOverload implements CelStandardOverload { + TIMESTAMP_TO_YEAR( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_year", + Instant.class, + (Instant ts) -> (long) newLocalDateTime(ts, UTC).getYear()); + } else { + return CelFunctionBinding.from( + "timestamp_to_year", + Timestamp.class, + (Timestamp ts) -> (long) newLocalDateTime(ts, UTC).getYear()); + } + }), + TIMESTAMP_TO_YEAR_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_year_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> (long) newLocalDateTime(ts, tz).getYear()); + } else { + return CelFunctionBinding.from( + "timestamp_to_year_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> (long) newLocalDateTime(ts, tz).getYear()); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetFullYearOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetFullYearFunction(ImmutableSet overloads) { + super("getFullYear", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetHoursFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetHoursFunction.java new file mode 100644 index 000000000..afe16556f --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetHoursFunction.java @@ -0,0 +1,106 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code getHours}. */ +public final class GetHoursFunction extends CelStandardFunction { + private static final GetHoursFunction ALL_OVERLOADS = create(GetHoursOverload.values()); + + public static GetHoursFunction create() { + return ALL_OVERLOADS; + } + + public static GetHoursFunction create(GetHoursFunction.GetHoursOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetHoursFunction create(Iterable overloads) { + return new GetHoursFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetHoursOverload implements CelStandardOverload { + TIMESTAMP_TO_HOURS( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_hours", + Instant.class, + (Instant ts) -> (long) newLocalDateTime(ts, UTC).getHour()); + } else { + return CelFunctionBinding.from( + "timestamp_to_hours", + Timestamp.class, + (Timestamp ts) -> (long) newLocalDateTime(ts, UTC).getHour()); + } + }), + TIMESTAMP_TO_HOURS_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_hours_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> (long) newLocalDateTime(ts, tz).getHour()); + } else { + return CelFunctionBinding.from( + "timestamp_to_hours_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> (long) newLocalDateTime(ts, tz).getHour()); + } + }), + DURATION_TO_HOURS( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "duration_to_hours", java.time.Duration.class, java.time.Duration::toHours); + } else { + return CelFunctionBinding.from( + "duration_to_hours", Duration.class, ProtoTimeUtils::toHours); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetHoursOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetHoursFunction(ImmutableSet overloads) { + super("getHours", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetMillisecondsFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetMillisecondsFunction.java new file mode 100644 index 000000000..32b17cc88 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetMillisecondsFunction.java @@ -0,0 +1,117 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code getMilliseconds}. */ +public final class GetMillisecondsFunction extends CelStandardFunction { + private static final GetMillisecondsFunction ALL_OVERLOADS = + create(GetMillisecondsOverload.values()); + + public static GetMillisecondsFunction create() { + return ALL_OVERLOADS; + } + + public static GetMillisecondsFunction create( + GetMillisecondsFunction.GetMillisecondsOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetMillisecondsFunction create( + Iterable overloads) { + return new GetMillisecondsFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetMillisecondsOverload implements CelStandardOverload { + // We specifically need to only access nanos-of-second field for + // timestamp_to_milliseconds overload + @SuppressWarnings("JavaLocalDateTimeGetNano") + TIMESTAMP_TO_MILLISECONDS( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_milliseconds", + Instant.class, + (Instant ts) -> (long) (newLocalDateTime(ts, UTC).getNano() / 1e+6)); + } else { + return CelFunctionBinding.from( + "timestamp_to_milliseconds", + Timestamp.class, + (Timestamp ts) -> (long) (newLocalDateTime(ts, UTC).getNano() / 1e+6)); + } + }), + @SuppressWarnings("JavaLocalDateTimeGetNano") + TIMESTAMP_TO_MILLISECONDS_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_milliseconds_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> (long) (newLocalDateTime(ts, tz).getNano() / 1e+6)); + } else { + return CelFunctionBinding.from( + "timestamp_to_milliseconds_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> (long) (newLocalDateTime(ts, tz).getNano() / 1e+6)); + } + }), + DURATION_TO_MILLISECONDS( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "duration_to_milliseconds", + java.time.Duration.class, + (java.time.Duration d) -> d.toMillis() % 1_000); + } else { + return CelFunctionBinding.from( + "duration_to_milliseconds", + Duration.class, + (Duration arg) -> + ProtoTimeUtils.toMillis(arg) % java.time.Duration.ofSeconds(1).toMillis()); + } + }); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetMillisecondsOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetMillisecondsFunction(ImmutableSet overloads) { + super("getMilliseconds", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetMinutesFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetMinutesFunction.java new file mode 100644 index 000000000..5f701f1e1 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetMinutesFunction.java @@ -0,0 +1,107 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code getMinutes}. */ +public final class GetMinutesFunction extends CelStandardFunction { + private static final GetMinutesFunction ALL_OVERLOADS = create(GetMinutesOverload.values()); + + public static GetMinutesFunction create() { + return ALL_OVERLOADS; + } + + public static GetMinutesFunction create(GetMinutesFunction.GetMinutesOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetMinutesFunction create( + Iterable overloads) { + return new GetMinutesFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetMinutesOverload implements CelStandardOverload { + TIMESTAMP_TO_MINUTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_minutes", + Instant.class, + (Instant ts) -> (long) newLocalDateTime(ts, UTC).getMinute()); + } else { + return CelFunctionBinding.from( + "timestamp_to_minutes", + Timestamp.class, + (Timestamp ts) -> (long) newLocalDateTime(ts, UTC).getMinute()); + } + }), + TIMESTAMP_TO_MINUTES_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_minutes_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> (long) newLocalDateTime(ts, tz).getMinute()); + } else { + return CelFunctionBinding.from( + "timestamp_to_minutes_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> (long) newLocalDateTime(ts, tz).getMinute()); + } + }), + DURATION_TO_MINUTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "duration_to_minutes", java.time.Duration.class, java.time.Duration::toMinutes); + } else { + return CelFunctionBinding.from( + "duration_to_minutes", Duration.class, ProtoTimeUtils::toMinutes); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetMinutesOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetMinutesFunction(ImmutableSet overloads) { + super("getMinutes", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetMonthFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetMonthFunction.java new file mode 100644 index 000000000..a8a9ded68 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetMonthFunction.java @@ -0,0 +1,94 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function runtime definition for {@code getMonth}. */ +public final class GetMonthFunction extends CelStandardFunction { + private static final GetMonthFunction ALL_OVERLOADS = create(GetMonthOverload.values()); + + public static GetMonthFunction create() { + return ALL_OVERLOADS; + } + + public static GetMonthFunction create(GetMonthFunction.GetMonthOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetMonthFunction create(Iterable overloads) { + return new GetMonthFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetMonthOverload implements CelStandardOverload { + TIMESTAMP_TO_MONTH( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_month", + Instant.class, + (Instant ts) -> (long) newLocalDateTime(ts, UTC).getMonthValue() - 1); + } else { + return CelFunctionBinding.from( + "timestamp_to_month", + Timestamp.class, + (Timestamp ts) -> (long) newLocalDateTime(ts, UTC).getMonthValue() - 1); + } + }), + TIMESTAMP_TO_MONTH_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_month_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> (long) newLocalDateTime(ts, tz).getMonthValue() - 1); + } else { + return CelFunctionBinding.from( + "timestamp_to_month_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> (long) newLocalDateTime(ts, tz).getMonthValue() - 1); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetMonthOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetMonthFunction(ImmutableSet overloads) { + super("getMonth", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GetSecondsFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/GetSecondsFunction.java new file mode 100644 index 000000000..80030f50f --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GetSecondsFunction.java @@ -0,0 +1,119 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.internal.DateTimeHelpers.UTC; +import static dev.cel.common.internal.DateTimeHelpers.newLocalDateTime; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code getSeconds}. */ +public final class GetSecondsFunction extends CelStandardFunction { + + private static final GetSecondsFunction ALL_OVERLOADS = create(GetSecondsOverload.values()); + + public static GetSecondsFunction create() { + return ALL_OVERLOADS; + } + + public static GetSecondsFunction create(GetSecondsFunction.GetSecondsOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GetSecondsFunction create( + Iterable overloads) { + return new GetSecondsFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GetSecondsOverload implements CelStandardOverload { + TIMESTAMP_TO_SECONDS( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_seconds", + Instant.class, + (Instant ts) -> (long) newLocalDateTime(ts, UTC).getSecond()); + } else { + return CelFunctionBinding.from( + "timestamp_to_seconds", + Timestamp.class, + (Timestamp ts) -> (long) newLocalDateTime(ts, UTC).getSecond()); + } + }), + TIMESTAMP_TO_SECONDS_WITH_TZ( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_seconds_with_tz", + Instant.class, + String.class, + (Instant ts, String tz) -> (long) newLocalDateTime(ts, tz).getSecond()); + } else { + return CelFunctionBinding.from( + "timestamp_to_seconds_with_tz", + Timestamp.class, + String.class, + (Timestamp ts, String tz) -> (long) newLocalDateTime(ts, tz).getSecond()); + } + }), + DURATION_TO_SECONDS( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "duration_to_seconds", + java.time.Duration.class, + dur -> { + long truncatedSeconds = dur.getSeconds(); + // Preserve the existing behavior from protobuf where seconds is truncated towards + // 0 when negative. + if (dur.isNegative() && dur.getNano() > 0) { + truncatedSeconds++; + } + + return truncatedSeconds; + }); + } else { + return CelFunctionBinding.from( + "duration_to_seconds", Duration.class, ProtoTimeUtils::toSeconds); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GetSecondsOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GetSecondsFunction(ImmutableSet overloads) { + super("getSeconds", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GreaterEqualsOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/GreaterEqualsOperator.java new file mode 100644 index 000000000..c04b4398f --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GreaterEqualsOperator.java @@ -0,0 +1,204 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.GREATER_EQUALS; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.ComparisonFunctions; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for the greater equals (>=) operator. */ +public final class GreaterEqualsOperator extends CelStandardFunction { + private static final GreaterEqualsOperator ALL_OVERLOADS = create(GreaterEqualsOverload.values()); + + public static GreaterEqualsOperator create() { + return ALL_OVERLOADS; + } + + public static GreaterEqualsOperator create( + GreaterEqualsOperator.GreaterEqualsOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GreaterEqualsOperator create( + Iterable overloads) { + return new GreaterEqualsOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GreaterEqualsOverload implements CelStandardOverload { + GREATER_EQUALS_BOOL( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_bool", + Boolean.class, + Boolean.class, + (Boolean x, Boolean y) -> x || !y)), + GREATER_EQUALS_BYTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "greater_equals_bytes", + CelByteString.class, + CelByteString.class, + (CelByteString x, CelByteString y) -> + CelByteString.unsignedLexicographicalComparator().compare(x, y) >= 0); + } else { + return CelFunctionBinding.from( + "greater_equals_bytes", + ByteString.class, + ByteString.class, + (ByteString x, ByteString y) -> + ByteString.unsignedLexicographicalComparator().compare(x, y) >= 0); + } + }), + GREATER_EQUALS_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_double", + Double.class, + Double.class, + (Double x, Double y) -> x >= y)), + GREATER_EQUALS_DURATION( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "greater_equals_duration", + java.time.Duration.class, + java.time.Duration.class, + (java.time.Duration d1, java.time.Duration d2) -> d1.compareTo(d2) >= 0); + } else { + return CelFunctionBinding.from( + "greater_equals_duration", + Duration.class, + Duration.class, + (Duration d1, Duration d2) -> ProtoTimeUtils.compare(d1, d2) >= 0); + } + }), + GREATER_EQUALS_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_int64", Long.class, Long.class, (Long x, Long y) -> x >= y)), + GREATER_EQUALS_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_string", + String.class, + String.class, + (String x, String y) -> x.compareTo(y) >= 0)), + GREATER_EQUALS_TIMESTAMP( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "greater_equals_timestamp", + Instant.class, + Instant.class, + (Instant i1, Instant i2) -> i1.compareTo(i2) >= 0); + } else { + return CelFunctionBinding.from( + "greater_equals_timestamp", + Timestamp.class, + Timestamp.class, + (Timestamp t1, Timestamp t2) -> ProtoTimeUtils.compare(t1, t2) >= 0); + } + }), + GREATER_EQUALS_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "greater_equals_uint64", + UnsignedLong.class, + UnsignedLong.class, + (UnsignedLong x, UnsignedLong y) -> RuntimeHelpers.uint64CompareTo(x, y) >= 0); + } else { + return CelFunctionBinding.from( + "greater_equals_uint64", + Long.class, + Long.class, + (Long x, Long y) -> RuntimeHelpers.uint64CompareTo(x, y, celOptions) >= 0); + } + }), + GREATER_EQUALS_INT64_UINT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_int64_uint64", + Long.class, + UnsignedLong.class, + (Long x, UnsignedLong y) -> ComparisonFunctions.compareIntUint(x, y) >= 0)), + GREATER_EQUALS_UINT64_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_uint64_int64", + UnsignedLong.class, + Long.class, + (UnsignedLong x, Long y) -> ComparisonFunctions.compareUintInt(x, y) >= 0)), + GREATER_EQUALS_INT64_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_int64_double", + Long.class, + Double.class, + (Long x, Double y) -> ComparisonFunctions.compareIntDouble(x, y) >= 0)), + GREATER_EQUALS_DOUBLE_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_double_int64", + Double.class, + Long.class, + (Double x, Long y) -> ComparisonFunctions.compareDoubleInt(x, y) >= 0)), + GREATER_EQUALS_UINT64_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_uint64_double", + UnsignedLong.class, + Double.class, + (UnsignedLong x, Double y) -> ComparisonFunctions.compareUintDouble(x, y) >= 0)), + GREATER_EQUALS_DOUBLE_UINT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_equals_double_uint64", + Double.class, + UnsignedLong.class, + (Double x, UnsignedLong y) -> ComparisonFunctions.compareDoubleUint(x, y) >= 0)); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GreaterEqualsOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GreaterEqualsOperator(ImmutableSet overloads) { + super(GREATER_EQUALS.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/GreaterOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/GreaterOperator.java new file mode 100644 index 000000000..80edb8a9b --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/GreaterOperator.java @@ -0,0 +1,197 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.GREATER; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.ComparisonFunctions; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for the greater (>) operator. */ +public final class GreaterOperator extends CelStandardFunction { + private static final GreaterOperator ALL_OVERLOADS = create(GreaterOverload.values()); + + public static GreaterOperator create() { + return ALL_OVERLOADS; + } + + public static GreaterOperator create(GreaterOperator.GreaterOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static GreaterOperator create(Iterable overloads) { + return new GreaterOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum GreaterOverload implements CelStandardOverload { + GREATER_BOOL( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_bool", Boolean.class, Boolean.class, (Boolean x, Boolean y) -> x && !y)), + GREATER_BYTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "greater_bytes", + CelByteString.class, + CelByteString.class, + (CelByteString x, CelByteString y) -> + CelByteString.unsignedLexicographicalComparator().compare(x, y) > 0); + } else { + return CelFunctionBinding.from( + "greater_bytes", + ByteString.class, + ByteString.class, + (ByteString x, ByteString y) -> + ByteString.unsignedLexicographicalComparator().compare(x, y) > 0); + } + }), + GREATER_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_double", Double.class, Double.class, (Double x, Double y) -> x > y)), + GREATER_DURATION( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "greater_duration", + java.time.Duration.class, + java.time.Duration.class, + (java.time.Duration d1, java.time.Duration d2) -> d1.compareTo(d2) > 0); + } else { + return CelFunctionBinding.from( + "greater_duration", + Duration.class, + Duration.class, + (Duration d1, Duration d2) -> ProtoTimeUtils.compare(d1, d2) > 0); + } + }), + GREATER_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_int64", Long.class, Long.class, (Long x, Long y) -> x > y)), + GREATER_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_string", + String.class, + String.class, + (String x, String y) -> x.compareTo(y) > 0)), + GREATER_TIMESTAMP( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "greater_timestamp", + Instant.class, + Instant.class, + (Instant i1, Instant i2) -> i1.isAfter(i2)); + } else { + return CelFunctionBinding.from( + "greater_timestamp", + Timestamp.class, + Timestamp.class, + (Timestamp t1, Timestamp t2) -> ProtoTimeUtils.compare(t1, t2) > 0); + } + }), + GREATER_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "greater_uint64", + UnsignedLong.class, + UnsignedLong.class, + (UnsignedLong x, UnsignedLong y) -> RuntimeHelpers.uint64CompareTo(x, y) > 0); + } else { + return CelFunctionBinding.from( + "greater_uint64", + Long.class, + Long.class, + (Long x, Long y) -> RuntimeHelpers.uint64CompareTo(x, y, celOptions) > 0); + } + }), + GREATER_INT64_UINT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_int64_uint64", + Long.class, + UnsignedLong.class, + (Long x, UnsignedLong y) -> ComparisonFunctions.compareIntUint(x, y) == 1)), + GREATER_UINT64_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_uint64_int64", + UnsignedLong.class, + Long.class, + (UnsignedLong x, Long y) -> ComparisonFunctions.compareUintInt(x, y) == 1)), + GREATER_INT64_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_int64_double", + Long.class, + Double.class, + (Long x, Double y) -> ComparisonFunctions.compareIntDouble(x, y) == 1)), + GREATER_DOUBLE_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_double_int64", + Double.class, + Long.class, + (Double x, Long y) -> ComparisonFunctions.compareDoubleInt(x, y) == 1)), + GREATER_UINT64_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_uint64_double", + UnsignedLong.class, + Double.class, + (UnsignedLong x, Double y) -> ComparisonFunctions.compareUintDouble(x, y) == 1)), + GREATER_DOUBLE_UINT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "greater_double_uint64", + Double.class, + UnsignedLong.class, + (Double x, UnsignedLong y) -> ComparisonFunctions.compareDoubleUint(x, y) == 1)), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + GreaterOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private GreaterOperator(ImmutableSet overloads) { + super(GREATER.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/InOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/InOperator.java new file mode 100644 index 000000000..bf80cc6ff --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/InOperator.java @@ -0,0 +1,77 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.IN; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +/** Standard function for the ('in') operator. */ +@SuppressWarnings({"unchecked", "rawtypes"}) +public final class InOperator extends CelStandardFunction { + private static final InOperator ALL_OVERLOADS = create(InOverload.values()); + + public static InOperator create() { + return ALL_OVERLOADS; + } + + public static InOperator create(InOperator.InOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static InOperator create(Iterable overloads) { + return new InOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum InOverload implements CelStandardOverload { + IN_LIST( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "in_list", + Object.class, + List.class, + (Object value, List list) -> runtimeEquality.inList(list, value))), + IN_MAP( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "in_map", + Object.class, + Map.class, + (Object key, Map map) -> runtimeEquality.inMap(map, key))); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + InOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private InOperator(ImmutableSet overloads) { + super(IN.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/IndexOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/IndexOperator.java new file mode 100644 index 000000000..f48e8fbf5 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/IndexOperator.java @@ -0,0 +1,72 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.INDEX; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +/** Standard function for the indexing ({@code list[0] or map['foo']}) operator */ +public final class IndexOperator extends CelStandardFunction { + private static final IndexOperator ALL_OVERLOADS = create(IndexOverload.values()); + + public static IndexOperator create() { + return ALL_OVERLOADS; + } + + public static IndexOperator create(IndexOperator.IndexOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static IndexOperator create(Iterable overloads) { + return new IndexOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + @SuppressWarnings({"unchecked"}) + public enum IndexOverload implements CelStandardOverload { + INDEX_LIST( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "index_list", List.class, Number.class, RuntimeHelpers::indexList)), + INDEX_MAP( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "index_map", Map.class, Object.class, runtimeEquality::indexMap)); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + IndexOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private IndexOperator(ImmutableSet overloads) { + super(INDEX.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/IntFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/IntFunction.java new file mode 100644 index 000000000..63959af87 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/IntFunction.java @@ -0,0 +1,129 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code int} conversion function. */ +public final class IntFunction extends CelStandardFunction { + private static final IntFunction ALL_OVERLOADS = create(IntOverload.values()); + + public static IntFunction create() { + return ALL_OVERLOADS; + } + + public static IntFunction create(IntFunction.IntOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static IntFunction create(Iterable overloads) { + return new IntFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum IntOverload implements CelStandardOverload { + INT64_TO_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("int64_to_int64", Long.class, (Long x) -> x)), + UINT64_TO_INT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "uint64_to_int64", + UnsignedLong.class, + (UnsignedLong arg) -> { + if (arg.compareTo(UnsignedLong.valueOf(Long.MAX_VALUE)) > 0) { + throw new CelNumericOverflowException("unsigned out of int range"); + } + return arg.longValue(); + }); + } else { + return CelFunctionBinding.from( + "uint64_to_int64", + Long.class, + (Long arg) -> { + if (celOptions.errorOnIntWrap() && arg < 0) { + throw new CelNumericOverflowException("unsigned out of int range"); + } + return arg; + }); + } + }), + DOUBLE_TO_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "double_to_int64", + Double.class, + (Double arg) -> { + if (celOptions.errorOnIntWrap()) { + return RuntimeHelpers.doubleToLongChecked(arg) + .orElseThrow( + () -> + new CelNumericOverflowException("double is out of range for int")); + } + return arg.longValue(); + })), + STRING_TO_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "string_to_int64", + String.class, + (String arg) -> { + try { + return Long.parseLong(arg); + } catch (NumberFormatException e) { + throw new CelBadFormatException(e); + } + })), + TIMESTAMP_TO_INT64( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_int64", Instant.class, Instant::getEpochSecond); + } else { + return CelFunctionBinding.from( + "timestamp_to_int64", Timestamp.class, ProtoTimeUtils::toSeconds); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + IntOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private IntFunction(ImmutableSet overloads) { + super("int", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/LessEqualsOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/LessEqualsOperator.java new file mode 100644 index 000000000..7688acbc1 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/LessEqualsOperator.java @@ -0,0 +1,201 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.LESS_EQUALS; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.ComparisonFunctions; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for the less equals (<=) operator. */ +public final class LessEqualsOperator extends CelStandardFunction { + private static final LessEqualsOperator ALL_OVERLOADS = create(LessEqualsOverload.values()); + + public static LessEqualsOperator create() { + return ALL_OVERLOADS; + } + + public static LessEqualsOperator create(LessEqualsOperator.LessEqualsOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static LessEqualsOperator create( + Iterable overloads) { + return new LessEqualsOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum LessEqualsOverload implements CelStandardOverload { + LESS_EQUALS_BOOL( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_bool", + Boolean.class, + Boolean.class, + (Boolean x, Boolean y) -> !x || y)), + LESS_EQUALS_BYTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "less_equals_bytes", + CelByteString.class, + CelByteString.class, + (CelByteString x, CelByteString y) -> + CelByteString.unsignedLexicographicalComparator().compare(x, y) <= 0); + } else { + return CelFunctionBinding.from( + "less_equals_bytes", + ByteString.class, + ByteString.class, + (ByteString x, ByteString y) -> + ByteString.unsignedLexicographicalComparator().compare(x, y) <= 0); + } + }), + LESS_EQUALS_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_double", Double.class, Double.class, (Double x, Double y) -> x <= y)), + LESS_EQUALS_DURATION( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "less_equals_duration", + java.time.Duration.class, + java.time.Duration.class, + (java.time.Duration d1, java.time.Duration d2) -> d1.compareTo(d2) <= 0); + } else { + return CelFunctionBinding.from( + "less_equals_duration", + Duration.class, + Duration.class, + (Duration d1, Duration d2) -> ProtoTimeUtils.compare(d1, d2) <= 0); + } + }), + LESS_EQUALS_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_int64", Long.class, Long.class, (Long x, Long y) -> x <= y)), + LESS_EQUALS_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_string", + String.class, + String.class, + (String x, String y) -> x.compareTo(y) <= 0)), + LESS_EQUALS_TIMESTAMP( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "less_equals_timestamp", + Instant.class, + Instant.class, + (Instant i1, Instant i2) -> i1.compareTo(i2) <= 0); + } else { + return CelFunctionBinding.from( + "less_equals_timestamp", + Timestamp.class, + Timestamp.class, + (Timestamp t1, Timestamp t2) -> ProtoTimeUtils.compare(t1, t2) <= 0); + } + }), + LESS_EQUALS_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "less_equals_uint64", + UnsignedLong.class, + UnsignedLong.class, + (UnsignedLong x, UnsignedLong y) -> RuntimeHelpers.uint64CompareTo(x, y) <= 0); + } else { + return CelFunctionBinding.from( + "less_equals_uint64", + Long.class, + Long.class, + (Long x, Long y) -> RuntimeHelpers.uint64CompareTo(x, y, celOptions) <= 0); + } + }), + LESS_EQUALS_INT64_UINT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_int64_uint64", + Long.class, + UnsignedLong.class, + (Long x, UnsignedLong y) -> ComparisonFunctions.compareIntUint(x, y) <= 0)), + LESS_EQUALS_UINT64_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_uint64_int64", + UnsignedLong.class, + Long.class, + (UnsignedLong x, Long y) -> ComparisonFunctions.compareUintInt(x, y) <= 0)), + LESS_EQUALS_INT64_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_int64_double", + Long.class, + Double.class, + (Long x, Double y) -> ComparisonFunctions.compareIntDouble(x, y) <= 0)), + LESS_EQUALS_DOUBLE_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_double_int64", + Double.class, + Long.class, + (Double x, Long y) -> ComparisonFunctions.compareDoubleInt(x, y) <= 0)), + LESS_EQUALS_UINT64_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_uint64_double", + UnsignedLong.class, + Double.class, + (UnsignedLong x, Double y) -> ComparisonFunctions.compareUintDouble(x, y) <= 0)), + LESS_EQUALS_DOUBLE_UINT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_equals_double_uint64", + Double.class, + UnsignedLong.class, + (Double x, UnsignedLong y) -> ComparisonFunctions.compareDoubleUint(x, y) <= 0)), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + LessEqualsOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private LessEqualsOperator(ImmutableSet overloads) { + super(LESS_EQUALS.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/LessOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/LessOperator.java new file mode 100644 index 000000000..a53a13a92 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/LessOperator.java @@ -0,0 +1,197 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.LESS; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.ByteString; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.ComparisonFunctions; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for the less (<) operator. */ +public final class LessOperator extends CelStandardFunction { + private static final LessOperator ALL_OVERLOADS = create(LessOverload.values()); + + public static LessOperator create() { + return ALL_OVERLOADS; + } + + public static LessOperator create(LessOperator.LessOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static LessOperator create(Iterable overloads) { + return new LessOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum LessOverload implements CelStandardOverload { + LESS_BOOL( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_bool", Boolean.class, Boolean.class, (Boolean x, Boolean y) -> !x && y)), + LESS_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_int64", Long.class, Long.class, (Long x, Long y) -> x < y)), + LESS_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "less_uint64", + UnsignedLong.class, + UnsignedLong.class, + (UnsignedLong x, UnsignedLong y) -> RuntimeHelpers.uint64CompareTo(x, y) < 0); + } else { + return CelFunctionBinding.from( + "less_uint64", + Long.class, + Long.class, + (Long x, Long y) -> RuntimeHelpers.uint64CompareTo(x, y, celOptions) < 0); + } + }), + LESS_BYTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "less_bytes", + CelByteString.class, + CelByteString.class, + (CelByteString x, CelByteString y) -> + CelByteString.unsignedLexicographicalComparator().compare(x, y) < 0); + } else { + return CelFunctionBinding.from( + "less_bytes", + ByteString.class, + ByteString.class, + (ByteString x, ByteString y) -> + ByteString.unsignedLexicographicalComparator().compare(x, y) < 0); + } + }), + LESS_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_double", Double.class, Double.class, (Double x, Double y) -> x < y)), + LESS_DOUBLE_UINT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_double_uint64", + Double.class, + UnsignedLong.class, + (Double x, UnsignedLong y) -> ComparisonFunctions.compareDoubleUint(x, y) == -1)), + LESS_INT64_UINT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_int64_uint64", + Long.class, + UnsignedLong.class, + (Long x, UnsignedLong y) -> ComparisonFunctions.compareIntUint(x, y) == -1)), + LESS_UINT64_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_uint64_int64", + UnsignedLong.class, + Long.class, + (UnsignedLong x, Long y) -> ComparisonFunctions.compareUintInt(x, y) == -1)), + LESS_INT64_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_int64_double", + Long.class, + Double.class, + (Long x, Double y) -> ComparisonFunctions.compareIntDouble(x, y) == -1)), + LESS_DOUBLE_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_double_int64", + Double.class, + Long.class, + (Double x, Long y) -> ComparisonFunctions.compareDoubleInt(x, y) == -1)), + LESS_UINT64_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_uint64_double", + UnsignedLong.class, + Double.class, + (UnsignedLong x, Double y) -> ComparisonFunctions.compareUintDouble(x, y) == -1)), + LESS_DURATION( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "less_duration", + java.time.Duration.class, + java.time.Duration.class, + (java.time.Duration d1, java.time.Duration d2) -> d1.compareTo(d2) < 0); + } else { + return CelFunctionBinding.from( + "less_duration", + Duration.class, + Duration.class, + (Duration d1, Duration d2) -> ProtoTimeUtils.compare(d1, d2) < 0); + } + }), + LESS_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "less_string", + String.class, + String.class, + (String x, String y) -> x.compareTo(y) < 0)), + LESS_TIMESTAMP( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "less_timestamp", + Instant.class, + Instant.class, + (Instant i1, Instant i2) -> i1.isBefore(i2)); + } else { + return CelFunctionBinding.from( + "less_timestamp", + Timestamp.class, + Timestamp.class, + (Timestamp t1, Timestamp t2) -> ProtoTimeUtils.compare(t1, t2) < 0); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + LessOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private LessOperator(ImmutableSet overloads) { + super(LESS.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/LogicalNotOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/LogicalNotOperator.java new file mode 100644 index 000000000..6c2ec8efd --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/LogicalNotOperator.java @@ -0,0 +1,64 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.LOGICAL_NOT; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for the logical not (!=) operator. */ +public final class LogicalNotOperator extends CelStandardFunction { + private static final LogicalNotOperator ALL_OVERLOADS = create(LogicalNotOverload.values()); + + public static LogicalNotOperator create() { + return ALL_OVERLOADS; + } + + public static LogicalNotOperator create(LogicalNotOperator.LogicalNotOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static LogicalNotOperator create( + Iterable overloads) { + return new LogicalNotOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum LogicalNotOverload implements CelStandardOverload { + LOGICAL_NOT( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("logical_not", Boolean.class, (Boolean x) -> !x)); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + LogicalNotOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private LogicalNotOperator(ImmutableSet overloads) { + super(LOGICAL_NOT.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/MatchesFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/MatchesFunction.java new file mode 100644 index 000000000..a82a7d439 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/MatchesFunction.java @@ -0,0 +1,88 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelInvalidArgumentException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.util.Arrays; + +/** Standard function for {@code matches}. */ +public final class MatchesFunction extends CelStandardFunction { + private static final MatchesFunction ALL_OVERLOADS = create(MatchesOverload.values()); + + public static MatchesFunction create() { + return ALL_OVERLOADS; + } + + public static MatchesFunction create(MatchesFunction.MatchesOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static MatchesFunction create(Iterable overloads) { + return new MatchesFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum MatchesOverload implements CelStandardOverload { + MATCHES( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "matches", + String.class, + String.class, + (String string, String regexp) -> { + try { + return RuntimeHelpers.matches(string, regexp, celOptions); + } catch (RuntimeException e) { + throw new CelInvalidArgumentException(e); + } + })), + // Duplicate receiver-style matches overload. + MATCHES_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "matches_string", + String.class, + String.class, + (String string, String regexp) -> { + try { + return RuntimeHelpers.matches(string, regexp, celOptions); + } catch (RuntimeException e) { + throw new CelInvalidArgumentException(e); + } + })), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + MatchesOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private MatchesFunction(ImmutableSet overloads) { + super("matches", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/ModuloOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/ModuloOperator.java new file mode 100644 index 000000000..baa74fe15 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/ModuloOperator.java @@ -0,0 +1,90 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.MODULO; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelDivideByZeroException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.util.Arrays; + +/** Standard function for the modulus (%) operator. */ +public final class ModuloOperator extends CelStandardFunction { + private static final ModuloOperator ALL_OVERLOADS = create(ModuloOverload.values()); + + public static ModuloOperator create() { + return ALL_OVERLOADS; + } + + public static ModuloOperator create(ModuloOperator.ModuloOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static ModuloOperator create(Iterable overloads) { + return new ModuloOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum ModuloOverload implements CelStandardOverload { + MODULO_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "modulo_int64", + Long.class, + Long.class, + (Long x, Long y) -> { + try { + return x % y; + } catch (ArithmeticException e) { + throw new CelDivideByZeroException(e); + } + })), + MODULO_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "modulo_uint64", UnsignedLong.class, UnsignedLong.class, RuntimeHelpers::uint64Mod); + } else { + return CelFunctionBinding.from( + "modulo_uint64", + Long.class, + Long.class, + (Long x, Long y) -> RuntimeHelpers.uint64Mod(x, y, celOptions)); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + ModuloOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private ModuloOperator(ImmutableSet overloads) { + super(MODULO.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/MultiplyOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/MultiplyOperator.java new file mode 100644 index 000000000..425723652 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/MultiplyOperator.java @@ -0,0 +1,108 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.MULTIPLY; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.util.Arrays; + +/** Standard function for the multiplication (*) operator. */ +public final class MultiplyOperator extends CelStandardFunction { + private static final MultiplyOperator ALL_OVERLOADS = create(MultiplyOverload.values()); + + public static MultiplyOperator create() { + return ALL_OVERLOADS; + } + + public static MultiplyOperator create(MultiplyOperator.MultiplyOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static MultiplyOperator create(Iterable overloads) { + return new MultiplyOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum MultiplyOverload implements CelStandardOverload { + MULTIPLY_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "multiply_int64", + Long.class, + Long.class, + (Long x, Long y) -> { + try { + return RuntimeHelpers.int64Multiply(x, y, celOptions); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + })), + MULTIPLY_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "multiply_double", Double.class, Double.class, (Double x, Double y) -> x * y)), + MULTIPLY_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "multiply_uint64", + UnsignedLong.class, + UnsignedLong.class, + (UnsignedLong x, UnsignedLong y) -> { + try { + return RuntimeHelpers.uint64Multiply(x, y); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + }); + } else { + return CelFunctionBinding.from( + "multiply_uint64", + Long.class, + Long.class, + (Long x, Long y) -> { + try { + return RuntimeHelpers.uint64Multiply(x, y, celOptions); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + }); + } + }); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + MultiplyOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private MultiplyOperator(ImmutableSet overloads) { + super(MULTIPLY.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/NegateOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/NegateOperator.java new file mode 100644 index 000000000..c61c395cb --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/NegateOperator.java @@ -0,0 +1,77 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.NEGATE; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.util.Arrays; + +/** Standard function for the negate (-) operator. */ +public final class NegateOperator extends CelStandardFunction { + private static final NegateOperator ALL_OVERLOADS = create(NegateOverload.values()); + + public static NegateOperator create() { + return ALL_OVERLOADS; + } + + public static NegateOperator create(NegateOperator.NegateOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static NegateOperator create(Iterable overloads) { + return new NegateOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum NegateOverload implements CelStandardOverload { + NEGATE_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "negate_int64", + Long.class, + (Long x) -> { + try { + return RuntimeHelpers.int64Negate(x, celOptions); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + })), + NEGATE_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("negate_double", Double.class, (Double x) -> -x)); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + NegateOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private NegateOperator(ImmutableSet overloads) { + super(NEGATE.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/NotEqualsOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/NotEqualsOperator.java new file mode 100644 index 000000000..27b17676e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/NotEqualsOperator.java @@ -0,0 +1,67 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.NOT_EQUALS; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for the not equals (!=) operator. */ +public final class NotEqualsOperator extends CelStandardFunction { + private static final NotEqualsOperator ALL_OVERLOADS = create(NotEqualsOverload.values()); + + public static NotEqualsOperator create() { + return ALL_OVERLOADS; + } + + public static NotEqualsOperator create(NotEqualsOperator.NotEqualsOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static NotEqualsOperator create(Iterable overloads) { + return new NotEqualsOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum NotEqualsOverload implements CelStandardOverload { + NOT_EQUALS( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "not_equals", + Object.class, + Object.class, + (Object x, Object y) -> !runtimeEquality.objectEquals(x, y))); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + NotEqualsOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private NotEqualsOperator(ImmutableSet overloads) { + super(NOT_EQUALS.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/NotStrictlyFalseFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/NotStrictlyFalseFunction.java new file mode 100644 index 000000000..8e0ceead4 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/NotStrictlyFalseFunction.java @@ -0,0 +1,70 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.NOT_STRICTLY_FALSE; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.InternalFunctionBinder; +import dev.cel.runtime.RuntimeEquality; + +/** + * Standard function for {@code @not_strictly_false}. This is an internal function used within + * comprehensions to coerce the result into true if an evaluation yields an error or an unknown set. + */ +public final class NotStrictlyFalseFunction extends CelStandardFunction { + private static final NotStrictlyFalseFunction ALL_OVERLOADS = + new NotStrictlyFalseFunction(ImmutableSet.copyOf(NotStrictlyFalseOverload.values())); + + public static NotStrictlyFalseFunction create() { + return ALL_OVERLOADS; + } + + /** Overloads for the standard function. */ + public enum NotStrictlyFalseOverload implements CelStandardOverload { + NOT_STRICTLY_FALSE( + (celOptions, runtimeEquality) -> + InternalFunctionBinder.from( + "not_strictly_false", + Object.class, + (Object value) -> { + if (value instanceof Boolean) { + return value; + } + + return true; + }, + /* isStrict= */ false)), + ; + + private final CelStandardOverload bindingCreator; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return bindingCreator.newFunctionBinding(celOptions, runtimeEquality); + } + + NotStrictlyFalseOverload(CelStandardOverload bindingCreator) { + this.bindingCreator = bindingCreator; + } + } + + private NotStrictlyFalseFunction(ImmutableSet overloads) { + super(NOT_STRICTLY_FALSE.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/SizeFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/SizeFunction.java new file mode 100644 index 000000000..a8f787665 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/SizeFunction.java @@ -0,0 +1,103 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.ByteString; +import dev.cel.common.CelOptions; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +/** Standard function for {@code size}. */ +public final class SizeFunction extends CelStandardFunction { + private static final SizeFunction ALL_OVERLOADS = create(SizeOverload.values()); + + public static SizeFunction create() { + return ALL_OVERLOADS; + } + + public static SizeFunction create(SizeFunction.SizeOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static SizeFunction create(Iterable overloads) { + return new SizeFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + @SuppressWarnings("rawtypes") + public enum SizeOverload implements CelStandardOverload { + SIZE_BYTES( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "size_bytes", CelByteString.class, (CelByteString bytes) -> (long) bytes.size()); + } else { + return CelFunctionBinding.from( + "size_bytes", ByteString.class, (ByteString bytes) -> (long) bytes.size()); + } + }), + BYTES_SIZE( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "bytes_size", CelByteString.class, (CelByteString bytes) -> (long) bytes.size()); + } else { + return CelFunctionBinding.from( + "bytes_size", ByteString.class, (ByteString bytes) -> (long) bytes.size()); + } + }), + SIZE_LIST( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("size_list", List.class, (List list1) -> (long) list1.size())), + LIST_SIZE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("list_size", List.class, (List list1) -> (long) list1.size())), + SIZE_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "size_string", String.class, (String s) -> (long) s.codePointCount(0, s.length()))), + STRING_SIZE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "string_size", String.class, (String s) -> (long) s.codePointCount(0, s.length()))), + SIZE_MAP( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("size_map", Map.class, (Map map1) -> (long) map1.size())), + MAP_SIZE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("map_size", Map.class, (Map map1) -> (long) map1.size())); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + SizeOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private SizeFunction(ImmutableSet overloads) { + super("size", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/StartsWithFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/StartsWithFunction.java new file mode 100644 index 000000000..457dd3cf1 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/StartsWithFunction.java @@ -0,0 +1,63 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.util.Arrays; + +/** Standard function for {@code startsWith}. */ +public final class StartsWithFunction extends CelStandardFunction { + private static final StartsWithFunction ALL_OVERLOADS = create(StartsWithOverload.values()); + + public static StartsWithFunction create() { + return ALL_OVERLOADS; + } + + public static StartsWithFunction create(StartsWithFunction.StartsWithOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static StartsWithFunction create( + Iterable overloads) { + return new StartsWithFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum StartsWithOverload implements CelStandardOverload { + STARTS_WITH_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "starts_with_string", String.class, String.class, String::startsWith)); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + StartsWithOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private StartsWithFunction(ImmutableSet overloads) { + super("startsWith", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/StringFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/StringFunction.java new file mode 100644 index 000000000..8fbc8add7 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/StringFunction.java @@ -0,0 +1,134 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.common.primitives.UnsignedLongs; +import com.google.protobuf.ByteString; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.common.internal.DateTimeHelpers; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for {@code string} conversion function. */ +public final class StringFunction extends CelStandardFunction { + private static final StringFunction ALL_OVERLOADS = create(StringOverload.values()); + + public static StringFunction create() { + return ALL_OVERLOADS; + } + + public static StringFunction create(StringFunction.StringOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static StringFunction create(Iterable overloads) { + return new StringFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum StringOverload implements CelStandardOverload { + STRING_TO_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("string_to_string", String.class, (String x) -> x)), + INT64_TO_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("int64_to_string", Long.class, Object::toString)), + DOUBLE_TO_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("double_to_string", Double.class, Object::toString)), + BOOL_TO_STRING( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from("bool_to_string", Boolean.class, Object::toString)), + BYTES_TO_STRING( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "bytes_to_string", + CelByteString.class, + (byteStr) -> { + if (!byteStr.isValidUtf8()) { + throw new CelBadFormatException( + "invalid UTF-8 in bytes, cannot convert to string"); + } + return byteStr.toStringUtf8(); + }); + } else { + return CelFunctionBinding.from( + "bytes_to_string", + ByteString.class, + (byteStr) -> { + if (!byteStr.isValidUtf8()) { + throw new CelBadFormatException( + "invalid UTF-8 in bytes, cannot convert to string"); + } + return byteStr.toStringUtf8(); + }); + } + }), + TIMESTAMP_TO_STRING( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from("timestamp_to_string", Instant.class, Instant::toString); + } else { + return CelFunctionBinding.from( + "timestamp_to_string", Timestamp.class, ProtoTimeUtils::toString); + } + }), + DURATION_TO_STRING( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "duration_to_string", java.time.Duration.class, DateTimeHelpers::toString); + } else { + return CelFunctionBinding.from( + "duration_to_string", Duration.class, ProtoTimeUtils::toString); + } + }), + UINT64_TO_STRING( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "uint64_to_string", UnsignedLong.class, UnsignedLong::toString); + } else { + return CelFunctionBinding.from("uint64_to_string", Long.class, UnsignedLongs::toString); + } + }); + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + StringOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private StringFunction(ImmutableSet overloads) { + super("string", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/SubtractOperator.java b/runtime/src/main/java/dev/cel/runtime/standard/SubtractOperator.java new file mode 100644 index 000000000..784c46825 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/SubtractOperator.java @@ -0,0 +1,162 @@ +// Copyright 2025 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.standard; + +import static dev.cel.common.Operator.SUBTRACT; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Duration; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.common.internal.DateTimeHelpers; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.time.Instant; +import java.util.Arrays; + +/** Standard function for the subtraction (-) operator. */ +public final class SubtractOperator extends CelStandardFunction { + private static final SubtractOperator ALL_OVERLOADS = create(SubtractOverload.values()); + + public static SubtractOperator create() { + return ALL_OVERLOADS; + } + + public static SubtractOperator create(SubtractOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static SubtractOperator create(Iterable overloads) { + return new SubtractOperator(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum SubtractOverload implements CelStandardOverload { + SUBTRACT_INT64( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "subtract_int64", + Long.class, + Long.class, + (Long x, Long y) -> { + try { + return RuntimeHelpers.int64Subtract(x, y, celOptions); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + })), + SUBTRACT_TIMESTAMP_TIMESTAMP( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "subtract_timestamp_timestamp", + Instant.class, + Instant.class, + (Instant i1, Instant i2) -> java.time.Duration.between(i2, i1)); + } else { + return CelFunctionBinding.from( + "subtract_timestamp_timestamp", + Timestamp.class, + Timestamp.class, + (Timestamp t1, Timestamp t2) -> ProtoTimeUtils.between(t2, t1)); + } + }), + SUBTRACT_TIMESTAMP_DURATION( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "subtract_timestamp_duration", + Instant.class, + java.time.Duration.class, + DateTimeHelpers::subtract); + } else { + return CelFunctionBinding.from( + "subtract_timestamp_duration", + Timestamp.class, + Duration.class, + ProtoTimeUtils::subtract); + } + }), + SUBTRACT_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "subtract_uint64", + UnsignedLong.class, + UnsignedLong.class, + (UnsignedLong x, UnsignedLong y) -> { + try { + return RuntimeHelpers.uint64Subtract(x, y); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + }); + } else { + return CelFunctionBinding.from( + "subtract_uint64", + Long.class, + Long.class, + (Long x, Long y) -> { + try { + return RuntimeHelpers.uint64Subtract(x, y, celOptions); + } catch (ArithmeticException e) { + throw new CelNumericOverflowException(e); + } + }); + } + }), + SUBTRACT_DOUBLE( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "subtract_double", Double.class, Double.class, (Double x, Double y) -> x - y)), + SUBTRACT_DURATION_DURATION( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "subtract_duration_duration", + java.time.Duration.class, + java.time.Duration.class, + DateTimeHelpers::subtract); + } else { + return CelFunctionBinding.from( + "subtract_duration_duration", + Duration.class, + Duration.class, + ProtoTimeUtils::subtract); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + SubtractOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private SubtractOperator(ImmutableSet overloads) { + super(SUBTRACT.getFunction(), overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/TimestampFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/TimestampFunction.java new file mode 100644 index 000000000..00a4ed43e --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/TimestampFunction.java @@ -0,0 +1,111 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Timestamp; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.common.internal.DateTimeHelpers; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import java.text.ParseException; +import java.time.Instant; +import java.time.format.DateTimeParseException; +import java.util.Arrays; + +/** Standard function for {@code timestamp} conversion function. */ +public final class TimestampFunction extends CelStandardFunction { + private static final TimestampFunction ALL_OVERLOADS = create(TimestampOverload.values()); + + public static TimestampFunction create() { + return ALL_OVERLOADS; + } + + public static TimestampFunction create(TimestampFunction.TimestampOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static TimestampFunction create(Iterable overloads) { + return new TimestampFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum TimestampOverload implements CelStandardOverload { + STRING_TO_TIMESTAMP( + (celOptions, runtimeEquality) -> + CelFunctionBinding.from( + "string_to_timestamp", + String.class, + (String ts) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + try { + return DateTimeHelpers.parse(ts); + } catch (DateTimeParseException e) { + throw new CelBadFormatException(e); + } + + } else { + try { + return ProtoTimeUtils.parse(ts); + } catch (ParseException e) { + throw new CelBadFormatException(e); + } + } + })), + TIMESTAMP_TO_TIMESTAMP( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "timestamp_to_timestamp", Instant.class, (Instant x) -> x); + } else { + return CelFunctionBinding.from( + "timestamp_to_timestamp", Timestamp.class, (Timestamp x) -> x); + } + }), + INT64_TO_TIMESTAMP( + (celOptions, runtimeEquality) -> { + if (celOptions.evaluateCanonicalTypesToNativeValues()) { + return CelFunctionBinding.from( + "int64_to_timestamp", Long.class, epochSecond -> { + Instant instant = Instant.ofEpochSecond(epochSecond); + DateTimeHelpers.checkValid(instant); + return instant; + }); + } else { + return CelFunctionBinding.from( + "int64_to_timestamp", Long.class, ProtoTimeUtils::fromSecondsToTimestamp); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + TimestampOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private TimestampFunction(ImmutableSet overloads) { + super("timestamp", overloads); + } +} diff --git a/runtime/src/main/java/dev/cel/runtime/standard/TypeFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/TypeFunction.java new file mode 100644 index 000000000..b325c0e9c --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/TypeFunction.java @@ -0,0 +1,71 @@ +// 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.standard; + +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelOptions; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeType; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.TypeResolver; + +/** + * Standard function for the {@code type} function. + * + *

The {@code type} function returns the CEL type of its argument. It accepts a + * {@link TypeResolver} so that different runtimes can supply the appropriate resolver (e.g. a + * descriptor-based resolver for full proto, or a base resolver for lite proto). + */ +public final class TypeFunction extends CelStandardFunction { + + private final TypeResolver typeResolver; + + public static TypeFunction create(TypeResolver typeResolver) { + return new TypeFunction(typeResolver); + } + + /** Overloads for the standard {@code type} function. */ + public enum TypeOverload implements CelStandardOverload { + TYPE; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + // This overload is not used directly. The binding is created in TypeFunction via the + // TypeResolver instance. + // TODO: Instantiate from CelStandardFunctions. + throw new UnsupportedOperationException( + "TypeOverload bindings must be created through TypeFunction.create(TypeResolver)"); + } + } + + @Override + public ImmutableSet newFunctionBindings( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + CelFunctionBinding binding = + CelFunctionBinding.from( + "type", + Object.class, + arg -> typeResolver.resolveObjectType(arg, TypeType.create(SimpleType.DYN))); + + return CelFunctionBinding.fromOverloads("type", ImmutableSet.of(binding)); + } + + private TypeFunction(TypeResolver typeResolver) { + super("type", ImmutableSet.copyOf(TypeOverload.values())); + this.typeResolver = typeResolver; + } +} \ No newline at end of file diff --git a/runtime/src/main/java/dev/cel/runtime/standard/UintFunction.java b/runtime/src/main/java/dev/cel/runtime/standard/UintFunction.java new file mode 100644 index 000000000..be2217dd9 --- /dev/null +++ b/runtime/src/main/java/dev/cel/runtime/standard/UintFunction.java @@ -0,0 +1,155 @@ +// Copyright 2025 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.standard; + +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.common.primitives.UnsignedLongs; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import java.math.BigDecimal; +import java.util.Arrays; + +/** Standard function for {@code uint} conversion function. */ +public final class UintFunction extends CelStandardFunction { + private static final UintFunction ALL_OVERLOADS = create(UintOverload.values()); + + public static UintFunction create() { + return ALL_OVERLOADS; + } + + public static UintFunction create(UintFunction.UintOverload... overloads) { + return create(Arrays.asList(overloads)); + } + + public static UintFunction create(Iterable overloads) { + return new UintFunction(ImmutableSet.copyOf(overloads)); + } + + /** Overloads for the standard function. */ + public enum UintOverload implements CelStandardOverload { + UINT64_TO_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "uint64_to_uint64", UnsignedLong.class, (UnsignedLong x) -> x); + } else { + return CelFunctionBinding.from("uint64_to_uint64", Long.class, (Long x) -> x); + } + }), + INT64_TO_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "int64_to_uint64", + Long.class, + (Long arg) -> { + if (celOptions.errorOnIntWrap() && arg < 0) { + throw new CelNumericOverflowException("int out of uint range"); + } + return UnsignedLong.valueOf(arg); + }); + } else { + return CelFunctionBinding.from( + "int64_to_uint64", + Long.class, + (Long arg) -> { + if (celOptions.errorOnIntWrap() && arg < 0) { + throw new CelNumericOverflowException("int out of uint range"); + } + return arg; + }); + } + }), + DOUBLE_TO_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "double_to_uint64", + Double.class, + (Double arg) -> { + if (celOptions.errorOnIntWrap()) { + return RuntimeHelpers.doubleToUnsignedChecked(arg) + .orElseThrow( + () -> new CelNumericOverflowException("double out of uint range")); + } + return UnsignedLong.valueOf(BigDecimal.valueOf(arg).toBigInteger()); + }); + } else { + return CelFunctionBinding.from( + "double_to_uint64", + Double.class, + (Double arg) -> { + if (celOptions.errorOnIntWrap()) { + return RuntimeHelpers.doubleToUnsignedChecked(arg) + .map(UnsignedLong::longValue) + .orElseThrow( + () -> + new CelNumericOverflowException( + "double out of uint range")); + } + return arg.longValue(); + }); + } + }), + STRING_TO_UINT64( + (celOptions, runtimeEquality) -> { + if (celOptions.enableUnsignedLongs()) { + return CelFunctionBinding.from( + "string_to_uint64", + String.class, + (String arg) -> { + try { + return UnsignedLong.valueOf(arg); + } catch (NumberFormatException e) { + throw new CelBadFormatException(e); + } + }); + } else { + return CelFunctionBinding.from( + "string_to_uint64", + String.class, + (String arg) -> { + try { + return UnsignedLongs.parseUnsignedLong(arg); + } catch (NumberFormatException e) { + throw new CelBadFormatException(e); + } + }); + } + }), + ; + + private final CelStandardOverload standardOverload; + + @Override + public CelFunctionBinding newFunctionBinding( + CelOptions celOptions, RuntimeEquality runtimeEquality) { + return standardOverload.newFunctionBinding(celOptions, runtimeEquality); + } + + UintOverload(CelStandardOverload standardOverload) { + this.standardOverload = standardOverload; + } + } + + private UintFunction(ImmutableSet overloads) { + super("uint", overloads); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/ActivationTest.java b/runtime/src/test/java/dev/cel/runtime/ActivationTest.java new file mode 100644 index 000000000..fc435c848 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/ActivationTest.java @@ -0,0 +1,166 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; + +import com.google.common.primitives.UnsignedLong; +import dev.cel.common.CelOptions; +import dev.cel.common.values.NullValue; +import dev.cel.expr.conformance.proto3.NestedTestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedMessage; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class ActivationTest { + + private static final CelOptions TEST_OPTIONS = + CelOptions.current().enableUnsignedLongs(true).build(); + + private static final CelOptions TEST_OPTIONS_SKIP_UNSET_FIELDS = + CelOptions.current() + .enableUnsignedLongs(true) + .fromProtoUnsetFieldOption(CelOptions.ProtoUnsetFieldOptions.SKIP) + .build(); + + @Test + public void copyOf_success_withNullEntries() { + Map map = new HashMap<>(); + map.put("key", null); + map.put(null, "value"); + map.put("valid", "value"); + Activation activation = Activation.copyOf(map); + assertThat(activation.resolve("key")).isNull(); + assertThat(activation.resolve("valid")).isEqualTo("value"); + } + + @Test + public void fromProto() { + NestedMessage nestedMessage = NestedMessage.newBuilder().setBb(1).build(); + Activation activation = ProtoMessageActivationFactory.fromProto(nestedMessage, TEST_OPTIONS); + assertThat(activation.resolve("bb")).isEqualTo(1); + + TestAllTypes testMessage = + TestAllTypes.newBuilder().setSingleNestedMessage(nestedMessage).build(); + activation = ProtoMessageActivationFactory.fromProto(testMessage, TEST_OPTIONS); + assertThat(activation.resolve("single_nested_message")).isEqualTo(nestedMessage); + } + + @Test + public void fromProto_unsetScalarField() { + Activation activation = + ProtoMessageActivationFactory.fromProto(NestedMessage.getDefaultInstance(), TEST_OPTIONS); + assertThat(activation.resolve("bb")).isEqualTo(0); + } + + @Test + public void fromProto_unsetScalarField_skipUnsetFields() { + Activation activation = + ProtoMessageActivationFactory.fromProto( + NestedMessage.getDefaultInstance(), TEST_OPTIONS_SKIP_UNSET_FIELDS); + assertThat(activation.resolve("bb")).isNull(); + } + + @Test + public void fromProto_unsetAnyField() { + // An unset Any field is the only field which cannot be accurately published into an Activation, + // and is instead published as an error value which should fit nicely with the CEL evaluation + // semantics. + Activation activation = + ProtoMessageActivationFactory.fromProto(TestAllTypes.getDefaultInstance(), TEST_OPTIONS); + assertThat(activation.resolve("single_any")).isInstanceOf(Throwable.class); + assertThat((Throwable) activation.resolve("single_any")) + .hasMessageThat() + .contains("illegal field value"); + assertThat((Throwable) activation.resolve("single_any")) + .hasCauseThat() + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + public void fromProto_unsetValueField() { + Activation activation = + ProtoMessageActivationFactory.fromProto(TestAllTypes.getDefaultInstance(), TEST_OPTIONS); + assertThat(activation.resolve("single_value")).isEqualTo(NullValue.NULL_VALUE); + } + + @Test + public void fromProto_unsetMessageField() { + Activation activation = + ProtoMessageActivationFactory.fromProto( + NestedTestAllTypes.getDefaultInstance(), TEST_OPTIONS); + assertThat(activation.resolve("payload")).isEqualTo(TestAllTypes.getDefaultInstance()); + } + + @Test + public void fromProto_unsetRepeatedField() { + Activation activation = + ProtoMessageActivationFactory.fromProto(TestAllTypes.getDefaultInstance(), TEST_OPTIONS); + assertThat(activation.resolve("repeated_int64")).isInstanceOf(List.class); + assertThat((List) activation.resolve("repeated_int64")).isEmpty(); + + assertThat(activation.resolve("repeated_nested_message")).isInstanceOf(List.class); + assertThat((List) activation.resolve("repeated_nested_message")).isEmpty(); + } + + @Test + public void fromProto_unsetRepeatedField_skipUnsetFields() { + Activation activation = + ProtoMessageActivationFactory.fromProto( + TestAllTypes.getDefaultInstance(), TEST_OPTIONS_SKIP_UNSET_FIELDS); + assertThat(activation.resolve("repeated_int64")).isInstanceOf(List.class); + assertThat((List) activation.resolve("repeated_int64")).isEmpty(); + + assertThat(activation.resolve("repeated_nested_message")).isInstanceOf(List.class); + assertThat((List) activation.resolve("repeated_nested_message")).isEmpty(); + } + + @Test + public void fromProto_unsetMapField() { + Activation activation = + ProtoMessageActivationFactory.fromProto(TestAllTypes.getDefaultInstance(), TEST_OPTIONS); + assertThat(activation.resolve("map_int32_int64")).isInstanceOf(Map.class); + assertThat((Map) activation.resolve("map_int32_int64")).isEmpty(); + } + + @Test + public void fromProto_unsetMapField_skipUnsetFields() { + Activation activation = + ProtoMessageActivationFactory.fromProto( + TestAllTypes.getDefaultInstance(), TEST_OPTIONS_SKIP_UNSET_FIELDS); + assertThat(activation.resolve("map_int32_int64")).isInstanceOf(Map.class); + assertThat((Map) activation.resolve("map_int32_int64")).isEmpty(); + } + + @Test + public void fromProto_unsignedLongField_unsignedResult() { + Activation activation = + ProtoMessageActivationFactory.fromProto( + TestAllTypes.newBuilder() + .setSingleUint32(1) + .setSingleUint64(UnsignedLong.MAX_VALUE.longValue()) + .build(), + TEST_OPTIONS); + assertThat((UnsignedLong) activation.resolve("single_uint32")).isEqualTo(UnsignedLong.ONE); + assertThat((UnsignedLong) activation.resolve("single_uint64")) + .isEqualTo(UnsignedLong.MAX_VALUE); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/BUILD.bazel b/runtime/src/test/java/dev/cel/runtime/BUILD.bazel new file mode 100644 index 000000000..e886c3d8a --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/BUILD.bazel @@ -0,0 +1,229 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_local_test") +load("//:testing.bzl", "junit4_test_suites") + +# Invalidate cache after file removal +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, +) + +ANDROID_TESTS = [ + "CelLiteRuntimeAndroidTest.java", +] + +java_library( + name = "tests", + testonly = 1, + srcs = glob( + ["*.java"], + # keep sorted + exclude = [ + "CelLiteInterpreterTest.java", + "InterpreterTest.java", + "PlannerInterpreterTest.java", + ] + ANDROID_TESTS, + ), + deps = [ + "//:auto_value", + "//:java_truth", + "//bundle:cel", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "//common:cel_exception", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:error_codes", + "//common:options", + "//common:proto_v1alpha1_ast", + "//common/ast", + "//common/exceptions:bad_format", + "//common/exceptions:divide_by_zero", + "//common/exceptions:numeric_overflow", + "//common/exceptions:runtime_exception", + "//common/internal:cel_descriptor_pools", + "//common/internal:converter", + "//common/internal:default_message_factory", + "//common/internal:dynamic_proto", + "//common/internal:proto_message_factory", + "//common/internal:proto_time_utils", + "//common/internal:well_known_proto", + "//common/types", + "//common/types:cel_v1alpha1_types", + "//common/types:message_type_provider", + "//common/values", + "//common/values:cel_byte_string", + "//common/values:cel_value_provider", + "//common/values:proto_message_lite_value_provider", + "//compiler", + "//compiler:compiler_builder", + "//extensions", + "//extensions:optional_library", + "//parser:macro", + "//parser:unparser", + "//runtime", + "//runtime:activation", + "//runtime:dispatcher", + "//runtime:evaluation_exception_builder", + "//runtime:evaluation_listener", + "//runtime:function_binding", + "//runtime:interpretable", + "//runtime:interpreter", + "//runtime:interpreter_util", + "//runtime:late_function_binding", + "//runtime:lite_runtime", + "//runtime:lite_runtime_factory", + "//runtime:partial_vars", + "//runtime:proto_message_activation_factory", + "//runtime:proto_message_runtime_equality", + "//runtime:proto_message_runtime_helpers", + "//runtime:resolved_overload", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime:standard_functions", + "//runtime:type_resolver", + "//runtime:unknown_attributes", + "//runtime:unknown_options", + "//runtime/standard:add", + "//runtime/standard:not_strictly_false", + "//runtime/standard:standard_overload", + "//runtime/standard:subtract", + "//testing:cel_runtime_flavor", + "//testing/protos:message_with_enum_cel_java_proto", + "//testing/protos:message_with_enum_java_proto", + "//testing/protos:multi_file_cel_java_proto", + "//testing/protos:multi_file_java_proto", + "//testing/protos:single_file_java_proto", + "//testing/protos:test_all_types_cel_java_proto2", + "//testing/protos:test_all_types_cel_java_proto3", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@com_google_googleapis//google/api/expr/v1alpha1:expr_java_proto", + "@com_google_googleapis//google/rpc/context:attribute_context_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_protobuf_protobuf_java_util", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:com_google_truth_extensions_truth_proto_extension", + "@maven//:junit_junit", + "@maven//:org_jspecify_jspecify", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "interpreter_test", + testonly = 1, + srcs = [ + "InterpreterTest.java", + ], + deps = [ + # "//java/com/google/testing/testsize:annotations", + "//testing:base_interpreter_test", + "@maven//:junit_junit", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + ], +) + +java_library( + name = "planner_interpreter_test", + testonly = 1, + srcs = [ + "PlannerInterpreterTest.java", + ], + resources = [ + "//runtime/testdata", + ], + deps = [ + "//common:cel_ast", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common/types", + "//common/types:type_providers", + "//extensions", + "//runtime", + "//runtime:function_binding", + "//runtime:unknown_attributes", + "//testing:base_interpreter_test", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +cel_android_local_test( + name = "android_tests", + srcs = ANDROID_TESTS, + test_class = "dev.cel.runtime.CelLiteRuntimeAndroidTest", + deps = [ + "//:java_truth", + "//common:cel_ast_android", + "//common:options", + "//common/internal:proto_time_utils_android", + "//common/values:cel_byte_string", + "//common/values:cel_value_provider_android", + "//common/values:proto_message_lite_value_provider_android", + "//extensions:lite_extensions_android", + "//extensions:sets_function", + "//runtime:evaluation_exception", + "//runtime:function_binding_android", + "//runtime:late_function_binding_android", + "//runtime:lite_runtime_android", + "//runtime:lite_runtime_factory_android", + "//runtime:lite_runtime_impl_android", + "//runtime:standard_functions_android", + "//runtime:unknown_attributes_android", + "//runtime/src/main/java/dev/cel/runtime:program_android", + "//runtime/standard:equals_android", + "//runtime/standard:int_android", + "//testing/protos:test_all_types_cel_java_proto2_lite", + "//testing/protos:test_all_types_cel_java_proto3_lite", + "//testing/src/main/java/dev/cel/testing/compiled:compiled_expr_utils_android", + "@cel_spec//proto/cel/expr:checked_java_proto_lite", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto_lite", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto_lite", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "cel_lite_interpreter_test", + testonly = 1, + srcs = [ + "CelLiteInterpreterTest.java", + ], + deps = [ + "//common:options", + "//common/values:proto_message_lite_value_provider", + "//extensions:optional_library", + "//runtime", + "//testing:base_interpreter_test", + "//testing/protos:test_all_types_cel_java_proto2", + "//testing/protos:test_all_types_cel_java_proto3", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + shard_count = 4, + sizes = [ + "small", + "medium", + ], + src_dir = "src/test/java", + deps = [ + ":cel_lite_interpreter_test", + ":interpreter_test", + ":planner_interpreter_test", + ":tests", + ], +) diff --git a/runtime/src/test/java/dev/cel/runtime/CelAttributeParserTest.java b/runtime/src/test/java/dev/cel/runtime/CelAttributeParserTest.java new file mode 100644 index 000000000..e2d463555 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelAttributeParserTest.java @@ -0,0 +1,131 @@ +// Copyright 2023 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 static com.google.common.truth.Truth.assertThat; + +import dev.cel.runtime.CelAttribute.Qualifier; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelAttributeParserTest { + + @Test + public void parse_parses() { + assertThat(CelAttributeParser.parse("com.google.Attr")) + .isEqualTo( + CelAttribute.create("com") + .qualify(Qualifier.ofString("google")) + .qualify(Qualifier.ofString("Attr"))); + } + + @Test + public void parse_parseIndexes() { + assertThat(CelAttributeParser.parse("com.google.Attr[1]")) + .isEqualTo( + CelAttribute.create("com") + .qualify(Qualifier.ofString("google")) + .qualify(Qualifier.ofString("Attr")) + .qualify(Qualifier.ofInt(1))); + assertThat(CelAttributeParser.parse("com.google.Attr[1u]")) + .isEqualTo( + CelAttribute.create("com") + .qualify(Qualifier.ofString("google")) + .qualify(Qualifier.ofString("Attr")) + .qualify(Qualifier.ofUint(1))); + assertThat(CelAttributeParser.parse("com.google.Attr[false]")) + .isEqualTo( + CelAttribute.create("com") + .qualify(Qualifier.ofString("google")) + .qualify(Qualifier.ofString("Attr")) + .qualify(Qualifier.ofBool(false))); + assertThat(CelAttributeParser.parse("com.google.Attr['1']")) + .isEqualTo( + CelAttribute.create("com") + .qualify(Qualifier.ofString("google")) + .qualify(Qualifier.ofString("Attr")) + .qualify(Qualifier.ofString("1"))); + } + + @Test + public void parse_parsesWildCard() { + assertThat(CelAttributeParser.parsePattern("com.google.Attr.*")) + .isEqualTo( + CelAttributePattern.create("com") + .qualify(Qualifier.ofString("google")) + .qualify(Qualifier.ofString("Attr")) + .qualify(Qualifier.ofWildCard())); + } + + @Test + public void parse_preservesEscapeCollisions() { + // Implementation detail: cel doesn't accept '*' as a legal field so parser escapes to + // _wildcard. check that the escaping scheme doesn't lose information. + assertThat(CelAttributeParser.parse("attr._wildcard")) + .isEqualTo(CelAttribute.create("attr").qualify(Qualifier.ofString("_wildcard"))); + + assertThat(CelAttributeParser.parse("attr._wildcar")) + .isEqualTo(CelAttribute.create("attr").qualify(Qualifier.ofString("_wildcar"))); + + assertThat(CelAttributeParser.parse("attr.__f")) + .isEqualTo(CelAttribute.create("attr").qualify(Qualifier.ofString("__f"))); + + assertThat(CelAttributeParser.parse("attr['*']")) + .isEqualTo(CelAttribute.create("attr").qualify(Qualifier.ofString("*"))); + + assertThat(CelAttributeParser.parse("attr['_wildcard']")) + .isEqualTo(CelAttribute.create("attr").qualify(Qualifier.ofString("_wildcard"))); + + assertThat(CelAttributeParser.parse("attr['__f']")) + .isEqualTo(CelAttribute.create("attr").qualify(Qualifier.ofString("__f"))); + } + + @Test + public void parse_unsupportedExprKindThrows() { + IllegalArgumentException iae = + Assert.assertThrows( + IllegalArgumentException.class, () -> CelAttributeParser.parse("1 / 2")); + + assertThat(iae).hasMessageThat().contains("_/_(CONSTANT, CONSTANT)"); + + iae = + Assert.assertThrows( + IllegalArgumentException.class, () -> CelAttributeParser.parse("123.field")); + + assertThat(iae).hasMessageThat().contains("CelConstant"); + + iae = + Assert.assertThrows( + IllegalArgumentException.class, () -> CelAttributeParser.parse("a && b")); + + assertThat(iae).hasMessageThat().contains("_&&_(IDENT, IDENT)"); + } + + @Test + public void parse_unsupportedConstThrows() { + Assert.assertThrows( + IllegalArgumentException.class, () -> CelAttributeParser.parse("attr[null]")); + Assert.assertThrows( + IllegalArgumentException.class, () -> CelAttributeParser.parse("attr[1.0]")); + } + + @Test + public void parse_badSyntaxThrows() { + Assert.assertThrows(IllegalArgumentException.class, () -> CelAttributeParser.parse("}attr,")); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelAttributePatternTest.java b/runtime/src/test/java/dev/cel/runtime/CelAttributePatternTest.java new file mode 100644 index 000000000..de265cc77 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelAttributePatternTest.java @@ -0,0 +1,297 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import dev.cel.runtime.CelAttribute.Qualifier; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelAttributePatternTest { + @Test + public void equality_unequal() { + assertThat(CelAttributePattern.create("identifier")) + .isNotEqualTo(CelAttributePattern.create("other_identifier")); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofString("field1"))) + .isNotEqualTo(CelAttributePattern.create("identifier")); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofString("field1"))) + .isNotEqualTo( + CelAttributePattern.create("identifier").qualify(Qualifier.ofString("field2"))); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofString("field1"))) + .isNotEqualTo(CelAttributePattern.create("identifier").qualify(Qualifier.ofInt(1))); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofUint(1))) + .isNotEqualTo(CelAttributePattern.create("identifier").qualify(Qualifier.ofInt(1))); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofBool(true))) + .isNotEqualTo(CelAttributePattern.create("identifier").qualify(Qualifier.ofInt(1))); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofWildCard())) + .isNotEqualTo(CelAttributePattern.create("identifier").qualify(Qualifier.ofInt(1))); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofInt(1)) + .qualify(Qualifier.ofString("field1"))) + .isNotEqualTo( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofInt(2)) + .qualify(Qualifier.ofString("field1"))); + } + + @Test + public void equality_equal() { + assertThat(CelAttributePattern.create("identifier")) + .isEqualTo(CelAttributePattern.create("identifier")); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofInt(1))) + .isEqualTo(CelAttributePattern.create("identifier").qualify(Qualifier.ofInt(1))); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofUint(1))) + .isEqualTo(CelAttributePattern.create("identifier").qualify(Qualifier.ofUint(1))); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofString("1"))) + .isEqualTo(CelAttributePattern.create("identifier").qualify(Qualifier.ofString("1"))); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofBool(true))) + .isEqualTo(CelAttributePattern.create("identifier").qualify(Qualifier.ofBool(true))); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofWildCard())) + .isEqualTo(CelAttributePattern.create("identifier").qualify(Qualifier.ofWildCard())); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofBool(true)) + .qualify(Qualifier.ofString("field1"))) + .isEqualTo( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofBool(true)) + .qualify(Qualifier.ofString("field1"))); + } + + @Test + public void toString_values() { + assertThat(CelAttributePattern.create("identifier").toString()).isEqualTo("identifier"); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofInt(1)).toString()) + .isEqualTo("identifier[1]"); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofUint(1)).toString()) + .isEqualTo("identifier[1u]"); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofString("1")).toString()) + .isEqualTo("identifier['1']"); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofBool(true)).toString()) + .isEqualTo("identifier[true]"); + + assertThat(CelAttributePattern.create("identifier").qualify(Qualifier.ofWildCard()).toString()) + .isEqualTo("identifier.*"); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofBool(true)) + .qualify(Qualifier.ofString("field1")) + .toString()) + .isEqualTo("identifier[true].field1"); + } + + @Test + public void isMatch_matches() { + assertThat(CelAttributePattern.create("identifier").isMatch(CelAttribute.create("identifier"))) + .isTrue(); + + assertThat( + CelAttributePattern.create("identifier") + .isMatch(CelAttribute.create("identifier").qualify(Qualifier.ofString("field1")))) + .isTrue(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .isMatch(CelAttribute.create("identifier").qualify(Qualifier.ofString("field1")))) + .isTrue(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .isMatch(CelAttribute.create("identifier").qualify(Qualifier.ofString("field1")))) + .isTrue(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .isMatch( + CelAttribute.create("identifier") + .qualify(Qualifier.ofInt(1)) + .qualify(Qualifier.ofString("field1")))) + .isTrue(); + } + + @Test + public void isMatch_doesNotMatch() { + assertThat(CelAttributePattern.create("identifier").isMatch(CelAttribute.create("identifier2"))) + .isFalse(); + + assertThat( + CelAttributePattern.create("identifier") + .isMatch(CelAttribute.create("identifier2").qualify(Qualifier.ofString("field1")))) + .isFalse(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofString("field1")) + .isMatch(CelAttribute.create("identifier").qualify(Qualifier.ofString("field2")))) + .isFalse(); + + // Partial match + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .qualify(Qualifier.ofString("field1")) + .isMatch(CelAttribute.create("identifier").qualify(Qualifier.ofInt(1)))) + .isFalse(); + } + + @Test + public void isPartialMatch_matches() { + assertThat( + CelAttributePattern.create("identifier") + .isPartialMatch(CelAttribute.create("identifier"))) + .isTrue(); + + assertThat( + CelAttributePattern.create("identifier") + .isPartialMatch( + CelAttribute.create("identifier").qualify(Qualifier.ofString("field1")))) + .isTrue(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .isPartialMatch( + CelAttribute.create("identifier").qualify(Qualifier.ofString("field1")))) + .isTrue(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .isPartialMatch( + CelAttribute.create("identifier").qualify(Qualifier.ofString("field1")))) + .isTrue(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .isPartialMatch( + CelAttribute.create("identifier") + .qualify(Qualifier.ofInt(1)) + .qualify(Qualifier.ofString("field1")))) + .isTrue(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .qualify(Qualifier.ofString("field1")) + .isPartialMatch(CelAttribute.create("identifier").qualify(Qualifier.ofInt(1)))) + .isTrue(); + } + + @Test + public void isPartialMatch_doesNotMatch() { + assertThat( + CelAttributePattern.create("identifier") + .isPartialMatch(CelAttribute.create("identifier2"))) + .isFalse(); + + assertThat( + CelAttributePattern.create("identifier") + .isPartialMatch( + CelAttribute.create("identifier2").qualify(Qualifier.ofString("field1")))) + .isFalse(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofString("field1")) + .isPartialMatch( + CelAttribute.create("identifier").qualify(Qualifier.ofString("field2")))) + .isFalse(); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .isPartialMatch(CelAttribute.EMPTY)) + .isFalse(); + } + + @Test + public void simplify_simplifies() { + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .simplify(CelAttribute.create("identifier").qualify(Qualifier.ofInt(2)))) + .isEqualTo(CelAttribute.create("identifier").qualify(Qualifier.ofInt(2))); + + assertThat( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofWildCard()) + .simplify( + CelAttribute.create("identifier") + .qualify(Qualifier.ofInt(2)) + .qualify(Qualifier.ofString("12345")))) + .isEqualTo(CelAttribute.create("identifier").qualify(Qualifier.ofInt(2))); + } + + @Test + public void fromQualifiedIdentifier_parseIdents() { + assertThat(CelAttributePattern.fromQualifiedIdentifier("identifier.field1.field2")) + .isEqualTo( + CelAttributePattern.create("identifier") + .qualify(Qualifier.ofString("field1")) + .qualify(Qualifier.ofString("field2"))); + } + + @Test + public void create_fromList() { + assertThat( + CelAttributePattern.create( + ImmutableList.of(Qualifier.ofString("ident"), Qualifier.ofString("field")))) + .isEqualTo(CelAttributePattern.create("ident").qualify(Qualifier.ofString("field"))); + } + + @Test + public void create_invalidListThrows() { + assertThrows( + IllegalArgumentException.class, + () -> + CelAttribute.create( + // EMPTY has special meaning so cannot be created. + ImmutableList.of())); + + assertThrows( + IllegalArgumentException.class, + () -> + CelAttributePattern.create( + ImmutableList.of(Qualifier.ofString("not-a-root"), Qualifier.ofInt(1)))); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelAttributeTest.java b/runtime/src/test/java/dev/cel/runtime/CelAttributeTest.java new file mode 100644 index 000000000..fc6cb3442 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelAttributeTest.java @@ -0,0 +1,189 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.UnsignedLong; +import dev.cel.runtime.CelAttribute.Qualifier; +import java.util.ArrayList; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelAttributeTest { + @Test + public void unequal() { + assertThat(CelAttribute.create("identifier")) + .isNotEqualTo(CelAttribute.create("other_identifier")); + + assertThat(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofString("field1"))) + .isNotEqualTo(CelAttribute.create("identifier")); + + assertThat(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofString("field1"))) + .isNotEqualTo( + CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofString("field2"))); + + assertThat(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofString("field1"))) + .isNotEqualTo(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofInt(1))); + + assertThat(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofUint(1))) + .isNotEqualTo(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofInt(1))); + + assertThat(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofBool(true))) + .isNotEqualTo(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofInt(1))); + + assertThat( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofInt(1)) + .qualify(CelAttribute.Qualifier.ofString("field1"))) + .isNotEqualTo( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofInt(2)) + .qualify(CelAttribute.Qualifier.ofString("field1"))); + } + + @Test + public void equality_equal() { + assertThat(CelAttribute.create("identifier")).isEqualTo(CelAttribute.create("identifier")); + + assertThat(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofInt(1))) + .isEqualTo(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofInt(1))); + + assertThat(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofUint(1))) + .isEqualTo(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofUint(1))); + + assertThat(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofString("1"))) + .isEqualTo(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofString("1"))); + + assertThat(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofBool(true))) + .isEqualTo(CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofBool(true))); + + assertThat( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofBool(true)) + .qualify(CelAttribute.Qualifier.ofString("field1"))) + .isEqualTo( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofBool(true)) + .qualify(CelAttribute.Qualifier.ofString("field1"))); + } + + @Test + public void create_wildcardUnsupported() { + assertThrows( + IllegalArgumentException.class, + () -> + CelAttribute.create( + ImmutableList.of(Qualifier.ofString("identifier"), Qualifier.ofWildCard()))); + } + + @Test + public void qualify_wildcardUnsupported() { + assertThrows( + IllegalArgumentException.class, + () -> CelAttribute.create("identifier").qualify(Qualifier.ofWildCard())); + } + + @Test + public void toString_values() { + assertThat(CelAttribute.create("identifier").toString()).isEqualTo("identifier"); + + assertThat( + CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofInt(1)).toString()) + .isEqualTo("identifier[1]"); + + assertThat( + CelAttribute.create("identifier").qualify(CelAttribute.Qualifier.ofUint(1)).toString()) + .isEqualTo("identifier[1u]"); + + assertThat( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofString("1")) + .toString()) + .isEqualTo("identifier['1']"); + + assertThat( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofBool(true)) + .toString()) + .isEqualTo("identifier[true]"); + + assertThat( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofBool(true)) + .qualify(CelAttribute.Qualifier.ofString("field1")) + .toString()) + .isEqualTo("identifier[true].field1"); + } + + @Test + public void fromQualifiedIdentifier_parseIdents() { + assertThat(CelAttribute.fromQualifiedIdentifier("identifier.field1.field2")) + .isEqualTo( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofString("field1")) + .qualify(CelAttribute.Qualifier.ofString("field2"))); + } + + @Test + public void fromGeneric_supportedTypes() { + assertThat(Qualifier.fromGeneric(Long.valueOf(1))).isEqualTo(Qualifier.ofInt(1)); + assertThat(Qualifier.fromGeneric(UnsignedLong.valueOf(1))).isEqualTo(Qualifier.ofUint(1)); + assertThat(Qualifier.fromGeneric("abcd")).isEqualTo(Qualifier.ofString("abcd")); + assertThat(Qualifier.fromGeneric(Boolean.valueOf(false))).isEqualTo(Qualifier.ofBool(false)); + } + + @Test + public void fromGeneric_unsupportedTypeThrows() { + assertThrows( + IllegalArgumentException.class, () -> Qualifier.fromGeneric(new ArrayList())); + } + + @Test + public void create_fromList() { + assertThat( + CelAttribute.create( + ImmutableList.of(Qualifier.ofString("ident"), Qualifier.ofString("field")))) + .isEqualTo(CelAttribute.create("ident").qualify(Qualifier.ofString("field"))); + } + + @Test + public void create_invalidListThrows() { + assertThrows( + IllegalArgumentException.class, + () -> + CelAttribute.create( + // EMPTY instance has special meaning so cannot be created. + ImmutableList.of())); + + assertThrows( + IllegalArgumentException.class, + () -> + CelAttribute.create( + ImmutableList.of(Qualifier.ofString("not-a-root"), Qualifier.ofInt(1)))); + assertThrows( + IllegalArgumentException.class, + () -> + CelAttribute.create( + ImmutableList.of( + Qualifier.ofString("root"), + // Wildcard unsupported in specific concrete attributes. + Qualifier.ofWildCard()))); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelEvaluationExceptionBuilderTest.java b/runtime/src/test/java/dev/cel/runtime/CelEvaluationExceptionBuilderTest.java new file mode 100644 index 000000000..c073a8443 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelEvaluationExceptionBuilderTest.java @@ -0,0 +1,101 @@ +// Copyright 2025 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 static com.google.common.truth.Truth.assertThat; + +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelErrorCode; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.common.exceptions.CelRuntimeException; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelEvaluationExceptionBuilderTest { + + @Test + public void builder_default() { + CelEvaluationExceptionBuilder builder = CelEvaluationExceptionBuilder.newBuilder("foo"); + + CelEvaluationException e = builder.build(); + + assertThat(e).hasMessageThat().isEqualTo("evaluation error: foo"); + assertThat(e).hasCauseThat().isNull(); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.INTERNAL_ERROR); + } + + @Test + public void builder_withoutMetadata() { + IllegalStateException cause = new IllegalStateException("Cause"); + CelEvaluationExceptionBuilder builder = + CelEvaluationExceptionBuilder.newBuilder("foo") + .setCause(cause) + .setErrorCode(CelErrorCode.ATTRIBUTE_NOT_FOUND); + + CelEvaluationException e = builder.build(); + + assertThat(e).hasMessageThat().isEqualTo("evaluation error: foo"); + assertThat(e).hasCauseThat().isEqualTo(cause); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.ATTRIBUTE_NOT_FOUND); + } + + @Test + public void builder_allPropertiesSet() { + IllegalStateException cause = new IllegalStateException("Cause"); + CelEvaluationExceptionBuilder builder = + CelEvaluationExceptionBuilder.newBuilder("foo") + .setCause(cause) + .setErrorCode(CelErrorCode.BAD_FORMAT) + .setMetadata( + new Metadata() { + @Override + public String getLocation() { + return "location.txt"; + } + + @Override + public int getPosition(long exprId) { + return 10; + } + + @Override + public boolean hasPosition(long exprId) { + return true; + } + }, + 0); + + CelEvaluationException e = builder.build(); + + assertThat(e).hasMessageThat().isEqualTo("evaluation error at location.txt:10: foo"); + assertThat(e).hasCauseThat().isEqualTo(cause); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.BAD_FORMAT); + } + + @Test + public void builder_fromCelRuntimeException() { + IllegalStateException cause = new IllegalStateException("cause error message"); + CelRuntimeException celRuntimeException = new CelBadFormatException(cause); + CelEvaluationExceptionBuilder builder = + CelEvaluationExceptionBuilder.newBuilder(celRuntimeException); + + CelEvaluationException e = builder.build(); + + assertThat(e).hasMessageThat().isEqualTo("evaluation error: cause error message"); + assertThat(e).hasCauseThat().isEqualTo(celRuntimeException); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.BAD_FORMAT); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelLateFunctionBindingsTest.java b/runtime/src/test/java/dev/cel/runtime/CelLateFunctionBindingsTest.java new file mode 100644 index 000000000..819b99665 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelLateFunctionBindingsTest.java @@ -0,0 +1,142 @@ +// Copyright 2024 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 static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.UnsignedLong; +import dev.cel.common.CelErrorCode; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import java.util.Optional; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** Tests for {@link CelLateFunctionBindings}. */ +@RunWith(JUnit4.class) +public final class CelLateFunctionBindingsTest { + + @Test + public void findOverload_singleMatchingFunction_isPresent() throws Exception { + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from("increment_int", Long.class, (arg) -> arg + 1), + CelFunctionBinding.from( + "increment_uint", UnsignedLong.class, (arg) -> arg.plus(UnsignedLong.ONE))); + Optional overload = + bindings.findOverloadMatchingArgs( + "increment", ImmutableList.of("increment_int", "increment_uint"), new Object[] {1L}); + assertThat(overload).isPresent(); + assertThat(overload.get().getOverloadId()).isEqualTo("increment_int"); + assertThat(overload.get().getParameterTypes()).containsExactly(Long.class); + assertThat(overload.get().getDefinition().apply(new Object[] {1L})).isEqualTo(2L); + } + + @Test + public void findOverload_noMatchingFunctionSameArgCount_isEmpty() throws Exception { + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from("increment_int", Long.class, (arg) -> arg + 1), + CelFunctionBinding.from( + "increment_uint", UnsignedLong.class, (arg) -> arg.plus(UnsignedLong.ONE))); + Optional overload = + bindings.findOverloadMatchingArgs( + "increment", ImmutableList.of("increment_int", "increment_uint"), new Object[] {1.0}); + assertThat(overload).isEmpty(); + } + + @Test + public void findOverload_noMatchingFunctionDifferentArgCount_isEmpty() throws Exception { + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from("increment_int", Long.class, (arg) -> arg + 1), + CelFunctionBinding.from( + "increment_uint", UnsignedLong.class, (arg) -> arg.plus(UnsignedLong.ONE))); + Optional overload = + bindings.findOverloadMatchingArgs( + "increment", + ImmutableList.of("increment_int", "increment_uint"), + new Object[] {1.0, 1.0}); + assertThat(overload).isEmpty(); + } + + @Test + public void findOverload_badInput_throwsException() throws Exception { + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from( + "increment_uint", + UnsignedLong.class, + (arg) -> { + if (arg.equals(UnsignedLong.MAX_VALUE)) { + throw new CelEvaluationException( + "numeric overflow", null, CelErrorCode.NUMERIC_OVERFLOW); + } + return arg.plus(UnsignedLong.ONE); + })); + Optional overload = + bindings.findOverloadMatchingArgs( + "increment", ImmutableList.of("increment_uint"), new Object[] {UnsignedLong.MAX_VALUE}); + assertThat(overload).isPresent(); + assertThat(overload.get().getOverloadId()).isEqualTo("increment_uint"); + assertThat(overload.get().getParameterTypes()).containsExactly(UnsignedLong.class); + CelEvaluationException e = + Assert.assertThrows( + CelEvaluationException.class, + () -> overload.get().getDefinition().apply(new Object[] {UnsignedLong.MAX_VALUE})); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.NUMERIC_OVERFLOW); + } + + @Test + public void findOverload_multipleMatchingFunctions_throwsException() throws Exception { + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from("increment_int", Long.class, (arg) -> arg + 1), + CelFunctionBinding.from("increment_uint", Long.class, (arg) -> arg + 2)); + CelEvaluationException e = + Assert.assertThrows( + CelEvaluationException.class, + () -> + bindings.findOverloadMatchingArgs( + "increment", + ImmutableList.of("increment_int", "increment_uint"), + new Object[] {1L})); + assertThat(e).hasMessageThat().contains("Ambiguous overloads for function 'increment'"); + } + + @Test + public void findOverload_nullPrimitiveArg_isEmpty() throws Exception { + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from("identity_int", Long.class, (arg) -> arg)); + Optional overload = + bindings.findOverloadMatchingArgs( + "identity", ImmutableList.of("identity_int"), new Object[] {null}); + assertThat(overload).isEmpty(); + } + + @Test + public void findOverload_nullMessageArg_isEmpty() throws Exception { + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from("identity_msg", TestAllTypes.class, (arg) -> arg)); + Optional overload = + bindings.findOverloadMatchingArgs( + "identity", ImmutableList.of("identity_msg"), new Object[] {null}); + assertThat(overload).isEmpty(); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelLiteInterpreterTest.java b/runtime/src/test/java/dev/cel/runtime/CelLiteInterpreterTest.java new file mode 100644 index 000000000..1d1a316c0 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelLiteInterpreterTest.java @@ -0,0 +1,112 @@ +// Copyright 2025 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.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelOptions; +import dev.cel.common.values.ProtoMessageLiteValueProvider; +import dev.cel.expr.conformance.proto3.TestAllTypesCelDescriptor; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.testing.BaseInterpreterTest; +import org.junit.runner.RunWith; + +/** + * Exercises a suite of interpreter tests defined in {@link BaseInterpreterTest} using {@link + * ProtoMessageLiteValueProvider} and full version of protobuf messages. + */ +@RunWith(TestParameterInjector.class) +public class CelLiteInterpreterTest extends BaseInterpreterTest { + + @Override + protected CelRuntimeBuilder newBaseRuntimeBuilder(CelOptions celOptions) { + return CelRuntimeFactory.standardCelRuntimeBuilder() + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + dev.cel.expr.conformance.proto2.TestAllTypesCelDescriptor.getDescriptor(), + TestAllTypesCelDescriptor.getDescriptor())) + .addLibraries(CelOptionalLibrary.INSTANCE) + .setOptions(celOptions.toBuilder().enableCelValue(true).build()); + } + + @Override + public void dynamicMessage_adapted() throws Exception { + // Dynamic message is not supported in Protolite + skipBaselineVerification(); + } + + @Override + public void dynamicMessage_dynamicDescriptor() throws Exception { + // Dynamic message is not supported in Protolite + skipBaselineVerification(); + } + + // All the tests below rely on message creation with fields populated. They are excluded for time + // being until this support is added. + @Override + public void nullAssignability() throws Exception { + skipBaselineVerification(); + } + + @Override + public void wrappers() throws Exception { + skipBaselineVerification(); + } + + @Override + public void jsonConversions() { + skipBaselineVerification(); + } + + @Override + public void nestedEnums() { + skipBaselineVerification(); + } + + @Override + public void messages() throws Exception { + skipBaselineVerification(); + } + + @Override + public void packUnpackAny() { + skipBaselineVerification(); + } + + @Override + public void lists() throws Exception { + skipBaselineVerification(); + } + + @Override + public void maps() throws Exception { + skipBaselineVerification(); + } + + @Override + public void jsonValueTypes() { + skipBaselineVerification(); + } + + @Override + public void messages_error() { + skipBaselineVerification(); + } + + @Override + public void jsonFieldNames() { + // json_name field option is not yet supported in lite runtime + skipBaselineVerification(); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeAndroidTest.java b/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeAndroidTest.java new file mode 100644 index 000000000..73492d126 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeAndroidTest.java @@ -0,0 +1,731 @@ +// Copyright 2025 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 static com.google.common.truth.Truth.assertThat; +import static dev.cel.testing.compiled.CompiledExprUtils.readCheckedExpr; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.common.truth.Correspondence; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.StringValue; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.CelValueProvider; +import dev.cel.common.values.ProtoMessageLiteValueProvider; +import dev.cel.expr.conformance.proto3.NestedTestAllTypes; +import dev.cel.expr.conformance.proto3.NestedTestAllTypesCelLiteDescriptor; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypesCelLiteDescriptor; +import dev.cel.extensions.CelLiteExtensions; +import dev.cel.extensions.SetsFunction; +import dev.cel.runtime.standard.EqualsOperator; +import dev.cel.runtime.standard.IntFunction; +import dev.cel.runtime.standard.IntFunction.IntOverload; +import java.time.Duration; +import java.time.Instant; +import java.util.List; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelLiteRuntimeAndroidTest { + private static final double DOUBLE_TOLERANCE = 0.00001d; + private static final Correspondence, List> LIST_WITH_DOUBLE_TOLERANCE = + Correspondence.from( + (actualList, expectedList) -> { + if (actualList == null + || expectedList == null + || actualList.size() != expectedList.size()) { + return false; + } + for (int i = 0; i < actualList.size(); i++) { + Object actual = actualList.get(i); + Object expected = expectedList.get(i); + + if (actual instanceof Double && expected instanceof Double) { + return Math.abs((Double) actual - (Double) expected) <= DOUBLE_TOLERANCE; + } else if (!actual.equals(expected)) { + return false; + } + } + return true; + }, + String.format( + "has elements that are equal (with tolerance of %f for doubles)", DOUBLE_TOLERANCE)); + + private static final Correspondence, Map> MAP_WITH_DOUBLE_TOLERANCE = + Correspondence.from( + (actualMap, expectedMap) -> { + if (actualMap == null + || expectedMap == null + || actualMap.size() != expectedMap.size()) { + return false; + } + + for (Map.Entry actualEntry : actualMap.entrySet()) { + if (!expectedMap.containsKey(actualEntry.getKey())) { + return false; + } + + Object actualEntryValue = actualEntry.getValue(); + Object expectedEntryValue = expectedMap.get(actualEntry.getKey()); + if (actualEntryValue instanceof Double && expectedEntryValue instanceof Double) { + return Math.abs((Double) actualEntryValue - (Double) expectedEntryValue) + <= DOUBLE_TOLERANCE; + } else if (!actualEntryValue.equals(expectedEntryValue)) { + return false; + } + } + + return true; + }, + String.format( + "has elements that are equal (with tolerance of %f for doubles)", DOUBLE_TOLERANCE)); + + @Test + public void toRuntimeBuilder_isNewInstance() { + CelLiteRuntimeBuilder runtimeBuilder = CelLiteRuntimeFactory.newLiteRuntimeBuilder(); + CelLiteRuntime runtime = runtimeBuilder.build(); + + CelLiteRuntimeBuilder newRuntimeBuilder = runtime.toRuntimeBuilder(); + + assertThat(newRuntimeBuilder).isNotEqualTo(runtimeBuilder); + } + + @Test + public void toRuntimeBuilder_propertiesCopied() { + CelOptions celOptions = CelOptions.current().enableCelValue(true).build(); + CelLiteRuntimeLibrary runtimeExtension = + CelLiteExtensions.sets(celOptions, SetsFunction.INTERSECTS); + CelValueProvider celValueProvider = ProtoMessageLiteValueProvider.newInstance(); + IntFunction intFunction = IntFunction.create(IntOverload.INT64_TO_INT64); + EqualsOperator equalsOperator = EqualsOperator.create(); + CelLiteRuntimeBuilder runtimeBuilder = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setOptions(celOptions) + .setStandardFunctions(intFunction, equalsOperator) + .addFunctionBindings( + CelFunctionBinding.from("string_isEmpty", String.class, String::isEmpty)) + .setValueProvider(celValueProvider) + .addLibraries(runtimeExtension); + CelLiteRuntime runtime = runtimeBuilder.build(); + + LiteRuntimeImpl.Builder newRuntimeBuilder = + (LiteRuntimeImpl.Builder) runtime.toRuntimeBuilder(); + + assertThat(newRuntimeBuilder.celOptions).isEqualTo(celOptions); + assertThat(newRuntimeBuilder.celValueProvider).isSameInstanceAs(celValueProvider); + assertThat(newRuntimeBuilder.runtimeLibrariesBuilder.build()).containsExactly(runtimeExtension); + assertThat(newRuntimeBuilder.standardFunctionBuilder.build()) + .containsExactly(intFunction, equalsOperator) + .inOrder(); + assertThat(newRuntimeBuilder.customFunctionBindings).hasSize(3); + assertThat(newRuntimeBuilder.customFunctionBindings).containsKey("string_isEmpty"); + assertThat(newRuntimeBuilder.customFunctionBindings).containsKey("list_sets_intersects_list"); + assertThat(newRuntimeBuilder.customFunctionBindings).containsKey("sets.intersects"); + } + + @Test + public void setCelOptions_unallowedOptionsSet_throws(@TestParameter CelOptionsTestCase testCase) { + assertThrows( + IllegalArgumentException.class, + () -> + CelLiteRuntimeFactory.newLiteRuntimeBuilder().setOptions(testCase.celOptions).build()); + } + + @Test + public void standardEnvironment_disabledByDefault() throws Exception { + CelLiteRuntime runtime = CelLiteRuntimeFactory.newLiteRuntimeBuilder().build(); + // Expr: 1 + 2 + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_one_plus_two"); + + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> runtime.createProgram(ast).eval()); + assertThat(e) + .hasMessageThat() + .contains( + "evaluation error at :2: No matching overload for function '_+_'. Overload" + + " candidates: add_int64"); + } + + @Test + public void eval_add() throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .build(); + // Expr: 1 + 2 + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_one_plus_two"); + + assertThat(runtime.createProgram(ast).eval()).isEqualTo(3L); + } + + @Test + public void eval_stringLiteral() throws Exception { + CelLiteRuntime runtime = CelLiteRuntimeFactory.newLiteRuntimeBuilder().build(); + // Expr: 'hello world' + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_hello_world"); + Program program = runtime.createProgram(ast); + + String result = (String) program.eval(); + + assertThat(result).isEqualTo("hello world"); + } + + @Test + @SuppressWarnings("unchecked") + public void eval_listLiteral() throws Exception { + CelLiteRuntime runtime = CelLiteRuntimeFactory.newLiteRuntimeBuilder().build(); + // Expr: ['a', 1, 2u, 3.5] + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_list_literal"); + Program program = runtime.createProgram(ast); + + List result = (List) program.eval(); + + assertThat(result).containsExactly("a", 1L, UnsignedLong.valueOf(2L), 3.5d).inOrder(); + } + + @Test + public void eval_comprehensionExists() throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .build(); + // Expr: [1,2,3].exists(x, x == 3) + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_comprehension_exists"); + Program program = runtime.createProgram(ast); + + boolean result = (boolean) program.eval(); + + assertThat(result).isTrue(); + } + + @Test + public void eval_primitiveVariables() throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .build(); + // Expr: bool_var && bytes_var == b'abc' && double_var == 1.0 && int_var == 42 && uint_var == + // 42u && str_var == 'foo' + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_primitive_variables"); + Program program = runtime.createProgram(ast); + + boolean result = + (boolean) + program.eval( + ImmutableMap.of( + "bool_var", + true, + "bytes_var", + CelByteString.copyFromUtf8("abc"), + "double_var", + 1.0, + "int_var", + 42L, + "uint_var", + UnsignedLong.valueOf(42L), + "str_var", + "foo")); + + assertThat(result).isTrue(); + } + + @Test + @SuppressWarnings("rawtypes") + public void eval_customFunctions() throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .addFunctionBindings( + CelFunctionBinding.from("string_isEmpty", String.class, String::isEmpty), + CelFunctionBinding.from("list_isEmpty", List.class, List::isEmpty)) + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .build(); + // Expr: ''.isEmpty() && [].isEmpty() + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_custom_functions"); + Program program = runtime.createProgram(ast); + + boolean result = (boolean) program.eval(); + + assertThat(result).isTrue(); + } + + @Test + @SuppressWarnings("rawtypes") + public void eval_customFunctions_asLateBoundFunctions() throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .addFunctionBindings(CelFunctionBinding.from("list_isEmpty", List.class, List::isEmpty)) + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .build(); + // Expr: ''.isEmpty() && [].isEmpty() + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_custom_functions"); + Program program = runtime.createProgram(ast); + + boolean result = + (boolean) + program.eval( + ImmutableMap.of(), + CelLateFunctionBindings.from( + CelFunctionBinding.from("string_isEmpty", String.class, String::isEmpty), + CelFunctionBinding.from("list_isEmpty", List.class, List::isEmpty))); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{checkedExpr: 'compiled_proto2_select_primitives'}") + @TestParameters("{checkedExpr: 'compiled_proto3_select_primitives'}") + public void eval_protoMessage_unknowns(String checkedExpr) throws Exception { + CelLiteRuntime runtime = CelLiteRuntimeFactory.newLiteRuntimeBuilder().build(); + CelAbstractSyntaxTree ast = readCheckedExpr(checkedExpr); + Program program = runtime.createProgram(ast); + + CelUnknownSet result = (CelUnknownSet) program.eval(); + + assertThat(result.unknownExprIds()).hasSize(15); + } + + @Test + @TestParameters("{checkedExpr: 'compiled_proto2_select_primitives_all_ored'}") + @TestParameters("{checkedExpr: 'compiled_proto3_select_primitives_all_ored'}") + public void eval_protoMessage_primitiveWithDefaults(String checkedExpr) throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + dev.cel.expr.conformance.proto2.TestAllTypesCelLiteDescriptor.getDescriptor(), + dev.cel.expr.conformance.proto2.NestedTestAllTypesCelLiteDescriptor + .getDescriptor(), + TestAllTypesCelLiteDescriptor.getDescriptor(), + NestedTestAllTypesCelLiteDescriptor.getDescriptor())) + .build(); + // Ensures that all branches of the OR conditions are evaluated, and that appropriate defaults + // are returned for primitives. + CelAbstractSyntaxTree ast = readCheckedExpr(checkedExpr); + Program program = runtime.createProgram(ast); + + boolean result = + (boolean) + program.eval( + ImmutableMap.of( + "proto2", dev.cel.expr.conformance.proto2.TestAllTypes.getDefaultInstance(), + "proto3", TestAllTypes.getDefaultInstance())); + + assertThat(result).isFalse(); // False should be returned to avoid short circuiting. + } + + @Test + @TestParameters("{checkedExpr: 'compiled_proto2_select_primitives'}") + @TestParameters("{checkedExpr: 'compiled_proto3_select_primitives'}") + public void eval_protoMessage_primitives(String checkedExpr) throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + dev.cel.expr.conformance.proto2.TestAllTypesCelLiteDescriptor.getDescriptor(), + TestAllTypesCelLiteDescriptor.getDescriptor())) + .build(); + CelAbstractSyntaxTree ast = readCheckedExpr(checkedExpr); + Program program = runtime.createProgram(ast); + + boolean result = + (boolean) + program.eval( + ImmutableMap.of( + "proto2", + dev.cel.expr.conformance.proto2.TestAllTypes.newBuilder() + .setSingleInt32(1) + .setSingleInt64(2L) + .setSingleUint32(3) + .setSingleUint64(4L) + .setSingleSint32(5) + .setSingleSint64(6L) + .setSingleFixed32(7) + .setSingleFixed64(8L) + .setSingleSfixed32(9) + .setSingleSfixed64(10L) + .setSingleFloat(1.5f) + .setSingleDouble(2.5d) + .setSingleBool(true) + .setSingleString("hello world") + .setSingleBytes(ByteString.copyFromUtf8("abc")) + .build(), + "proto3", + TestAllTypes.newBuilder() + .setSingleInt32(1) + .setSingleInt64(2L) + .setSingleUint32(3) + .setSingleUint64(4L) + .setSingleSint32(5) + .setSingleSint64(6L) + .setSingleFixed32(7) + .setSingleFixed64(8L) + .setSingleSfixed32(9) + .setSingleSfixed64(10L) + .setSingleFloat(1.5f) + .setSingleDouble(2.5d) + .setSingleBool(true) + .setSingleString("hello world") + .setSingleBytes(ByteString.copyFromUtf8("abc")) + .build())); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{checkedExpr: 'compiled_proto2_select_wrappers'}") + @TestParameters("{checkedExpr: 'compiled_proto3_select_wrappers'}") + public void eval_protoMessage_wrappers(String checkedExpr) throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + dev.cel.expr.conformance.proto2.TestAllTypesCelLiteDescriptor.getDescriptor(), + TestAllTypesCelLiteDescriptor.getDescriptor())) + .build(); + CelAbstractSyntaxTree ast = readCheckedExpr(checkedExpr); + Program program = runtime.createProgram(ast); + + boolean result = + (boolean) + program.eval( + ImmutableMap.of( + "proto2", + dev.cel.expr.conformance.proto2.TestAllTypes.newBuilder() + .setSingleInt32Wrapper(Int32Value.of(1)) + .setSingleInt64Wrapper(Int64Value.of(2L)) + .setSingleUint32Wrapper(UInt32Value.of(3)) + .setSingleUint64Wrapper(UInt64Value.of(4L)) + .setSingleFloatWrapper(FloatValue.of(1.5f)) + .setSingleDoubleWrapper(DoubleValue.of(2.5d)) + .setSingleBoolWrapper(BoolValue.of(true)) + .setSingleStringWrapper(StringValue.of("hello world")) + .setSingleBytesWrapper(BytesValue.of(ByteString.copyFromUtf8("abc"))) + .build(), + "proto3", + TestAllTypes.newBuilder() + .setSingleInt32Wrapper(Int32Value.of(1)) + .setSingleInt64Wrapper(Int64Value.of(2L)) + .setSingleUint32Wrapper(UInt32Value.of(3)) + .setSingleUint64Wrapper(UInt64Value.of(4L)) + .setSingleFloatWrapper(FloatValue.of(1.5f)) + .setSingleDoubleWrapper(DoubleValue.of(2.5d)) + .setSingleBoolWrapper(BoolValue.of(true)) + .setSingleStringWrapper(StringValue.of("hello world")) + .setSingleBytesWrapper(BytesValue.of(ByteString.copyFromUtf8("abc"))) + .build())); + + assertThat(result).isTrue(); + } + + @Test + @SuppressWarnings("unchecked") + @TestParameters("{checkedExpr: 'compiled_proto2_deep_traversal'}") + @TestParameters("{checkedExpr: 'compiled_proto3_deep_traversal'}") + public void eval_protoMessage_safeTraversal(String checkedExpr) throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + dev.cel.expr.conformance.proto2.TestAllTypesCelLiteDescriptor.getDescriptor(), + dev.cel.expr.conformance.proto2.NestedTestAllTypesCelLiteDescriptor + .getDescriptor(), + TestAllTypesCelLiteDescriptor.getDescriptor(), + NestedTestAllTypesCelLiteDescriptor.getDescriptor())) + .build(); + // Expr: proto2.oneof_type.payload.repeated_string + CelAbstractSyntaxTree ast = readCheckedExpr(checkedExpr); + + Program program = runtime.createProgram(ast); + + List result = + (List) + program.eval( + ImmutableMap.of( + "proto2", dev.cel.expr.conformance.proto2.TestAllTypes.getDefaultInstance(), + "proto3", TestAllTypes.getDefaultInstance())); + + assertThat(result).isEmpty(); + } + + @Test + @SuppressWarnings("unchecked") + @TestParameters("{checkedExpr: 'compiled_proto2_deep_traversal'}") + @TestParameters("{checkedExpr: 'compiled_proto3_deep_traversal'}") + public void eval_protoMessage_deepTraversalReturnsRepeatedStrings(String checkedExpr) + throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + dev.cel.expr.conformance.proto2.TestAllTypesCelLiteDescriptor.getDescriptor(), + dev.cel.expr.conformance.proto2.NestedTestAllTypesCelLiteDescriptor + .getDescriptor(), + TestAllTypesCelLiteDescriptor.getDescriptor(), + NestedTestAllTypesCelLiteDescriptor.getDescriptor())) + .build(); + // Expr: proto2.oneof_type.payload.repeated_string + CelAbstractSyntaxTree ast = readCheckedExpr(checkedExpr); + Program program = runtime.createProgram(ast); + ImmutableList data = ImmutableList.of("hello", "world"); + + List result = + (List) + program.eval( + ImmutableMap.of( + "proto2", + dev.cel.expr.conformance.proto2.TestAllTypes.newBuilder() + .setOneofType( + dev.cel.expr.conformance.proto2.NestedTestAllTypes.newBuilder() + .setPayload( + dev.cel.expr.conformance.proto2.TestAllTypes.newBuilder() + .addAllRepeatedString(data) + .build())), + "proto3", + TestAllTypes.newBuilder() + .setOneofType( + NestedTestAllTypes.newBuilder() + .setPayload( + TestAllTypes.newBuilder() + .addAllRepeatedString(data) + .build())))); + + assertThat(result).isEqualTo(data); + } + + @Test + @SuppressWarnings("unchecked") + @TestParameters("{checkedExpr: 'compiled_proto2_select_repeated_fields'}") + @TestParameters("{checkedExpr: 'compiled_proto3_select_repeated_fields'}") + public void eval_protoMessage_repeatedFields(String checkedExpr) throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + dev.cel.expr.conformance.proto2.TestAllTypesCelLiteDescriptor.getDescriptor(), + TestAllTypesCelLiteDescriptor.getDescriptor())) + .build(); + dev.cel.expr.conformance.proto2.TestAllTypes proto2TestMsg = + dev.cel.expr.conformance.proto2.TestAllTypes.newBuilder() + .addAllRepeatedInt32(ImmutableList.of(1, 2)) + .addAllRepeatedInt64(ImmutableList.of(3L, 4L)) + .addAllRepeatedUint32(ImmutableList.of(5, 6)) + .addAllRepeatedUint64(ImmutableList.of(7L, 8L)) + .addAllRepeatedSint32(ImmutableList.of(9, 10)) + .addAllRepeatedSint64(ImmutableList.of(11L, 12L)) + .addAllRepeatedFixed32(ImmutableList.of(13, 14)) + .addAllRepeatedFixed64(ImmutableList.of(15L, 16L)) + .addAllRepeatedSfixed32(ImmutableList.of(17, 18)) + .addAllRepeatedSfixed64(ImmutableList.of(19L, 20L)) + .addAllRepeatedFloat(ImmutableList.of(21.1f, 22.2f)) + .addAllRepeatedDouble(ImmutableList.of(23.3, 24.4)) + .addAllRepeatedBool(ImmutableList.of(true, false)) + .addAllRepeatedString(ImmutableList.of("alpha", "beta")) + .addAllRepeatedBytes( + ImmutableList.of( + ByteString.copyFromUtf8("gamma"), ByteString.copyFromUtf8("delta"))) + .build(); + TestAllTypes proto3TestMsg = + TestAllTypes.newBuilder() + .addAllRepeatedInt32(ImmutableList.of(1, 2)) + .addAllRepeatedInt64(ImmutableList.of(3L, 4L)) + .addAllRepeatedUint32(ImmutableList.of(5, 6)) + .addAllRepeatedUint64(ImmutableList.of(7L, 8L)) + .addAllRepeatedSint32(ImmutableList.of(9, 10)) + .addAllRepeatedSint64(ImmutableList.of(11L, 12L)) + .addAllRepeatedFixed32(ImmutableList.of(13, 14)) + .addAllRepeatedFixed64(ImmutableList.of(15L, 16L)) + .addAllRepeatedSfixed32(ImmutableList.of(17, 18)) + .addAllRepeatedSfixed64(ImmutableList.of(19L, 20L)) + .addAllRepeatedFloat(ImmutableList.of(21.1f, 22.2f)) + .addAllRepeatedDouble(ImmutableList.of(23.3, 24.4)) + .addAllRepeatedBool(ImmutableList.of(true, false)) + .addAllRepeatedString(ImmutableList.of("alpha", "beta")) + .addAllRepeatedBytes( + ImmutableList.of( + ByteString.copyFromUtf8("gamma"), ByteString.copyFromUtf8("delta"))) + .build(); + CelAbstractSyntaxTree ast = readCheckedExpr(checkedExpr); + Program program = runtime.createProgram(ast); + + List result = + (List) + program.eval(ImmutableMap.of("proto2", proto2TestMsg, "proto3", proto3TestMsg)); + + assertThat(result) + .comparingElementsUsing(LIST_WITH_DOUBLE_TOLERANCE) + .containsExactly( + ImmutableList.of(1L, 2L), + ImmutableList.of(3L, 4L), + ImmutableList.of(UnsignedLong.valueOf(5L), UnsignedLong.valueOf(6L)), + ImmutableList.of(UnsignedLong.valueOf(7L), UnsignedLong.valueOf(8L)), + ImmutableList.of(9L, 10L), + ImmutableList.of(11L, 12L), + ImmutableList.of(13L, 14L), + ImmutableList.of(15L, 16L), + ImmutableList.of(17L, 18L), + ImmutableList.of(19L, 20L), + ImmutableList.of(21.1d, 22.2d), + ImmutableList.of(23.3d, 24.4d), + ImmutableList.of(true, false), + ImmutableList.of("alpha", "beta"), + ImmutableList.of( + CelByteString.copyFromUtf8("gamma"), CelByteString.copyFromUtf8("delta"))) + .inOrder(); + } + + @Test + // leave proto2.TestAllTypes qualification as is for clarity + @SuppressWarnings({"UnnecessarilyFullyQualified", "unchecked"}) + @TestParameters("{checkedExpr: 'compiled_proto2_select_map_fields'}") + @TestParameters("{checkedExpr: 'compiled_proto3_select_map_fields'}") + public void eval_protoMessage_mapFields(String checkedExpr) throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + dev.cel.expr.conformance.proto2.TestAllTypesCelLiteDescriptor.getDescriptor(), + TestAllTypesCelLiteDescriptor.getDescriptor())) + .build(); + dev.cel.expr.conformance.proto2.TestAllTypes proto2TestMsg = + dev.cel.expr.conformance.proto2.TestAllTypes.newBuilder() + .putAllMapBoolBool(ImmutableMap.of(true, false, false, true)) + .putAllMapBoolString(ImmutableMap.of(true, "foo", false, "bar")) + .putAllMapBoolBytes( + ImmutableMap.of( + true, ByteString.copyFromUtf8("baz"), false, ByteString.copyFromUtf8("qux"))) + .putAllMapBoolInt32(ImmutableMap.of(true, 1, false, 2)) + .putAllMapBoolInt64(ImmutableMap.of(true, 3L, false, 4L)) + .putAllMapBoolUint32(ImmutableMap.of(true, 5, false, 6)) + .putAllMapBoolUint64(ImmutableMap.of(true, 7L, false, 8L)) + .putAllMapBoolFloat(ImmutableMap.of(true, 9.1f, false, 10.2f)) + .putAllMapBoolDouble(ImmutableMap.of(true, 11.3, false, 12.4)) + .putAllMapBoolEnum( + ImmutableMap.of( + true, + dev.cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAR, + false, + dev.cel.expr.conformance.proto2.TestAllTypes.NestedEnum.BAZ)) + .putAllMapBoolDuration( + ImmutableMap.of( + true, + ProtoTimeUtils.fromSecondsToDuration(15), + false, + ProtoTimeUtils.fromSecondsToDuration(16))) + .putAllMapBoolTimestamp( + ImmutableMap.of( + true, + ProtoTimeUtils.fromSecondsToTimestamp(17), + false, + ProtoTimeUtils.fromSecondsToTimestamp(18))) + .build(); + TestAllTypes proto3TestMsg = + TestAllTypes.newBuilder() + .putAllMapBoolBool(ImmutableMap.of(true, false, false, true)) + .putAllMapBoolString(ImmutableMap.of(true, "foo", false, "bar")) + .putAllMapBoolBytes( + ImmutableMap.of( + true, ByteString.copyFromUtf8("baz"), false, ByteString.copyFromUtf8("qux"))) + .putAllMapBoolInt32(ImmutableMap.of(true, 1, false, 2)) + .putAllMapBoolInt64(ImmutableMap.of(true, 3L, false, 4L)) + .putAllMapBoolUint32(ImmutableMap.of(true, 5, false, 6)) + .putAllMapBoolUint64(ImmutableMap.of(true, 7L, false, 8L)) + .putAllMapBoolFloat(ImmutableMap.of(true, 9.1f, false, 10.2f)) + .putAllMapBoolDouble(ImmutableMap.of(true, 11.3, false, 12.4)) + .putAllMapBoolEnum( + ImmutableMap.of( + true, TestAllTypes.NestedEnum.BAR, false, TestAllTypes.NestedEnum.BAZ)) + .putAllMapBoolDuration( + ImmutableMap.of( + true, + ProtoTimeUtils.fromSecondsToDuration(15), + false, + ProtoTimeUtils.fromSecondsToDuration(16))) + .putAllMapBoolTimestamp( + ImmutableMap.of( + true, + ProtoTimeUtils.fromSecondsToTimestamp(17), + false, + ProtoTimeUtils.fromSecondsToTimestamp(18))) + .build(); + CelAbstractSyntaxTree ast = readCheckedExpr(checkedExpr); + Program program = runtime.createProgram(ast); + + List result = + (List) + program.eval(ImmutableMap.of("proto2", proto2TestMsg, "proto3", proto3TestMsg)); + + assertThat(result) + .comparingElementsUsing(MAP_WITH_DOUBLE_TOLERANCE) + .containsExactly( + ImmutableMap.of(true, false, false, true), + ImmutableMap.of(true, "foo", false, "bar"), + ImmutableMap.of( + true, CelByteString.copyFromUtf8("baz"), false, CelByteString.copyFromUtf8("qux")), + ImmutableMap.of(true, 1L, false, 2L), + ImmutableMap.of(true, 3L, false, 4L), + ImmutableMap.of(true, UnsignedLong.valueOf(5), false, UnsignedLong.valueOf(6)), + ImmutableMap.of(true, UnsignedLong.valueOf(7L), false, UnsignedLong.valueOf(8L)), + ImmutableMap.of(true, 9.1d, false, 10.2d), + ImmutableMap.of(true, 11.3d, false, 12.4d), + ImmutableMap.of(true, 1L, false, 2L), // Note: Enums are converted into integers + ImmutableMap.of(true, Duration.ofSeconds(15), false, Duration.ofSeconds(16)), + ImmutableMap.of(true, Instant.ofEpochSecond(17), false, Instant.ofEpochSecond(18))) + .inOrder(); + } + + private enum CelOptionsTestCase { + CEL_VALUE_DISABLED(newBaseTestOptions().enableCelValue(false).build()), + UNSIGNED_LONG_DISABLED(newBaseTestOptions().enableUnsignedLongs(false).build()), + UNWRAP_WKT_DISABLED(newBaseTestOptions().unwrapWellKnownTypesOnFunctionDispatch(false).build()), + ; + + private final CelOptions celOptions; + + private static CelOptions.Builder newBaseTestOptions() { + return CelOptions.current().enableCelValue(true); + } + + CelOptionsTestCase(CelOptions celOptions) { + this.celOptions = celOptions; + } + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeTest.java b/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeTest.java new file mode 100644 index 000000000..0ce7bd184 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeTest.java @@ -0,0 +1,696 @@ +// Copyright 2025 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 static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.util.Values; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.NullValue; +import dev.cel.common.values.ProtoMessageLiteValueProvider; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedEnum; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedMessage; +import dev.cel.expr.conformance.proto3.TestAllTypesCelDescriptor; +import dev.cel.parser.CelStandardMacro; +import dev.cel.testing.testdata.MessageWithEnum; +import dev.cel.testing.testdata.MessageWithEnumCelDescriptor; +import dev.cel.testing.testdata.MultiFile; +import dev.cel.testing.testdata.MultiFileCelDescriptor; +import dev.cel.testing.testdata.SimpleEnum; +import dev.cel.testing.testdata.SingleFile; +import dev.cel.testing.testdata.SingleFileCelDescriptor; +import java.time.Duration; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** Exercises tests for CelLiteRuntime using full version of protobuf messages. */ +@RunWith(TestParameterInjector.class) +public class CelLiteRuntimeTest { + private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .addVar("content", SimpleType.DYN) + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .build(); + + private static final CelLiteRuntime CEL_RUNTIME = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + dev.cel.expr.conformance.proto2.TestAllTypesCelDescriptor.getDescriptor(), + TestAllTypesCelDescriptor.getDescriptor())) + .build(); + + @Test + public void messageCreation_emptyMessage() throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile("TestAllTypes{}").getAst(); + + TestAllTypes simpleTest = (TestAllTypes) CEL_RUNTIME.createProgram(ast).eval(); + + assertThat(simpleTest).isEqualToDefaultInstance(); + } + + @Test + public void messageCreation_fieldsPopulated() throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile("TestAllTypes{single_int32: 4}").getAst(); + + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> CEL_RUNTIME.createProgram(ast).eval()); + + assertThat(e) + .hasMessageThat() + .contains("Message creation with prepopulated fields is not supported yet."); + } + + @Test + @TestParameters("{expression: 'msg.single_int32 == 1'}") + @TestParameters("{expression: 'msg.single_int64 == 2'}") + @TestParameters("{expression: 'msg.single_uint32 == 3u'}") + @TestParameters("{expression: 'msg.single_uint64 == 4u'}") + @TestParameters("{expression: 'msg.single_sint32 == 5'}") + @TestParameters("{expression: 'msg.single_sint64 == 6'}") + @TestParameters("{expression: 'msg.single_fixed32 == 7u'}") + @TestParameters("{expression: 'msg.single_fixed64 == 8u'}") + @TestParameters("{expression: 'msg.single_sfixed32 == 9'}") + @TestParameters("{expression: 'msg.single_sfixed64 == 10'}") + @TestParameters("{expression: 'msg.single_float == 1.5'}") + @TestParameters("{expression: 'msg.single_double == 2.5'}") + @TestParameters("{expression: 'msg.single_bool == true'}") + @TestParameters("{expression: 'msg.single_string == \"foo\"'}") + @TestParameters("{expression: 'msg.single_bytes == b\"abc\"'}") + @TestParameters("{expression: 'msg.optional_bool == true'}") + public void fieldSelection_literals(String expression) throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .setSingleInt32(1) + .setSingleInt64(2L) + .setSingleUint32(3) + .setSingleUint64(4L) + .setSingleSint32(5) + .setSingleSint64(6L) + .setSingleFixed32(7) + .setSingleFixed64(8L) + .setSingleSfixed32(9) + .setSingleSfixed64(10L) + .setSingleFloat(1.5f) + .setSingleDouble(2.5d) + .setSingleBool(true) + .setSingleString("foo") + .setSingleBytes(ByteString.copyFromUtf8("abc")) + .setOptionalBool(true) + .build(); + + boolean result = (boolean) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expression: 'msg.single_uint32'}") + @TestParameters("{expression: 'msg.single_uint64'}") + public void fieldSelection_unsigned(String expression) throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = TestAllTypes.newBuilder().setSingleUint32(4).setSingleUint64(4L).build(); + + Object result = CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isEqualTo(UnsignedLong.valueOf(4L)); + } + + @Test + @TestParameters("{expression: 'msg.repeated_int32'}") + @TestParameters("{expression: 'msg.repeated_int64'}") + @SuppressWarnings("unchecked") + public void fieldSelection_packedRepeatedInts(String expression) throws Exception { + // Note: non-LEN delimited primitives such as ints are packed by default in proto3 + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .addRepeatedInt32(1) + .addRepeatedInt32(2) + .addRepeatedInt64(1L) + .addRepeatedInt64(2L) + .build(); + + List result = + (List) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).containsExactly(1L, 2L).inOrder(); + } + + @Test + @SuppressWarnings("unchecked") + public void fieldSelection_repeatedStrings() throws Exception { + // Note: len-delimited fields, such as string and messages are not packed. + CelAbstractSyntaxTree ast = CEL_COMPILER.compile("msg.repeated_string").getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder().addRepeatedString("hello").addRepeatedString("world").build(); + + List result = + (List) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).containsExactly("hello", "world").inOrder(); + } + + @Test + @SuppressWarnings("unchecked") + public void fieldSelection_repeatedBoolWrappers() throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile("msg.repeated_bool_wrapper").getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .addRepeatedBoolWrapper(BoolValue.of(true)) + .addRepeatedBoolWrapper(BoolValue.of(false)) + .addRepeatedBoolWrapper(BoolValue.of(true)) + .build(); + + List result = + (List) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).containsExactly(true, false, true).inOrder(); + } + + @Test + @TestParameters("{expression: 'msg.map_string_int32'}") + @TestParameters("{expression: 'msg.map_string_int64'}") + @SuppressWarnings("unchecked") + public void fieldSelection_map(String expression) throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .putMapStringInt32("a", 1) + .putMapStringInt32("b", 2) + .putMapStringInt64("a", 1L) + .putMapStringInt64("b", 2L) + .build(); + + Map result = + (Map) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).containsExactly("a", 1L, "b", 2L); + } + + @Test + @TestParameters("{expression: 'msg.single_int32_wrapper == 1'}") + @TestParameters("{expression: 'msg.single_int64_wrapper == 2'}") + @TestParameters("{expression: 'msg.single_uint32_wrapper == 3u'}") + @TestParameters("{expression: 'msg.single_uint64_wrapper == 4u'}") + @TestParameters("{expression: 'msg.single_float_wrapper == 1.5'}") + @TestParameters("{expression: 'msg.single_double_wrapper == 2.5'}") + @TestParameters("{expression: 'msg.single_bool_wrapper == true'}") + @TestParameters("{expression: 'msg.single_string_wrapper == \"foo\"'}") + @TestParameters("{expression: 'msg.single_bytes_wrapper == b\"abc\"'}") + public void fieldSelection_wrappers(String expression) throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .setSingleInt32Wrapper(Int32Value.of(1)) + .setSingleInt64Wrapper(Int64Value.of(2L)) + .setSingleUint32Wrapper(UInt32Value.of(3)) + .setSingleUint64Wrapper(UInt64Value.of(4L)) + .setSingleFloatWrapper(FloatValue.of(1.5f)) + .setSingleDoubleWrapper(DoubleValue.of(2.5d)) + .setSingleBoolWrapper(BoolValue.of(true)) + .setSingleStringWrapper(StringValue.of("foo")) + .setSingleBytesWrapper(BytesValue.of(ByteString.copyFromUtf8("abc"))) + .build(); + + boolean result = (boolean) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expression: 'msg.single_int32_wrapper'}") + @TestParameters("{expression: 'msg.single_int64_wrapper'}") + @TestParameters("{expression: 'msg.single_uint32_wrapper'}") + @TestParameters("{expression: 'msg.single_uint64_wrapper'}") + @TestParameters("{expression: 'msg.single_float_wrapper'}") + @TestParameters("{expression: 'msg.single_double_wrapper'}") + @TestParameters("{expression: 'msg.single_bool_wrapper'}") + @TestParameters("{expression: 'msg.single_string_wrapper'}") + @TestParameters("{expression: 'msg.single_bytes_wrapper'}") + public void fieldSelection_wrappersNullability(String expression) throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = TestAllTypes.getDefaultInstance(); + + Object result = CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isEqualTo(NullValue.NULL_VALUE); + } + + @Test + public void fieldSelection_duration() throws Exception { + String expression = "msg.single_duration"; + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .setSingleDuration(ProtoTimeUtils.fromSecondsToDuration(600)) + .build(); + + Duration result = (Duration) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isEqualTo(Duration.ofMinutes(10)); + } + + @Test + public void fieldSelection_timestamp() throws Exception { + String expression = "msg.single_timestamp"; + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .setSingleTimestamp(ProtoTimeUtils.fromSecondsToTimestamp(50)) + .build(); + + Instant result = (Instant) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isEqualTo(Instant.ofEpochSecond(50)); + } + + @Test + @SuppressWarnings("unchecked") + public void fieldSelection_jsonStruct() throws Exception { + String expression = "msg.single_struct"; + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .setSingleStruct( + Struct.newBuilder() + .putFields("one", Values.of(1)) + .putFields("two", Values.of(true))) + .build(); + + Map result = + (Map) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).containsExactly("one", 1.0d, "two", true).inOrder(); + } + + @Test + public void fieldSelection_jsonValue() throws Exception { + String expression = "msg.single_value"; + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = TestAllTypes.newBuilder().setSingleValue(Values.of("foo")).build(); + + String result = (String) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isEqualTo("foo"); + } + + @Test + @SuppressWarnings("unchecked") + public void fieldSelection_jsonListValue() throws Exception { + String expression = "msg.list_value"; + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .setListValue( + ListValue.newBuilder().addValues(Values.of(true)).addValues(Values.of("foo"))) + .build(); + + List result = + (List) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).containsExactly(true, "foo").inOrder(); + } + + @Test + @TestParameters("{expression: 'has(msg.single_int32)'}") + @TestParameters("{expression: 'has(msg.single_int64)'}") + @TestParameters("{expression: 'has(msg.single_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.single_int64_wrapper)'}") + @TestParameters("{expression: 'has(msg.repeated_int32)'}") + @TestParameters("{expression: 'has(msg.repeated_int64)'}") + @TestParameters("{expression: 'has(msg.repeated_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.repeated_int64_wrapper)'}") + @TestParameters("{expression: 'has(msg.map_string_int32)'}") + @TestParameters("{expression: 'has(msg.map_string_int64)'}") + @TestParameters("{expression: 'has(msg.map_bool_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.map_bool_int64_wrapper)'}") + public void presenceTest_proto2_evaluatesToFalse(String expression) throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + dev.cel.expr.conformance.proto2.TestAllTypes msg = + dev.cel.expr.conformance.proto2.TestAllTypes.newBuilder() + .addAllRepeatedInt32(ImmutableList.of()) + .addAllRepeatedInt32Wrapper(ImmutableList.of()) + .putAllMapBoolInt32(ImmutableMap.of()) + .putAllMapBoolInt32Wrapper(ImmutableMap.of()) + .build(); + + boolean result = (boolean) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isFalse(); + } + + @Test + @TestParameters("{expression: 'has(msg.single_int32)'}") + @TestParameters("{expression: 'has(msg.single_int64)'}") + @TestParameters("{expression: 'has(msg.single_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.single_int64_wrapper)'}") + @TestParameters("{expression: 'has(msg.repeated_int32)'}") + @TestParameters("{expression: 'has(msg.repeated_int64)'}") + @TestParameters("{expression: 'has(msg.repeated_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.repeated_int64_wrapper)'}") + @TestParameters("{expression: 'has(msg.map_string_int32)'}") + @TestParameters("{expression: 'has(msg.map_string_int64)'}") + @TestParameters("{expression: 'has(msg.map_string_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.map_string_int64_wrapper)'}") + public void presenceTest_proto2_evaluatesToTrue(String expression) throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + dev.cel.expr.conformance.proto2.TestAllTypes msg = + dev.cel.expr.conformance.proto2.TestAllTypes.newBuilder() + .setSingleInt32(0) + .setSingleInt64(0) + .setSingleInt32Wrapper(Int32Value.of(0)) + .setSingleInt64Wrapper(Int64Value.of(0)) + .addAllRepeatedInt32(ImmutableList.of(1)) + .addAllRepeatedInt64(ImmutableList.of(2L)) + .addAllRepeatedInt32Wrapper(ImmutableList.of(Int32Value.of(0))) + .addAllRepeatedInt64Wrapper(ImmutableList.of(Int64Value.of(0L))) + .putAllMapStringInt32Wrapper(ImmutableMap.of("a", Int32Value.of(1))) + .putAllMapStringInt64Wrapper(ImmutableMap.of("b", Int64Value.of(2L))) + .putMapStringInt32("a", 1) + .putMapStringInt64("b", 2) + .build(); + + boolean result = (boolean) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expression: 'has(msg.single_int32)'}") + @TestParameters("{expression: 'has(msg.single_int64)'}") + @TestParameters("{expression: 'has(msg.single_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.single_int64_wrapper)'}") + @TestParameters("{expression: 'has(msg.repeated_int32)'}") + @TestParameters("{expression: 'has(msg.repeated_int64)'}") + @TestParameters("{expression: 'has(msg.repeated_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.repeated_int64_wrapper)'}") + @TestParameters("{expression: 'has(msg.map_string_int32)'}") + @TestParameters("{expression: 'has(msg.map_string_int64)'}") + @TestParameters("{expression: 'has(msg.map_bool_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.map_bool_int64_wrapper)'}") + public void presenceTest_proto3_evaluatesToFalse(String expression) throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .setSingleInt32(0) + .addAllRepeatedInt32(ImmutableList.of()) + .addAllRepeatedInt32Wrapper(ImmutableList.of()) + .putAllMapBoolInt32(ImmutableMap.of()) + .putAllMapBoolInt32Wrapper(ImmutableMap.of()) + .build(); + + boolean result = (boolean) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isFalse(); + } + + @Test + @TestParameters("{expression: 'has(msg.single_int32)'}") + @TestParameters("{expression: 'has(msg.single_int64)'}") + @TestParameters("{expression: 'has(msg.single_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.single_int64_wrapper)'}") + @TestParameters("{expression: 'has(msg.repeated_int32)'}") + @TestParameters("{expression: 'has(msg.repeated_int64)'}") + @TestParameters("{expression: 'has(msg.repeated_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.repeated_int64_wrapper)'}") + @TestParameters("{expression: 'has(msg.map_string_int32)'}") + @TestParameters("{expression: 'has(msg.map_string_int64)'}") + @TestParameters("{expression: 'has(msg.map_string_int32_wrapper)'}") + @TestParameters("{expression: 'has(msg.map_string_int64_wrapper)'}") + public void presenceTest_proto3_evaluatesToTrue(String expression) throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(expression).getAst(); + TestAllTypes msg = + TestAllTypes.newBuilder() + .setSingleInt32(1) + .setSingleInt64(2) + .setSingleInt32Wrapper(Int32Value.of(0)) + .setSingleInt64Wrapper(Int64Value.of(0)) + .addAllRepeatedInt32(ImmutableList.of(1)) + .addAllRepeatedInt64(ImmutableList.of(2L)) + .addAllRepeatedInt32Wrapper(ImmutableList.of(Int32Value.of(0))) + .addAllRepeatedInt64Wrapper(ImmutableList.of(Int64Value.of(0L))) + .putAllMapStringInt32Wrapper(ImmutableMap.of("a", Int32Value.of(1))) + .putAllMapStringInt64Wrapper(ImmutableMap.of("b", Int64Value.of(2L))) + .putMapStringInt32("a", 1) + .putMapStringInt64("b", 2) + .build(); + + boolean result = (boolean) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", msg)); + + assertThat(result).isTrue(); + } + + @Test + public void nestedMessage_traversalThroughSetField() throws Exception { + CelAbstractSyntaxTree ast = + CEL_COMPILER + .compile("msg.single_nested_message.bb == 43 && has(msg.single_nested_message)") + .getAst(); + TestAllTypes nestedMessage = + TestAllTypes.newBuilder() + .setSingleNestedMessage(NestedMessage.newBuilder().setBb(43)) + .build(); + + boolean result = + (boolean) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", nestedMessage)); + + assertThat(result).isTrue(); + } + + @Test + public void nestedMessage_safeTraversal() throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile("msg.single_nested_message.bb == 43").getAst(); + TestAllTypes nestedMessage = + TestAllTypes.newBuilder() + .setSingleNestedMessage(NestedMessage.getDefaultInstance()) + .build(); + + boolean result = + (boolean) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", nestedMessage)); + + assertThat(result).isFalse(); + } + + @Test + public void enumSelection() throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile("msg.single_nested_enum").getAst(); + TestAllTypes nestedMessage = + TestAllTypes.newBuilder().setSingleNestedEnum(NestedEnum.BAR).build(); + Long result = (Long) CEL_RUNTIME.createProgram(ast).eval(ImmutableMap.of("msg", nestedMessage)); + + assertThat(result).isEqualTo(NestedEnum.BAR.getNumber()); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum DefaultValueTestCase { + INT32("msg.single_int32", 0L), + INT64("msg.single_int64", 0L), + UINT32("msg.single_uint32", UnsignedLong.ZERO), + UINT64("msg.single_uint64", UnsignedLong.ZERO), + SINT32("msg.single_sint32", 0L), + SINT64("msg.single_sint64", 0L), + FIXED32("msg.single_fixed32", 0L), + FIXED64("msg.single_fixed64", 0L), + SFIXED32("msg.single_sfixed32", 0L), + SFIXED64("msg.single_sfixed64", 0L), + FLOAT("msg.single_float", 0.0d), + DOUBLE("msg.single_double", 0.0d), + BOOL("msg.single_bool", false), + STRING("msg.single_string", ""), + BYTES("msg.single_bytes", CelByteString.EMPTY), + ENUM("msg.standalone_enum", 0L), + NESTED_MESSAGE("msg.single_nested_message", NestedMessage.getDefaultInstance()), + OPTIONAL_BOOL("msg.optional_bool", false), + REPEATED_STRING("msg.repeated_string", Collections.unmodifiableList(new ArrayList<>())), + MAP_INT32_BOOL("msg.map_int32_bool", Collections.unmodifiableMap(new HashMap<>())), + ; + + private final String expression; + private final Object expectedValue; + + DefaultValueTestCase(String expression, Object expectedValue) { + this.expression = expression; + this.expectedValue = expectedValue; + } + } + + @Test + public void unsetField_defaultValue(@TestParameter DefaultValueTestCase testCase) + throws Exception { + CelAbstractSyntaxTree ast = CEL_COMPILER.compile(testCase.expression).getAst(); + + Object result = + CEL_RUNTIME + .createProgram(ast) + .eval(ImmutableMap.of("msg", TestAllTypes.getDefaultInstance())); + + assertThat(result).isEqualTo(testCase.expectedValue); + } + + @Test + public void nestedMessage_fromImportedProto() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar( + "multiFile", StructTypeReference.create(MultiFile.getDescriptor().getFullName())) + .addMessageTypes(MultiFile.getDescriptor()) + .build(); + CelLiteRuntime celRuntime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + SingleFileCelDescriptor.getDescriptor(), + MultiFileCelDescriptor.getDescriptor())) + .build(); + + CelAbstractSyntaxTree ast = celCompiler.compile("multiFile.nested_single_file.name").getAst(); + + String result = + (String) + celRuntime + .createProgram(ast) + .eval( + ImmutableMap.of( + "multiFile", + MultiFile.newBuilder() + .setNestedSingleFile(SingleFile.newBuilder().setName("foo").build()))); + + assertThat(result).isEqualTo("foo"); + } + + @Test + public void eval_withLateBoundFunction() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "lateBoundFunc", + CelOverloadDecl.newGlobalOverload( + "lateBoundFunc_string", SimpleType.STRING, SimpleType.STRING))) + .build(); + CelLiteRuntime celRuntime = CelLiteRuntimeFactory.newLiteRuntimeBuilder().build(); + CelAbstractSyntaxTree ast = celCompiler.compile("lateBoundFunc('hello')").getAst(); + + String result = + (String) + celRuntime + .createProgram(ast) + .eval( + ImmutableMap.of(), + CelLateFunctionBindings.from( + CelFunctionBinding.from( + "lateBoundFunc_string", String.class, arg -> arg + " world"))); + + assertThat(result).isEqualTo("hello world"); + } + + @Test + public void eval_dynFunctionReturnsProto() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "func", CelOverloadDecl.newGlobalOverload("func_identity", SimpleType.DYN))) + .build(); + CelLiteRuntime celRuntime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + TestAllTypesCelDescriptor.getDescriptor())) + .addFunctionBindings( + CelFunctionBinding.from( + "func_identity", + ImmutableList.of(), + unused -> TestAllTypes.getDefaultInstance())) + .build(); + + CelAbstractSyntaxTree ast = celCompiler.compile("func()").getAst(); + + TestAllTypes result = (TestAllTypes) celRuntime.createProgram(ast).eval(); + + assertThat(result).isEqualToDefaultInstance(); + } + + @Test + public void eval_withEnumField() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar( + "msg", StructTypeReference.create(MessageWithEnum.getDescriptor().getFullName())) + .addMessageTypes(MessageWithEnum.getDescriptor()) + .build(); + CelLiteRuntime celLiteRuntime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .setValueProvider( + ProtoMessageLiteValueProvider.newInstance( + MessageWithEnumCelDescriptor.getDescriptor())) + .build(); + CelAbstractSyntaxTree ast = celCompiler.compile("msg.simple_enum").getAst(); + + Long result = + (Long) + celLiteRuntime + .createProgram(ast) + .eval( + ImmutableMap.of( + "msg", MessageWithEnum.newBuilder().setSimpleEnum(SimpleEnum.BAR))); + + assertThat(result).isEqualTo(SimpleEnum.BAR.getNumber()); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelResolvedOverloadTest.java b/runtime/src/test/java/dev/cel/runtime/CelResolvedOverloadTest.java new file mode 100644 index 000000000..471282117 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelResolvedOverloadTest.java @@ -0,0 +1,114 @@ +// Copyright 2024 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 static com.google.common.truth.Truth.assertThat; + +import dev.cel.expr.conformance.proto3.TestAllTypes; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** Tests for {@link CelResolvedOverload}. */ +@RunWith(JUnit4.class) +public final class CelResolvedOverloadTest { + + CelResolvedOverload getIncrementIntOverload() { + return CelResolvedOverload.of( + /* functionName= */ "increment_int", + /* overloadId= */ "increment_int_overload", + (CelFunctionOverload) + (args) -> { + Long arg = (Long) args[0]; + return arg + 1; + }, + /* isStrict= */ true, + Long.class); + } + + @Test + public void canHandle_matchingTypes_returnsTrue() { + assertThat(getIncrementIntOverload().canHandle(new Object[] {1L})).isTrue(); + } + + @Test + public void canHandle_nullMessageType_returnsFalse() { + CelResolvedOverload overload = + CelResolvedOverload.of( + /* functionName= */ "identity", + /* overloadId= */ "identity_overload", + (CelFunctionOverload) (args) -> args[0], + /* isStrict= */ true, + TestAllTypes.class); + assertThat(overload.canHandle(new Object[] {null})).isFalse(); + } + + @Test + public void canHandle_nullPrimitive_returnsFalse() { + CelResolvedOverload overload = + CelResolvedOverload.of( + /* functionName= */ "identity", + /* overloadId= */ "identity_overload", + (CelFunctionOverload) (args) -> args[0], + /* isStrict= */ true, + Long.class); + assertThat(overload.canHandle(new Object[] {null})).isFalse(); + } + + @Test + public void canHandle_nonMatchingTypes_returnsFalse() { + assertThat(getIncrementIntOverload().canHandle(new Object[] {1.0})).isFalse(); + } + + @Test + public void canHandle_nonMatchingArgCount_returnsFalse() { + assertThat(getIncrementIntOverload().canHandle(new Object[] {1L, 2L})).isFalse(); + } + + @Test + public void canHandle_nonStrictOverload_returnsTrue() { + CelResolvedOverload nonStrictOverload = + CelResolvedOverload.of( + /* functionName= */ "non_strict", + /* overloadId= */ "non_strict_overload", + (CelFunctionOverload) + (args) -> { + return false; + }, + /* isStrict= */ false, + Long.class, + Long.class); + assertThat( + nonStrictOverload.canHandle( + new Object[] {new RuntimeException(), CelUnknownSet.create()})) + .isTrue(); + } + + @Test + public void canHandle_nonStrictOverload_returnsFalse() { + CelResolvedOverload nonStrictOverload = + CelResolvedOverload.of( + /* functionName= */ "non_strict", + /* overloadId= */ "non_strict_overload", + (CelFunctionOverload) + (args) -> { + return false; + }, + /* isStrict= */ false, + Long.class, + Long.class); + assertThat(nonStrictOverload.canHandle(new Object[] {new RuntimeException(), "Foo"})).isFalse(); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelRuntimeFactoryTest.java b/runtime/src/test/java/dev/cel/runtime/CelRuntimeFactoryTest.java new file mode 100644 index 000000000..28676ebcb --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelRuntimeFactoryTest.java @@ -0,0 +1,30 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelRuntimeFactoryTest { + + @Test + public void standardCelRuntimeBuilder() { + assertThat(CelRuntimeFactory.standardCelRuntimeBuilder().build()).isNotNull(); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelRuntimeLegacyImplTest.java b/runtime/src/test/java/dev/cel/runtime/CelRuntimeLegacyImplTest.java new file mode 100644 index 000000000..fa3b5f4ae --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelRuntimeLegacyImplTest.java @@ -0,0 +1,128 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; + +import com.google.protobuf.Message; +import dev.cel.common.CelException; +import dev.cel.common.exceptions.CelDivideByZeroException; +import dev.cel.common.values.CelValueProvider; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.runtime.CelStandardFunctions.StandardFunction; +import java.util.Optional; +import java.util.function.Function; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelRuntimeLegacyImplTest { + + @Test + public void evalException() throws CelException { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelRuntime runtime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + CelRuntime.Program program = runtime.createProgram(compiler.compile("1/0").getAst()); + CelEvaluationException e = Assert.assertThrows(CelEvaluationException.class, program::eval); + assertThat(e).hasCauseThat().isInstanceOf(CelDivideByZeroException.class); + } + + @Test + public void toRuntimeBuilder_isNewInstance() { + CelRuntimeBuilder celRuntimeBuilder = CelRuntimeFactory.standardCelRuntimeBuilder(); + CelRuntimeLegacyImpl celRuntime = (CelRuntimeLegacyImpl) celRuntimeBuilder.build(); + + CelRuntimeLegacyImpl.Builder newRuntimeBuilder = + (CelRuntimeLegacyImpl.Builder) celRuntime.toRuntimeBuilder(); + + assertThat(newRuntimeBuilder).isNotEqualTo(celRuntimeBuilder); + } + + @Test + public void toRuntimeBuilder_isImmutable() { + CelRuntimeBuilder originalRuntimeBuilder = CelRuntimeFactory.standardCelRuntimeBuilder(); + CelRuntimeLegacyImpl celRuntime = (CelRuntimeLegacyImpl) originalRuntimeBuilder.build(); + originalRuntimeBuilder.addLibraries(runtimeBuilder -> {}); + + CelRuntimeLegacyImpl.Builder newRuntimeBuilder = + (CelRuntimeLegacyImpl.Builder) celRuntime.toRuntimeBuilder(); + + assertThat(newRuntimeBuilder.celRuntimeLibraries.build()).isEmpty(); + } + + @Test + public void toRuntimeBuilder_collectionProperties_copied() { + CelRuntimeBuilder celRuntimeBuilder = CelRuntimeFactory.standardCelRuntimeBuilder(); + celRuntimeBuilder.addMessageTypes(TestAllTypes.getDescriptor()); + celRuntimeBuilder.addFileTypes(TestAllTypes.getDescriptor().getFile()); + celRuntimeBuilder.addFunctionBindings(CelFunctionBinding.from("test", Integer.class, arg -> 1)); + celRuntimeBuilder.addLibraries(runtimeBuilder -> {}); + int originalFileTypesSize = + ((CelRuntimeLegacyImpl.Builder) celRuntimeBuilder).fileTypes.build().size(); + CelRuntimeLegacyImpl celRuntime = (CelRuntimeLegacyImpl) celRuntimeBuilder.build(); + + CelRuntimeLegacyImpl.Builder newRuntimeBuilder = + (CelRuntimeLegacyImpl.Builder) celRuntime.toRuntimeBuilder(); + + assertThat(newRuntimeBuilder.customFunctionBindings).hasSize(1); + assertThat(newRuntimeBuilder.celRuntimeLibraries.build()).hasSize(1); + assertThat(newRuntimeBuilder.fileTypes.build()).hasSize(originalFileTypesSize); + } + + @Test + public void toRuntimeBuilder_collectionProperties_areImmutable() { + CelRuntimeBuilder celRuntimeBuilder = CelRuntimeFactory.standardCelRuntimeBuilder(); + CelRuntimeLegacyImpl celRuntime = (CelRuntimeLegacyImpl) celRuntimeBuilder.build(); + CelRuntimeLegacyImpl.Builder newRuntimeBuilder = + (CelRuntimeLegacyImpl.Builder) celRuntime.toRuntimeBuilder(); + + // Mutate the original builder containing collections + celRuntimeBuilder.addMessageTypes(TestAllTypes.getDescriptor()); + celRuntimeBuilder.addFileTypes(TestAllTypes.getDescriptor().getFile()); + celRuntimeBuilder.addFunctionBindings(CelFunctionBinding.from("test", Integer.class, arg -> 1)); + celRuntimeBuilder.addLibraries(runtimeBuilder -> {}); + + assertThat(newRuntimeBuilder.customFunctionBindings).isEmpty(); + assertThat(newRuntimeBuilder.celRuntimeLibraries.build()).isEmpty(); + assertThat(newRuntimeBuilder.fileTypes.build()).isEmpty(); + } + + @Test + public void toRuntimeBuilder_optionalProperties() { + Function customTypeFactory = (typeName) -> TestAllTypes.newBuilder(); + CelStandardFunctions overriddenStandardFunctions = + CelStandardFunctions.newBuilder().includeFunctions(StandardFunction.ADD).build(); + CelValueProvider noOpValueProvider = (structType, fields) -> Optional.empty(); + CelRuntimeBuilder celRuntimeBuilder = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setStandardEnvironmentEnabled(false) + .setTypeFactory(customTypeFactory) + .setStandardFunctions(overriddenStandardFunctions) + .setValueProvider(noOpValueProvider); + CelRuntime celRuntime = celRuntimeBuilder.build(); + + CelRuntimeLegacyImpl.Builder newRuntimeBuilder = + (CelRuntimeLegacyImpl.Builder) celRuntime.toRuntimeBuilder(); + + assertThat(newRuntimeBuilder.customTypeFactory).isEqualTo(customTypeFactory); + assertThat(newRuntimeBuilder.overriddenStandardFunctions) + .isEqualTo(overriddenStandardFunctions); + assertThat(newRuntimeBuilder.celValueProvider).isEqualTo(noOpValueProvider); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelRuntimeTest.java b/runtime/src/test/java/dev/cel/runtime/CelRuntimeTest.java new file mode 100644 index 000000000..13d5dd550 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelRuntimeTest.java @@ -0,0 +1,947 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.api.expr.v1alpha1.CheckedExpr; +import com.google.api.expr.v1alpha1.Constant; +import com.google.api.expr.v1alpha1.Expr; +import com.google.api.expr.v1alpha1.Type.PrimitiveType; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.DynamicMessage; +import com.google.rpc.context.AttributeContext; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +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; +import dev.cel.common.CelProtoV1Alpha1AbstractSyntaxTree; +import dev.cel.common.CelSource; +import dev.cel.common.ast.CelConstant; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.types.CelV1AlphaTypes; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelExtensions; +import dev.cel.parser.CelStandardMacro; +import dev.cel.parser.CelUnparserFactory; +import dev.cel.testing.CelRuntimeFlavor; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelRuntimeTest { + + @TestParameter private CelRuntimeFlavor runtimeFlavor; + + @Test + public void evaluate_anyPackedEqualityUsingProtoDifferencer_success() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableProtoDifferencerEquality(true).build()) + .addVar("a", StructTypeReference.create(AttributeContext.getDescriptor().getFullName())) + .addVar("b", StructTypeReference.create(AttributeContext.getDescriptor().getFullName())) + .addMessageTypes(AttributeContext.getDescriptor()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("a == b").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + + Object evaluatedResult = + program.eval( + ImmutableMap.of( + "a", + AttributeContext.newBuilder() + .addExtensions( + Any.newBuilder() + .setTypeUrl("type.googleapis.com/google.rpc.context.AttributeContext") + .setValue(ByteString.copyFromUtf8("\032\000:\000")) + .build()) + .build(), + "b", + AttributeContext.newBuilder() + .addExtensions( + Any.newBuilder() + .setTypeUrl("type.googleapis.com/google.rpc.context.AttributeContext") + .setValue(ByteString.copyFromUtf8(":\000\032\000")) + .build()) + .build())); + + assertThat(evaluatedResult).isEqualTo(true); + } + + @Test + public void evaluate_v1alpha1CheckedExpr() throws Exception { + // Note: v1alpha1 proto support exists only to help migrate existing consumers. + // New users of CEL should use the canonical protos instead (I.E: dev.cel.expr) + CheckedExpr checkedExpr = + CheckedExpr.newBuilder() + .setExpr( + Expr.newBuilder() + .setId(1) + .setConstExpr(Constant.newBuilder().setStringValue("Hello world!").build()) + .build()) + .putTypeMap(1, CelV1AlphaTypes.create(PrimitiveType.STRING)) + .build(); + CelRuntime celRuntime = CelRuntimeFactory.standardCelRuntimeBuilder().build(); + CelRuntime.Program program = + celRuntime.createProgram( + CelProtoV1Alpha1AbstractSyntaxTree.fromCheckedExpr(checkedExpr).getAst()); + + String evaluatedResult = (String) program.eval(); + + assertThat(evaluatedResult).isEqualTo("Hello world!"); + } + + @Test + // Lazy evaluation result cache doesn't allow references to mutate the cached instance. + @TestParameters( + "{expression: 'cel.bind(x, unknown_attr, (unknown_attr > 0) || [0, 1, 2, 3, 4, 5, 6, 7, 8, 9," + + " 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].exists(i, x + x > 0))'}") + @TestParameters( + "{expression: 'cel.bind(x, unknown_attr, x + x + x + x + x + x + x + x + x + x + x + x + x +" + + " x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x)'}") + // A new unknown is created per 'x' reference. + @TestParameters( + "{expression: '(my_list.exists(x, (x + x + x + x + x + x + x + x + x + x + x + x + x + x + x" + + " + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x + x) > 100) &&" + + " false) || unknown_attr > 0'}") + public void advanceEvaluation_withUnknownTracking_noSelfReferenceInMerge(String expression) + throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addCompilerLibraries(CelExtensions.bindings()) + .setContainer(CelContainer.ofName("cel.expr.conformance.test")) + .addVar("unknown_attr", SimpleType.INT) + .addVar("my_list", ListType.create(SimpleType.INT)) + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .build(); + + CelUnknownSet result = + (CelUnknownSet) + cel.createProgram(cel.compile(expression).getAst()) + .advanceEvaluation( + UnknownContext.create( + (String name) -> { + if (name.equals("my_list")) { + return Optional.of(ImmutableList.of(1)); + } + return Optional.empty(); + }, + ImmutableList.of( + CelAttributePattern.create("unknown_attr"), + CelAttributePattern.create("my_list") + .qualify(CelAttribute.Qualifier.ofInt(0))))); + + assertThat(result.attributes()).containsExactly(CelAttribute.create("unknown_attr")); + } + + @Test + public void newWellKnownTypeMessage_withDifferentDescriptorInstance() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(BoolValue.getDescriptor()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + // CEL-Internal-2 + .addFileTypes( + FileDescriptorSet.newBuilder() + .addFile( + BoolValue.getDescriptor().getFile().toProto()) // Copy the WKT descriptor + .build()) + .build(); + + CelAbstractSyntaxTree ast = + celCompiler.compile("google.protobuf.BoolValue{value: false}").getAst(); + + assertThat(celRuntime.createProgram(ast).eval()).isEqualTo(false); + } + + @Test + public void newWellKnownTypeMessage_inDynamicMessage_withSetTypeFactory() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(BoolValue.getDescriptor()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + // CEL-Internal-2 + .setTypeFactory( + (typeName) -> + typeName.equals("google.protobuf.BoolValue") + ? DynamicMessage.newBuilder(BoolValue.getDescriptor()) + : null) + .build(); + + CelAbstractSyntaxTree ast = + celCompiler.compile("google.protobuf.BoolValue{value: false}").getAst(); + + assertThat(celRuntime.createProgram(ast).eval()).isEqualTo(false); + } + + @Test + public void newWellKnownTypeMessage_inAnyMessage_withDifferentDescriptorInstance() + throws Exception { + FileDescriptorSet fds = + FileDescriptorSet.newBuilder() + // Copy the WKT descriptors + .addFile(Any.getDescriptor().getFile().toProto()) + .addFile(BoolValue.getDescriptor().getFile().toProto()) + .build(); + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder().addFileTypes(fds).build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + // CEL-Internal-2 + .addFileTypes(fds) + .build(); + + CelAbstractSyntaxTree ast = + celCompiler + .compile( + "google.protobuf.Any{type_url: 'types.googleapis.com/google.protobuf.DoubleValue'}") + .getAst(); + + assertThat(celRuntime.createProgram(ast).eval()).isEqualTo(0.0d); + } + + @Test + public void newWellKnownTypeMessage_inAnyMessage_withSetTypeFactory() throws Exception { + FileDescriptorSet fds = + FileDescriptorSet.newBuilder() + // Copy the WKT descriptors + .addFile(Any.getDescriptor().getFile().toProto()) + .addFile(BoolValue.getDescriptor().getFile().toProto()) + .build(); + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder().addFileTypes(fds).build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + // CEL-Internal-2 + .addFileTypes(fds) + .setTypeFactory( + (typeName) -> + typeName.equals("google.protobuf.Any") + ? Any.newBuilder().setTypeUrl("google.protobuf.DoubleValue") + : null) + .build(); + + CelAbstractSyntaxTree ast = + celCompiler + .compile( + "google.protobuf.Any{type_url: 'types.googleapis.com/google.protobuf.DoubleValue'}") + .getAst(); + + assertThat(celRuntime.createProgram(ast).eval()).isEqualTo(0.0d); + } + + @Test + public void trace_callExpr_identifyFalseBranch() throws Exception { + AtomicReference capturedExpr = new AtomicReference<>(); + CelEvaluationListener listener = + (expr, res) -> { + if (res instanceof Boolean && !(boolean) res && capturedExpr.get() == null) { + capturedExpr.set(expr); + } + }; + Cel cel = + runtimeFlavor + .builder() + .addVar("a", SimpleType.INT) + .addVar("b", SimpleType.INT) + .addVar("c", SimpleType.INT) + .build(); + CelAbstractSyntaxTree ast = cel.compile("a < 0 && b < 0 && c < 0").getAst(); + + boolean result = + (boolean) cel.createProgram(ast).trace(ImmutableMap.of("a", -1, "b", 1, "c", -4), listener); + + assertThat(result).isFalse(); + // Demonstrate that "b < 0" is what caused the expression to be false + CelAbstractSyntaxTree subtree = + CelAbstractSyntaxTree.newParsedAst(capturedExpr.get(), CelSource.newBuilder().build()); + assertThat(CelUnparserFactory.newUnparser().unparse(subtree)).isEqualTo("b < 0"); + } + + @Test + public void trace_constant() throws Exception { + CelEvaluationListener listener = + (expr, res) -> { + assertThat(res).isEqualTo("hello world"); + assertThat(expr.constant().getKind()).isEqualTo(CelConstant.Kind.STRING_VALUE); + }; + Cel cel = runtimeFlavor.builder().build(); + CelAbstractSyntaxTree ast = cel.compile("'hello world'").getAst(); + + String result = (String) cel.createProgram(ast).trace(listener); + + assertThat(result).isEqualTo("hello world"); + } + + @Test + public void trace_ident() throws Exception { + CelEvaluationListener listener = + (expr, res) -> { + assertThat(res).isEqualTo("test"); + assertThat(expr.ident().name()).isEqualTo("a"); + }; + Cel cel = runtimeFlavor.builder().addVar("a", SimpleType.STRING).build(); + CelAbstractSyntaxTree ast = cel.compile("a").getAst(); + + String result = (String) cel.createProgram(ast).trace(ImmutableMap.of("a", "test"), listener); + + assertThat(result).isEqualTo("test"); + } + + @Test + public void trace_select() throws Exception { + CelEvaluationListener listener = + (expr, res) -> { + if (expr.exprKind().getKind().equals(Kind.SELECT)) { + assertThat(res).isEqualTo(3L); + assertThat(expr.select().field()).isEqualTo("single_int64"); + } + }; + Cel cel = + runtimeFlavor + .builder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .build(); + CelAbstractSyntaxTree ast = cel.compile("TestAllTypes{single_int64: 3}.single_int64").getAst(); + + Long result = (Long) cel.createProgram(ast).trace(listener); + + assertThat(result).isEqualTo(3L); + } + + @Test + public void trace_struct() throws Exception { + CelEvaluationListener listener = + (expr, res) -> { + assertThat(res).isEqualTo(TestAllTypes.getDefaultInstance()); + assertThat(expr.struct().messageName()) + .isEqualTo("cel.expr.conformance.proto3.TestAllTypes"); + }; + Cel cel = + runtimeFlavor + .builder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName("cel.expr.conformance.proto3")) + .build(); + CelAbstractSyntaxTree ast = cel.compile("TestAllTypes{}").getAst(); + + TestAllTypes result = (TestAllTypes) cel.createProgram(ast).trace(listener); + + assertThat(result).isEqualTo(TestAllTypes.getDefaultInstance()); + } + + @Test + @SuppressWarnings("unchecked") // Test only + public void trace_list() throws Exception { + CelEvaluationListener listener = + (expr, res) -> { + if (expr.exprKind().getKind().equals(Kind.LIST)) { + assertThat((List) res).containsExactly(1L, 2L, 3L); + assertThat(expr.list().elements()).hasSize(3); + } + }; + Cel cel = runtimeFlavor.builder().build(); + CelAbstractSyntaxTree ast = cel.compile("[1, 2, 3]").getAst(); + + List result = (List) cel.createProgram(ast).trace(listener); + + assertThat(result).containsExactly(1L, 2L, 3L); + } + + @Test + @SuppressWarnings("unchecked") // Test only + public void trace_map() throws Exception { + CelEvaluationListener listener = + (expr, res) -> { + if (expr.exprKind().getKind().equals(Kind.MAP)) { + assertThat((Map) res).containsExactly(1L, "a"); + assertThat(expr.map().entries()).hasSize(1); + } + }; + Cel cel = runtimeFlavor.builder().build(); + CelAbstractSyntaxTree ast = cel.compile("{1: 'a'}").getAst(); + + Map result = (Map) cel.createProgram(ast).trace(listener); + + assertThat(result).containsExactly(1L, "a"); + } + + @Test + public void trace_comprehension() throws Exception { + CelEvaluationListener listener = + (expr, res) -> { + if (expr.exprKind().getKind().equals(Kind.COMPREHENSION)) { + assertThat(expr.comprehension().iterVar()).isEqualTo("i"); + } + }; + Cel cel = runtimeFlavor.builder().setStandardMacros(CelStandardMacro.STANDARD_MACROS).build(); + CelAbstractSyntaxTree ast = cel.compile("[true].exists(i, i)").getAst(); + + boolean result = (boolean) cel.createProgram(ast).trace(listener); + + assertThat(result).isTrue(); + } + + @Test + public void trace_withMessageInput() throws Exception { + CelEvaluationListener listener = + (expr, res) -> { + assertThat(res).isEqualTo(6L); + assertThat(expr.ident().name()).isEqualTo("single_int64"); + }; + Cel cel = + runtimeFlavor + .builder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("single_int64", SimpleType.INT) + .build(); + CelAbstractSyntaxTree ast = cel.compile("single_int64").getAst(); + + Long result = + (Long) + cel.createProgram(ast) + .trace(TestAllTypes.newBuilder().setSingleInt64(6L).build(), listener); + + assertThat(result).isEqualTo(6L); + } + + @Test + public void trace_withVariableResolver() throws Exception { + CelEvaluationListener listener = + (expr, res) -> { + assertThat(res).isEqualTo("hello"); + assertThat(expr.ident().name()).isEqualTo("variable"); + }; + Cel cel = + runtimeFlavor + .builder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("variable", SimpleType.STRING) + .build(); + CelAbstractSyntaxTree ast = cel.compile("variable").getAst(); + CelVariableResolver resolver = + (name) -> name.equals("variable") ? Optional.of("hello") : Optional.empty(); + + String result = (String) cel.createProgram(ast).trace(resolver, listener); + + assertThat(result).isEqualTo("hello"); + } + + @Test + public void trace_shortCircuitingDisabled_logicalAndAllBranchesVisited( + @TestParameter boolean first, @TestParameter boolean second, @TestParameter boolean third) + throws Exception { + String expression = String.format("%s && %s && %s", first, second, third); + ImmutableList.Builder branchResults = ImmutableList.builder(); + CelEvaluationListener listener = + (expr, res) -> { + if (expr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE)) { + branchResults.add((Boolean) res); + } + }; + Cel celWithShortCircuit = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableShortCircuiting(true) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + Cel cel = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(expression).getAst(); + + boolean result = (boolean) cel.createProgram(ast).trace(listener); + boolean shortCircuitedResult = + (boolean) + celWithShortCircuit + .createProgram(celWithShortCircuit.compile(expression).getAst()) + .eval(); + + assertThat(result).isEqualTo(shortCircuitedResult); + assertThat(branchResults.build()).containsExactly(first, second, third).inOrder(); + } + + @Test + @TestParameters("{source: 'false && false && x'}") + @TestParameters("{source: 'false && x && false'}") + @TestParameters("{source: 'x && false && false'}") + public void trace_shortCircuitingDisabledWithUnknownsAndedToFalse_returnsFalse(String source) + throws Exception { + ImmutableList.Builder branchResults = ImmutableList.builder(); + CelEvaluationListener listener = + (expr, res) -> { + if (expr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE) + || expr.identOrDefault().name().equals("x")) { + if (InterpreterUtil.isUnknown(res)) { + branchResults.add("x"); // Swap unknown result with a sentinel value for testing + } else { + branchResults.add(res); + } + } + }; + Cel cel = + runtimeFlavor + .builder() + .addVar("x", SimpleType.BOOL) + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + PartialVars partialVars = PartialVars.of(CelAttributePattern.create("x")); + boolean result = (boolean) cel.createProgram(ast).trace(partialVars, listener); + + assertThat(result).isFalse(); + assertThat(branchResults.build()).containsExactly(false, false, "x"); + } + + @Test + @TestParameters("{source: 'true && true && x'}") + @TestParameters("{source: 'true && x && true'}") + @TestParameters("{source: 'x && true && true'}") + public void trace_shortCircuitingDisabledWithUnknownAndedToTrue_returnsUnknown(String source) + throws Exception { + ImmutableList.Builder branchResults = ImmutableList.builder(); + CelEvaluationListener listener = + (expr, res) -> { + if (expr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE) + || expr.identOrDefault().name().equals("x")) { + branchResults.add(res); + } + }; + Cel cel = + runtimeFlavor + .builder() + .addVar("x", SimpleType.BOOL) + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + PartialVars partialVars = PartialVars.of(CelAttributePattern.create("x")); + Object unknownResult = cel.createProgram(ast).trace(partialVars, listener); + + assertThat(InterpreterUtil.isUnknown(unknownResult)).isTrue(); + assertThat(branchResults.build()).containsExactly(true, true, unknownResult); + } + + @Test + public void trace_shortCircuitingDisabled_logicalOrAllBranchesVisited( + @TestParameter boolean first, @TestParameter boolean second, @TestParameter boolean third) + throws Exception { + String expression = String.format("%s || %s || %s", first, second, third); + ImmutableList.Builder branchResults = ImmutableList.builder(); + CelEvaluationListener listener = + (expr, res) -> { + if (expr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE)) { + branchResults.add((Boolean) res); + } + }; + Cel celWithShortCircuit = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableShortCircuiting(true) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + Cel cel = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(expression).getAst(); + + boolean result = (boolean) cel.createProgram(ast).trace(listener); + boolean shortCircuitedResult = + (boolean) + celWithShortCircuit + .createProgram(celWithShortCircuit.compile(expression).getAst()) + .eval(); + + assertThat(result).isEqualTo(shortCircuitedResult); + assertThat(branchResults.build()).containsExactly(first, second, third).inOrder(); + } + + @Test + @TestParameters("{source: 'false || false || x'}") + @TestParameters("{source: 'false || x || false'}") + @TestParameters("{source: 'x || false || false'}") + public void trace_shortCircuitingDisabledWithUnknownsOredToFalse_returnsUnknown(String source) + throws Exception { + ImmutableList.Builder branchResults = ImmutableList.builder(); + CelEvaluationListener listener = + (expr, res) -> { + if (expr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE) + || expr.identOrDefault().name().equals("x")) { + branchResults.add(res); + } + }; + Cel cel = + runtimeFlavor + .builder() + .addVar("x", SimpleType.BOOL) + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + PartialVars partialVars = PartialVars.of(CelAttributePattern.create("x")); + Object unknownResult = cel.createProgram(ast).trace(partialVars, listener); + + assertThat(InterpreterUtil.isUnknown(unknownResult)).isTrue(); + assertThat(branchResults.build()).containsExactly(false, false, unknownResult); + } + + @Test + @TestParameters("{source: 'true || true || x'}") + @TestParameters("{source: 'true || x || true'}") + @TestParameters("{source: 'x || true || true'}") + public void trace_shortCircuitingDisabledWithUnknownOredToTrue_returnsTrue(String source) + throws Exception { + ImmutableList.Builder branchResults = ImmutableList.builder(); + CelEvaluationListener listener = + (expr, res) -> { + if (expr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE) + || expr.identOrDefault().name().equals("x")) { + if (InterpreterUtil.isUnknown(res)) { + branchResults.add("x"); // Swap unknown result with a sentinel value for testing + } else { + branchResults.add(res); + } + } + }; + Cel cel = + runtimeFlavor + .builder() + .addVar("x", SimpleType.BOOL) + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + PartialVars partialVars = PartialVars.of(CelAttributePattern.create("x")); + boolean result = (boolean) cel.createProgram(ast).trace(partialVars, listener); + + assertThat(result).isTrue(); + assertThat(branchResults.build()).containsExactly(true, true, "x"); + } + + @Test + public void trace_shortCircuitingDisabled_ternaryAllBranchesVisited() throws Exception { + ImmutableList.Builder branchResults = ImmutableList.builder(); + CelEvaluationListener listener = + (expr, res) -> { + if (expr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE)) { + branchResults.add((Boolean) res); + } + }; + Cel cel = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("true ? false : true").getAst(); + + boolean result = (boolean) cel.createProgram(ast).trace(listener); + + assertThat(result).isFalse(); + assertThat(branchResults.build()).containsExactly(true, false, true); + } + + @Test + @TestParameters("{source: 'false ? true : x'}") + @TestParameters("{source: 'true ? x : false'}") + @TestParameters("{source: 'x ? true : false'}") + public void trace_shortCircuitingDisabled_ternaryWithUnknowns(String source) throws Exception { + ImmutableList.Builder branchResults = ImmutableList.builder(); + CelEvaluationListener listener = + (expr, res) -> { + if (expr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE) + || expr.identOrDefault().name().equals("x")) { + branchResults.add(res); + } + }; + Cel cel = + runtimeFlavor + .builder() + .addVar("x", SimpleType.BOOL) + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + PartialVars partialVars = PartialVars.of(CelAttributePattern.create("x")); + Object unknownResult = cel.createProgram(ast).trace(partialVars, listener); + + assertThat(InterpreterUtil.isUnknown(unknownResult)).isTrue(); + assertThat(branchResults.build()).containsExactly(false, unknownResult, true); + } + + @Test + @TestParameters( + "{expression: 'false ? (1 / 0) > 2 : false', firstVisited: false, secondVisited: false}") + @TestParameters( + "{expression: 'false ? (1 / 0) > 2 : true', firstVisited: false, secondVisited: true}") + @TestParameters( + "{expression: 'true ? false : (1 / 0) > 2', firstVisited: true, secondVisited: false}") + @TestParameters( + "{expression: 'true ? true : (1 / 0) > 2', firstVisited: true, secondVisited: true}") + public void trace_shortCircuitingDisabled_ternaryWithError( + String expression, boolean firstVisited, boolean secondVisited) throws Exception { + ImmutableList.Builder branchResults = ImmutableList.builder(); + CelEvaluationListener listener = + (expr, res) -> { + if (expr.constantOrDefault().getKind().equals(CelConstant.Kind.BOOLEAN_VALUE)) { + branchResults.add(res); + } + }; + Cel celWithShortCircuit = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableShortCircuiting(true) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + Cel cel = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile(expression).getAst(); + + boolean result = (boolean) cel.createProgram(ast).trace(listener); + boolean shortCircuitedResult = + (boolean) + celWithShortCircuit + .createProgram(celWithShortCircuit.compile(expression).getAst()) + .eval(); + + assertThat(result).isEqualTo(shortCircuitedResult); + assertThat(branchResults.build()).containsExactly(firstVisited, secondVisited).inOrder(); + } + + @Test + public void trace_shortCircuitingDisabled_ternaryWithSelectedError() throws Exception { + Cel cel = + runtimeFlavor + .builder() + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("true ? (1 / 0) : 2").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> program.eval()); + assertThat(e).hasMessageThat().contains("evaluation error at :10: / by zero"); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.DIVIDE_BY_ZERO); + } + + @Test + public void trace_shortCircuitingDisabled_ternaryWithCustomError() throws Exception { + Cel cel = + runtimeFlavor + .builder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "error_func", + CelOverloadDecl.newGlobalOverload( + "error_func_overload", SimpleType.BOOL, ImmutableList.of()))) + .addFunctionBindings( + CelFunctionBinding.from( + "error_func_overload", + ImmutableList.of(), + args -> { + throw new IllegalArgumentException("custom error"); + })) + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("true ? error_func() : false").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> program.eval()); + assertThat(e).hasCauseThat().hasMessageThat().contains("custom error"); + } + + @Test + public void standardEnvironmentDisabledForRuntime_throws() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder().setStandardEnvironmentEnabled(true).build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder().setStandardEnvironmentEnabled(false).build(); + CelAbstractSyntaxTree ast = celCompiler.compile("size('hello')").getAst(); + CelRuntime.Program program = celRuntime.createProgram(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> program.eval()); + assertThat(e) + .hasMessageThat() + .contains("No matching overload for function 'size'. Overload candidates: size_string"); + } + + @Test + public void trace_shortCircuitingDisabled_logicalAndPrefersFirstError() throws Exception { + Cel cel = + runtimeFlavor + .builder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "error_1", + CelOverloadDecl.newGlobalOverload( + "error_1_overload", SimpleType.BOOL, ImmutableList.of())), + CelFunctionDecl.newFunctionDeclaration( + "error_2", + CelOverloadDecl.newGlobalOverload( + "error_2_overload", SimpleType.BOOL, ImmutableList.of()))) + .addFunctionBindings( + CelFunctionBinding.from( + "error_1_overload", + ImmutableList.of(), + args -> { + throw new IllegalArgumentException("error 1"); + }), + CelFunctionBinding.from( + "error_2_overload", + ImmutableList.of(), + args -> { + throw new IllegalArgumentException("error 2"); + })) + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("error_1() && error_2()").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> program.eval()); + assertThat(e).hasCauseThat().hasMessageThat().contains("error 1"); + } + + @Test + public void trace_shortCircuitingDisabled_logicalOrPrefersFirstError() throws Exception { + Cel cel = + runtimeFlavor + .builder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "error_1", + CelOverloadDecl.newGlobalOverload( + "error_1_overload", SimpleType.BOOL, ImmutableList.of())), + CelFunctionDecl.newFunctionDeclaration( + "error_2", + CelOverloadDecl.newGlobalOverload( + "error_2_overload", SimpleType.BOOL, ImmutableList.of()))) + .addFunctionBindings( + CelFunctionBinding.from( + "error_1_overload", + ImmutableList.of(), + args -> { + throw new IllegalArgumentException("error 1"); + }), + CelFunctionBinding.from( + "error_2_overload", + ImmutableList.of(), + args -> { + throw new IllegalArgumentException("error 2"); + })) + .setOptions( + CelOptions.current() + .enableShortCircuiting(false) + .enableHeterogeneousNumericComparisons(true) + .build()) + .build(); + CelAbstractSyntaxTree ast = cel.compile("error_1() || error_2()").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> program.eval()); + assertThat(e).hasCauseThat().hasMessageThat().contains("error 1"); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelStandardFunctionsTest.java b/runtime/src/test/java/dev/cel/runtime/CelStandardFunctionsTest.java new file mode 100644 index 000000000..c5f5572a7 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelStandardFunctionsTest.java @@ -0,0 +1,245 @@ +// Copyright 2024 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 static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableSet; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelOptions; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelStandardFunctions.StandardFunction; +import dev.cel.runtime.standard.AddOperator.AddOverload; +import dev.cel.runtime.standard.CelStandardOverload; +import dev.cel.runtime.standard.SubtractOperator.SubtractOverload; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class CelStandardFunctionsTest { + + @Test + @TestParameters("{includeFunction: true, excludeFunction: true, filterFunction: true}") + @TestParameters("{includeFunction: true, excludeFunction: true, filterFunction: false}") + @TestParameters("{includeFunction: true, excludeFunction: false, filterFunction: true}") + @TestParameters("{includeFunction: false, excludeFunction: true, filterFunction: true}") + public void standardFunction_moreThanOneFunctionFilterSet_throws( + boolean includeFunction, boolean excludeFunction, boolean filterFunction) { + CelStandardFunctions.Builder builder = CelStandardFunctions.newBuilder(); + if (includeFunction) { + builder.includeFunctions(StandardFunction.ADD); + } + if (excludeFunction) { + builder.excludeFunctions(StandardFunction.SUBTRACT); + } + if (filterFunction) { + builder.filterFunctions((func, over) -> true); + } + + IllegalArgumentException e = assertThrows(IllegalArgumentException.class, builder::build); + assertThat(e) + .hasMessageThat() + .contains( + "You may only populate one of the following builder methods: includeFunctions," + + " excludeFunctions or filterFunctions"); + } + + @Test + public void runtime_standardEnvironmentEnabled_throwsWhenOverridingFunctions() { + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> + CelRuntimeFactory.standardCelRuntimeBuilder() + .setStandardEnvironmentEnabled(true) + .setStandardFunctions( + CelStandardFunctions.newBuilder() + .includeFunctions(StandardFunction.ADD, StandardFunction.SUBTRACT) + .build()) + .build()); + + assertThat(e) + .hasMessageThat() + .contains( + "setStandardEnvironmentEnabled must be set to false to override standard" + + " function bindings"); + } + + @Test + public void standardFunctions_includeFunctions() { + CelStandardFunctions celStandardFunctions = + CelStandardFunctions.newBuilder() + .includeFunctions( + CelStandardFunctions.StandardFunction.ADD, + CelStandardFunctions.StandardFunction.SUBTRACT) + .build(); + + assertThat(celStandardFunctions.getOverloads()) + .containsExactlyElementsIn( + ImmutableSet.builder() + .addAll(CelStandardFunctions.StandardFunction.ADD.getOverloads()) + .addAll(CelStandardFunctions.StandardFunction.SUBTRACT.getOverloads()) + .build()); + } + + @Test + public void standardFunctions_excludeFunctions() { + CelStandardFunctions celStandardFunction = + CelStandardFunctions.newBuilder() + .excludeFunctions( + CelStandardFunctions.StandardFunction.ADD, + CelStandardFunctions.StandardFunction.SUBTRACT) + .build(); + + assertThat(celStandardFunction.getOverloads()) + .doesNotContain(CelStandardFunctions.StandardFunction.ADD.getOverloads()); + assertThat(celStandardFunction.getOverloads()) + .doesNotContain(CelStandardFunctions.StandardFunction.SUBTRACT.getOverloads()); + } + + @Test + public void standardFunctions_filterFunctions() { + CelStandardFunctions celStandardFunction = + CelStandardFunctions.newBuilder() + .filterFunctions( + (func, over) -> { + if (func.equals(CelStandardFunctions.StandardFunction.ADD) + && over.equals(AddOverload.ADD_INT64)) { + return true; + } + + if (func.equals(CelStandardFunctions.StandardFunction.SUBTRACT) + && over.equals(SubtractOverload.SUBTRACT_INT64)) { + return true; + } + + return false; + }) + .build(); + + assertThat(celStandardFunction.getOverloads()) + .containsExactly(AddOverload.ADD_INT64, SubtractOverload.SUBTRACT_INT64); + } + + @Test + public void standardEnvironment_subsetEnvironment() throws Exception { + CelCompiler celCompiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setStandardEnvironmentEnabled(false) + .setStandardFunctions( + CelStandardFunctions.newBuilder() + .includeFunctions(StandardFunction.ADD, StandardFunction.SUBTRACT) + .build()) + .build(); + assertThat(celRuntime.createProgram(celCompiler.compile("1 + 2 - 3").getAst()).eval()) + .isEqualTo(0); + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> celRuntime.createProgram(celCompiler.compile("1 * 2 / 3").getAst()).eval()); + assertThat(e) + .hasMessageThat() + .contains("No matching overload for function '_*_'. Overload candidates: multiply_int64"); + } + + @Test + @TestParameters("{expression: '1 > 2.0'}") + @TestParameters("{expression: '2.0 > 1'}") + @TestParameters("{expression: '1 > 2u'}") + @TestParameters("{expression: '2u > 1'}") + @TestParameters("{expression: '2u > 1.0'}") + @TestParameters("{expression: '1.0 > 2u'}") + @TestParameters("{expression: '1 >= 2.0'}") + @TestParameters("{expression: '2.0 >= 1'}") + @TestParameters("{expression: '1 >= 2u'}") + @TestParameters("{expression: '2u >= 1'}") + @TestParameters("{expression: '2u >= 1.0'}") + @TestParameters("{expression: '1.0 >= 2u'}") + @TestParameters("{expression: '1 < 2.0'}") + @TestParameters("{expression: '2.0 < 1'}") + @TestParameters("{expression: '1 < 2u'}") + @TestParameters("{expression: '2u < 1'}") + @TestParameters("{expression: '2u < 1.0'}") + @TestParameters("{expression: '1.0 < 2u'}") + @TestParameters("{expression: '1 <= 2.0'}") + @TestParameters("{expression: '2.0 <= 1'}") + @TestParameters("{expression: '1 <= 2u'}") + @TestParameters("{expression: '2u <= 1'}") + @TestParameters("{expression: '2u <= 1.0'}") + @TestParameters("{expression: '1.0 <= 2u'}") + public void heterogeneousEqualityDisabled_mixedTypeComparisons_throws(String expression) { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(true).build()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setOptions(CelOptions.current().enableHeterogeneousNumericComparisons(false).build()) + .build(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> celRuntime.createProgram(celCompiler.compile(expression).getAst()).eval()); + assertThat(e).hasMessageThat().contains("No matching overload for function"); + } + + @Test + public void unsignedLongsDisabled_int64Identity_throws() { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().enableUnsignedLongs(true).build()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setOptions(CelOptions.current().enableUnsignedLongs(false).build()) + .build(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> celRuntime.createProgram(celCompiler.compile("int(1)").getAst()).eval()); + assertThat(e) + .hasMessageThat() + .contains("No matching overload for function 'int'. Overload candidates: int64_to_int64"); + } + + @Test + public void timestampEpochDisabled_int64Identity_throws() { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(CelOptions.current().build()) + .build(); + CelRuntime celRuntime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .setOptions(CelOptions.current().enableTimestampEpoch(false).build()) + .build(); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> + celRuntime.createProgram(celCompiler.compile("timestamp(10000)").getAst()).eval()); + assertThat(e) + .hasMessageThat() + .contains( + "No matching overload for function 'timestamp'. Overload candidates:" + + " int64_to_timestamp"); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelUnknownSetTest.java b/runtime/src/test/java/dev/cel/runtime/CelUnknownSetTest.java new file mode 100644 index 000000000..c53a18e59 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelUnknownSetTest.java @@ -0,0 +1,108 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableSet; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelUnknownSetTest { + @Test + public void unknownSet_creation() { + assertThat(CelUnknownSet.create(CelAttribute.create("identifier"))) + .isEqualTo(CelUnknownSet.create(ImmutableSet.of(CelAttribute.create("identifier")))); + + assertThat( + CelUnknownSet.create(CelAttribute.create("identifier")) + .merge(CelUnknownSet.create(CelAttribute.create("identifier2"))) + .merge(CelUnknownSet.create(CelAttribute.create("identifier3")))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("identifier"), + CelAttribute.create("identifier2"), + CelAttribute.create("identifier3")))); + + assertThat( + CelUnknownSet.union( + CelUnknownSet.create(CelAttribute.create("identifier")), + CelUnknownSet.create(CelAttribute.create("identifier2")))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("identifier"), CelAttribute.create("identifier2")))); + } + + @Test + public void unknownSet_maintainsSetSemantics() { + assertThat(CelUnknownSet.create(CelAttribute.create("identifier"))) + .isEqualTo(CelUnknownSet.create(ImmutableSet.of(CelAttribute.create("identifier")))); + + assertThat( + CelUnknownSet.create(CelAttribute.create("identifier")) + .merge( + CelUnknownSet.create( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofString("field1")))) + .merge( + CelUnknownSet.create( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofString("field2"))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("identifier"), + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofString("field1")), + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofString("field2"))))); + + assertThat( + CelUnknownSet.create(CelAttribute.create("identifier")) + .merge( + CelUnknownSet.create( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofString("field1")))) + .merge( + CelUnknownSet.create( + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofString("field1"))))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("identifier"), + CelAttribute.create("identifier") + .qualify(CelAttribute.Qualifier.ofString("field1"))))); + + assertThat( + CelUnknownSet.union( + CelUnknownSet.create(CelAttribute.create("identifier")), + CelUnknownSet.create(CelAttribute.create("identifier2")))) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("identifier"), CelAttribute.create("identifier2")))); + + assertThat( + CelUnknownSet.union( + CelUnknownSet.create(CelAttribute.create("identifier")), + CelUnknownSet.create(CelAttribute.create("identifier")))) + .isEqualTo(CelUnknownSet.create(ImmutableSet.of(CelAttribute.create("identifier")))); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/CelVariableResolverTest.java b/runtime/src/test/java/dev/cel/runtime/CelVariableResolverTest.java new file mode 100644 index 000000000..3d2515ad3 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/CelVariableResolverTest.java @@ -0,0 +1,62 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; +import static dev.cel.runtime.CelVariableResolver.hierarchicalVariableResolver; + +import com.google.common.collect.ImmutableMap; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelVariableResolverTest { + + @Test + public void hierarchicalVariableResolvers_findsValueInPrimary() { + ImmutableMap primary = ImmutableMap.of("revision", "a_prime"); + ImmutableMap secondary = ImmutableMap.of("revision", "a"); + CelVariableResolver resolver = + hierarchicalVariableResolver( + (name) -> Optional.ofNullable(primary.get(name)), + (name) -> Optional.ofNullable(secondary.get(name))); + assertThat(resolver.find("revision")).hasValue("a_prime"); + } + + @Test + public void hierarchicalVariableResolvers_findsValueInSecondary() { + ImmutableMap primary = ImmutableMap.of("current", "descendant"); + ImmutableMap secondary = ImmutableMap.of("previous", "ancestor"); + CelVariableResolver resolver = + hierarchicalVariableResolver( + (name) -> Optional.ofNullable(primary.get(name)), + (name) -> Optional.ofNullable(secondary.get(name))); + assertThat(resolver.find("previous")).hasValue("ancestor"); + assertThat(resolver.find("current")).hasValue("descendant"); + } + + @Test + public void hierarchicalVariableResolvers_notFound() { + ImmutableMap primary = ImmutableMap.of(); + ImmutableMap secondary = ImmutableMap.of(); + CelVariableResolver resolver = + hierarchicalVariableResolver( + (name) -> Optional.ofNullable(primary.get(name)), + (name) -> Optional.ofNullable(secondary.get(name))); + assertThat(resolver.find("anything")).isEmpty(); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/DefaultDispatcherTest.java b/runtime/src/test/java/dev/cel/runtime/DefaultDispatcherTest.java new file mode 100644 index 000000000..d862ddb33 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/DefaultDispatcherTest.java @@ -0,0 +1,68 @@ +// Copyright 2024 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 static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import java.util.HashMap; +import java.util.Map; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** Tests for {@link DefaultDispatcher}. */ +@RunWith(JUnit4.class) +public final class DefaultDispatcherTest { + + private Map overloads; + + @Before + public void setup() { + overloads = new HashMap<>(); + overloads.put( + "overload_1", + CelResolvedOverload.of( + /* functionName= */ "overload_1", + /* overloadId= */ "overload_1", + args -> (Long) args[0] + 1, + /* isStrict= */ true, + Long.class)); + overloads.put( + "overload_2", + CelResolvedOverload.of( + /* functionName= */ "overload_2", + /* overloadId= */ "overload_2", + args -> (Long) args[0] + 2, + /* isStrict= */ true, + Long.class)); + } + + @Test + public void findOverload_multipleMatches_throwsException() { + CelEvaluationException e = + Assert.assertThrows( + CelEvaluationException.class, + () -> + DefaultDispatcher.findOverloadMatchingArgs( + "overloads", + ImmutableList.of("overload_1", "overload_2"), + overloads, + new Object[] {1L})); + assertThat(e).hasMessageThat().contains("Matching candidates: overload_1, overload_2"); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/DefaultInterpreterTest.java b/runtime/src/test/java/dev/cel/runtime/DefaultInterpreterTest.java new file mode 100644 index 000000000..a23e3b2fb --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/DefaultInterpreterTest.java @@ -0,0 +1,114 @@ +// Copyright 2025 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 static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.types.SimpleType; +import dev.cel.common.values.CelValueConverter; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.DefaultInterpreter.DefaultInterpretable; +import dev.cel.runtime.DefaultInterpreter.ExecutionFrame; +import dev.cel.runtime.standard.NotStrictlyFalseFunction.NotStrictlyFalseOverload; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** + * Exercises tests for the internals of the {@link DefaultInterpreter}. Tests should only be added + * here if we absolutely must add coverage for internal state of the interpreter that's otherwise + * impossible with the CEL public APIs. + */ +@RunWith(TestParameterInjector.class) +public class DefaultInterpreterTest { + + @Test + public void nestedComprehensions_accuVarContainsErrors_scopeLevelInvariantNotViolated() + throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + CelFunctionDecl.newFunctionDeclaration( + "error", CelOverloadDecl.newGlobalOverload("error_overload", SimpleType.DYN))) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .build(); + RuntimeTypeProvider emptyProvider = + new RuntimeTypeProvider() { + @Override + public Object createMessage(String messageName, Map values) { + return null; + } + + @Override + public Object selectField(Object message, String fieldName) { + return null; + } + + @Override + public Object hasField(Object message, String fieldName) { + return null; + } + + @Override + public Object adapt(String messageName, Object message) { + return message; + } + }; + CelAbstractSyntaxTree ast = celCompiler.compile("[1].all(x, [2].all(y, error()))").getAst(); + DefaultDispatcher.Builder dispatcherBuilder = DefaultDispatcher.newBuilder(); + dispatcherBuilder.addOverload( + /* functionName= */ "error", + /* overloadId= */ "error_overload", + ImmutableList.>of(long.class), + /* isStrict= */ true, + (args) -> new IllegalArgumentException("Always throws")); + CelFunctionBinding notStrictlyFalseBinding = + NotStrictlyFalseOverload.NOT_STRICTLY_FALSE.newFunctionBinding( + CelOptions.DEFAULT, + RuntimeEquality.create(RuntimeHelpers.create(), CelOptions.DEFAULT)); + String functionName = notStrictlyFalseBinding.getOverloadId(); + if (notStrictlyFalseBinding instanceof InternalCelFunctionBinding) { + functionName = ((InternalCelFunctionBinding) notStrictlyFalseBinding).getFunctionName(); + } + dispatcherBuilder.addOverload( + functionName, + notStrictlyFalseBinding.getOverloadId(), + notStrictlyFalseBinding.getArgTypes(), + notStrictlyFalseBinding.isStrict(), + notStrictlyFalseBinding.getDefinition()); + DefaultInterpreter defaultInterpreter = + new DefaultInterpreter( + TypeResolver.create(CelValueConverter.getDefaultInstance()), + emptyProvider, + dispatcherBuilder.build(), + CelOptions.DEFAULT); + DefaultInterpretable interpretable = + (DefaultInterpretable) defaultInterpreter.createInterpretable(ast); + + ExecutionFrame frame = interpretable.newTestExecutionFrame(GlobalResolver.EMPTY); + + assertThrows(CelEvaluationException.class, () -> interpretable.populateExecutionFrame(frame)); + assertThat(frame.scopeLevel).isEqualTo(0); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/DescriptorMessageProviderTest.java b/runtime/src/test/java/dev/cel/runtime/DescriptorMessageProviderTest.java new file mode 100644 index 000000000..02c8f2b51 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/DescriptorMessageProviderTest.java @@ -0,0 +1,255 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Any; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.Message; +import com.google.protobuf.NullValue; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import dev.cel.common.CelErrorCode; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelRuntimeException; +import dev.cel.common.internal.CelDescriptorPool; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.DefaultMessageFactory; +// CEL-Internal-1 +import dev.cel.common.internal.ProtoMessageFactory; +import dev.cel.common.internal.WellKnownProto; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import dev.cel.expr.conformance.proto2.TestAllTypes.NestedGroup; +import dev.cel.expr.conformance.proto2.TestAllTypesExtensions; +import dev.cel.expr.conformance.proto2.TestAllTypesProto; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class DescriptorMessageProviderTest { + + private RuntimeTypeProvider provider; + + @Before + public void setUp() { + CelOptions options = CelOptions.current().build(); + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor().getFile()); + ProtoMessageFactory dynamicMessageFactory = + DefaultMessageFactory.create(DefaultDescriptorPool.create(celDescriptors)); + provider = new DescriptorMessageProvider(dynamicMessageFactory, options); + } + + @Test + public void createMessage_success() { + dev.cel.expr.conformance.proto3.TestAllTypes message = + (dev.cel.expr.conformance.proto3.TestAllTypes) + provider.createMessage( + dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor().getFullName(), + ImmutableMap.of("single_int32", 1)); + assertThat(message) + .isEqualTo( + dev.cel.expr.conformance.proto3.TestAllTypes.newBuilder().setSingleInt32(1).build()); + } + + @Test + public void createMessageDynamic_success() { + ImmutableList descriptors = + ImmutableList.of(dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor()); + provider = DynamicMessageFactory.typeProvider(descriptors); + Message message = + (Message) + provider.createMessage( + dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor().getFullName(), + ImmutableMap.of("single_int32", 1)); + assertThat(message).isInstanceOf(dev.cel.expr.conformance.proto3.TestAllTypes.class); + assertThat(message) + .isEqualTo( + dev.cel.expr.conformance.proto3.TestAllTypes.newBuilder().setSingleInt32(1).build()); + } + + @Test + public void createNestedGroup_success() throws Exception { + String groupType = "cel.expr.conformance.proto2.TestAllTypes.NestedGroup"; + provider = + DynamicMessageFactory.typeProvider( + ImmutableList.of(TestAllTypes.NestedGroup.getDescriptor())); + Message message = + (Message) + provider.createMessage( + groupType, ImmutableMap.of("single_id", 1, "single_name", "cert")); + assertThat(message).isInstanceOf(NestedGroup.class); + assertThat(message) + .isEqualTo(NestedGroup.newBuilder().setSingleId(1).setSingleName("cert").build()); + } + + @Test + public void createMessage_missingDescriptorError() { + CelRuntimeException e = + Assert.assertThrows( + CelRuntimeException.class, + () -> + provider.createMessage( + "google.api.tools.contract.test.MissingMessageTypes", ImmutableMap.of())); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.ATTRIBUTE_NOT_FOUND); + assertThat(e).hasCauseThat().isNull(); + } + + @Test + public void createMessage_unsetWrapperField() { + dev.cel.expr.conformance.proto3.TestAllTypes message = + (dev.cel.expr.conformance.proto3.TestAllTypes) + provider.createMessage( + dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor().getFullName(), + ImmutableMap.of( + "single_int64_wrapper", dev.cel.common.values.NullValue.NULL_VALUE)); + assertThat(message).isEqualToDefaultInstance(); + } + + @Test + public void createMessage_badFieldError() { + Assert.assertThrows( + IllegalArgumentException.class, + () -> + provider.createMessage( + dev.cel.expr.conformance.proto3.TestAllTypes.getDescriptor().getFullName(), + ImmutableMap.of("bad_field", dev.cel.common.values.NullValue.NULL_VALUE))); + } + + @Test + public void hasField_mapKeyFound() { + assertThat(provider.hasField(ImmutableMap.of("hello", "world"), "hello")).isEqualTo(true); + } + + @Test + public void hasField_mapKeyNotFound() { + assertThat(provider.hasField(ImmutableMap.of(), "hello")).isEqualTo(false); + } + + @Test + public void selectField_mapKeyFound() { + assertThat(provider.selectField(ImmutableMap.of("hello", "world"), "hello")).isEqualTo("world"); + } + + @Test + public void selectField_mapKeyNotFound() { + CelRuntimeException e = + Assert.assertThrows( + CelRuntimeException.class, () -> provider.selectField(ImmutableMap.of(), "hello")); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.ATTRIBUTE_NOT_FOUND); + assertThat(e).hasCauseThat().isNull(); + } + + @Test + public void selectField_unsetWrapperField() { + assertThat( + provider.selectField( + dev.cel.expr.conformance.proto3.TestAllTypes.getDefaultInstance(), + "single_int64_wrapper")) + .isEqualTo(NullValue.NULL_VALUE); + } + + @Test + public void selectField_nonProtoObjectError() { + CelRuntimeException e = + Assert.assertThrows( + CelRuntimeException.class, () -> provider.selectField("hello", "not_a_field")); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.ATTRIBUTE_NOT_FOUND); + assertThat(e).hasCauseThat().isNull(); + } + + @Test + public void selectField_extensionUsingDynamicTypes() { + CelDescriptors celDescriptors = + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + ImmutableList.of(TestAllTypesExtensions.getDescriptor())); + CelDescriptorPool pool = DefaultDescriptorPool.create(celDescriptors); + + provider = + new DescriptorMessageProvider( + DefaultMessageFactory.create(pool), CelOptions.current().build()); + + long result = + (long) + provider.selectField( + TestAllTypes.newBuilder().setExtension(TestAllTypesExtensions.int32Ext, 10).build(), + TestAllTypesProto.getDescriptor().getPackage() + ".int32_ext"); + + assertThat(result).isEqualTo(10); + } + + @Test + public void createMessage_wellKnownType_withCustomMessageProvider( + @TestParameter WellKnownProto wellKnownProto) { + if (wellKnownProto.equals(WellKnownProto.ANY_VALUE)) { + return; + } + + Descriptor wellKnownDescriptor = + DefaultDescriptorPool.INSTANCE.findDescriptor(wellKnownProto.typeName()).get(); + DescriptorMessageProvider messageProvider = + new DescriptorMessageProvider( + msgName -> + msgName.equals(wellKnownDescriptor.getFullName()) + ? DynamicMessage.newBuilder(wellKnownDescriptor) + : null); + + Object createdMessage = + messageProvider.createMessage(wellKnownDescriptor.getFullName(), ImmutableMap.of()); + + assertThat(createdMessage).isNotNull(); + } + + @Test + public void createMessage_anyType_withCustomMessageProvider() { + DescriptorMessageProvider messageProvider = + new DescriptorMessageProvider( + msgName -> msgName.equals(Any.getDescriptor().getFullName()) ? Any.newBuilder() : null); + + double createdMessage = + (double) + messageProvider.createMessage( + Any.getDescriptor().getFullName(), + ImmutableMap.of("type_url", "types.googleapis.com/google.protobuf.DoubleValue")); + + assertThat(createdMessage).isEqualTo(0.0d); + } + + @Test + public void createMessage_doubleValue_withCustomMessageProvider() { + DescriptorMessageProvider messageProvider = + new DescriptorMessageProvider( + msgName -> + msgName.equals("google.protobuf.DoubleValue") + ? DynamicMessage.newBuilder(DoubleValue.getDescriptor()) + : null); + + double value = + (double) messageProvider.createMessage("google.protobuf.DoubleValue", ImmutableMap.of()); + + assertThat(value).isEqualTo(0.0d); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/DescriptorTypeResolverTest.java b/runtime/src/test/java/dev/cel/runtime/DescriptorTypeResolverTest.java new file mode 100644 index 000000000..bdd865601 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/DescriptorTypeResolverTest.java @@ -0,0 +1,169 @@ +// Copyright 2024 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 static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +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.CelContainer; +import dev.cel.common.types.OpaqueType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.types.TypeType; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelOptionalLibrary; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class DescriptorTypeResolverTest { + + private static final ProtoMessageTypeProvider PROTO_MESSAGE_TYPE_PROVIDER = + new ProtoMessageTypeProvider(ImmutableList.of(TestAllTypes.getDescriptor())); + + private static final Cel CEL = + CelFactory.standardCelBuilder() + .setTypeProvider(PROTO_MESSAGE_TYPE_PROVIDER) + .addCompilerLibraries(CelOptionalLibrary.INSTANCE) + .addRuntimeLibraries(CelOptionalLibrary.INSTANCE) + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFullName())) + .build(); + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum TypeLiteralTestCase { + BOOL("bool", TypeType.create(SimpleType.BOOL)), + BYTES("bytes", TypeType.create(SimpleType.BYTES)), + DOUBLE("double", TypeType.create(SimpleType.DOUBLE)), + DURATION("google.protobuf.Duration", TypeType.create(SimpleType.DURATION)), + INT("int", TypeType.create(SimpleType.INT)), + STRING("string", TypeType.create(SimpleType.STRING)), + TIMESTAMP("google.protobuf.Timestamp", TypeType.create(SimpleType.TIMESTAMP)), + UINT("uint", TypeType.create(SimpleType.UINT)), + + NULL_TYPE("null_type", TypeType.create(SimpleType.NULL_TYPE)), + OPTIONAL_TYPE("optional_type", TypeType.create(OptionalType.create(SimpleType.DYN))), + PROTO_MESSAGE_TYPE( + "TestAllTypes", + TypeType.create(StructTypeReference.create(TestAllTypes.getDescriptor().getFullName()))); + + private final String expression; + + private final TypeType celRuntimeType; + + TypeLiteralTestCase(String expression, TypeType celRuntimeType) { + this.expression = expression; + this.celRuntimeType = celRuntimeType; + } + } + + @Test + public void typeLiteral_success(@TestParameter TypeLiteralTestCase testCase) throws Exception { + if (!testCase.equals(TypeLiteralTestCase.DURATION)) { + return; + } + CelAbstractSyntaxTree ast = CEL.compile(testCase.expression).getAst(); + + assertThat(CEL.createProgram(ast).eval()).isEqualTo(testCase.celRuntimeType); + } + + @Test + public void typeLiteral_wrappedInDyn_success(@TestParameter TypeLiteralTestCase testCase) + throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(String.format("dyn(%s)", testCase.expression)).getAst(); + + assertThat(CEL.createProgram(ast).eval()).isEqualTo(testCase.celRuntimeType); + } + + @Test + public void typeLiteral_equality(@TestParameter TypeLiteralTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = + CEL.compile(String.format("type(%s) == type", testCase.expression)).getAst(); + + assertThat(CEL.createProgram(ast).eval()).isEqualTo(true); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum TypeCallTestCase { + ANY( + "google.protobuf.Any{type_url: 'types.googleapis.com/google.protobuf.DoubleValue'}", + TypeType.create(SimpleType.DOUBLE)), + BOOL("true", TypeType.create(SimpleType.BOOL)), + BYTES("b'hi'", TypeType.create(SimpleType.BYTES)), + DOUBLE("1.5", TypeType.create(SimpleType.DOUBLE)), + DURATION("duration('1h')", TypeType.create(SimpleType.DURATION)), + INT("1", TypeType.create(SimpleType.INT)), + STRING("'test'", TypeType.create(SimpleType.STRING)), + TIMESTAMP("timestamp(123)", TypeType.create(SimpleType.TIMESTAMP)), + UINT("1u", TypeType.create(SimpleType.UINT)), + PROTO_MESSAGE( + "TestAllTypes{}", + TypeType.create(StructTypeReference.create(TestAllTypes.getDescriptor().getFullName()))), + OPTIONAL_TYPE("optional.of(1)", TypeType.create(OptionalType.create(SimpleType.DYN))); + + private final String expression; + + private final TypeType celRuntimeType; + + TypeCallTestCase(String expression, TypeType celRuntimeType) { + this.expression = expression; + this.celRuntimeType = celRuntimeType; + } + } + + @Test + public void typeCall_success(@TestParameter TypeCallTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = + CEL.compile(String.format("type(%s)", testCase.expression)).getAst(); + + assertThat(CEL.createProgram(ast).eval()).isEqualTo(testCase.celRuntimeType); + } + + @Test + public void typeOfTypeCall_success(@TestParameter TypeCallTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = + CEL.compile(String.format("type(type(%s))", testCase.expression)).getAst(); + + assertThat(CEL.createProgram(ast).eval()).isEqualTo(TypeType.create(SimpleType.DYN)); + } + + @Test + public void typeCall_wrappedInDyn_evaluatesToUnderlyingType( + @TestParameter TypeCallTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = + CEL.compile(String.format("type(dyn(%s))", testCase.expression)).getAst(); + + assertThat(CEL.createProgram(ast).eval()).isEqualTo(testCase.celRuntimeType); + } + + @Test + public void typeCall_opaqueVar() throws Exception { + OpaqueType opaqueType = OpaqueType.create("opaque_type"); + Cel cel = CEL.toCelBuilder().addVar("opaque_var", opaqueType).build(); + CelAbstractSyntaxTree ast = cel.compile("type(opaque_var)").getAst(); + final class CustomClass {} + + assertThat(CEL.createProgram(ast).eval(ImmutableMap.of("opaque_var", new CustomClass()))) + .isEqualTo(TypeType.create(opaqueType)); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/InterpreterTest.java b/runtime/src/test/java/dev/cel/runtime/InterpreterTest.java new file mode 100644 index 000000000..a6342c6e4 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/InterpreterTest.java @@ -0,0 +1,25 @@ +// Copyright 2022 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.testing.junit.testparameterinjector.TestParameterInjector; +// import com.google.testing.testsize.MediumTest; +import dev.cel.testing.BaseInterpreterTest; +import org.junit.runner.RunWith; + +/** Tests for {@link Interpreter} and related functionality. */ +// @MediumTest +@RunWith(TestParameterInjector.class) +public class InterpreterTest extends BaseInterpreterTest {} diff --git a/runtime/src/test/java/dev/cel/runtime/MessageFactoryTest.java b/runtime/src/test/java/dev/cel/runtime/MessageFactoryTest.java new file mode 100644 index 000000000..bead31569 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/MessageFactoryTest.java @@ -0,0 +1,44 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.protobuf.Message; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.runtime.MessageFactory.CombinedMessageFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class MessageFactoryTest { + + @Test + public void combinedFactory_producesSameMessage() { + MessageFactory dynamicMessageFactory = + DynamicMessageFactory.typeFactory(ImmutableList.of(TestAllTypes.getDescriptor())); + CombinedMessageFactory combinedMessageFactory = + new MessageFactory.CombinedMessageFactory(ImmutableList.of(dynamicMessageFactory)); + + Message message1 = + dynamicMessageFactory.newBuilder(TestAllTypes.getDescriptor().getFullName()).build(); + Message message2 = + combinedMessageFactory.newBuilder(TestAllTypes.getDescriptor().getFullName()).build(); + + assertThat(message1).isEqualTo(message2); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/PlannerInterpreterTest.java b/runtime/src/test/java/dev/cel/runtime/PlannerInterpreterTest.java new file mode 100644 index 000000000..9ae8590d5 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/PlannerInterpreterTest.java @@ -0,0 +1,331 @@ +// 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.common.collect.ImmutableMap; +import com.google.protobuf.Timestamp; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationException; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.ListType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.extensions.CelExtensions; +import dev.cel.testing.BaseInterpreterTest; +import java.util.Arrays; +import java.util.Objects; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** Interpreter tests using ProgramPlanner */ +@RunWith(TestParameterInjector.class) +public class PlannerInterpreterTest extends BaseInterpreterTest { + + @TestParameter boolean isParseOnly; + + @Override + protected CelRuntimeBuilder newBaseRuntimeBuilder(CelOptions celOptions) { + return CelRuntimeFactory.plannerRuntimeBuilder() + .addLateBoundFunctions("record") + .setOptions(celOptions) + .addLibraries(CelExtensions.optional()) + .addFileTypes(TEST_FILE_DESCRIPTORS) + .addMessageTypes(TestAllTypes.getDescriptor()); + } + + @Override + protected void setContainer(CelContainer container) { + super.setContainer(container); + this.celRuntime = this.celRuntime.toRuntimeBuilder().setContainer(container).build(); + } + + @Override + protected CelAbstractSyntaxTree prepareTest(CelTypeProvider typeProvider) { + super.prepareCompiler(typeProvider); + + CelAbstractSyntaxTree ast; + try { + ast = celCompiler.parse(source, testSourceDescription()).getAst(); + } catch (CelValidationException e) { + printTestValidationError(e); + return null; + } + + if (isParseOnly) { + return ast; + } + + try { + return celCompiler.check(ast).getAst(); + } catch (CelValidationException e) { + printTestValidationError(e); + return null; + } + } + + @Override + public void optional_errors() { + // Exercised in planner_optional_errors instead + skipBaselineVerification(); + } + + @Test + public void planner_optional_errors() { + source = "optional.unwrap([dyn(1)])"; + runTest(ImmutableMap.of()); + } + + @Override + public void unknownField() { + // Exercised in planner_unknownFieldAccess instead + skipBaselineVerification(); + } + + @Override + public void unknownResultSet() { + // Exercised in planner_unknownResultSet_success instead + skipBaselineVerification(); + } + + @Test + public void planner_unknownFieldSelection() { + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + + CelAttributePattern patternX = CelAttributePattern.fromQualifiedIdentifier("x"); + + source = "x"; + // We have the full message, but we're claiming that the attribute is unknown. + runTest(ImmutableMap.of("x", TestAllTypes.getDefaultInstance()), patternX); + // A "partially known message". The result is still an unknown. + runTest( + ImmutableMap.of("x", TestAllTypes.getDefaultInstance()), + CelAttributePattern.fromQualifiedIdentifier("x.single_int32")); + + source = "x.single_int32"; + runTest(ImmutableMap.of(), patternX); + runTest(ImmutableMap.of(), CelAttributePattern.fromQualifiedIdentifier("x.single_int32")); + + source = "x.map_int32_int64[22]"; + runTest(ImmutableMap.of(), patternX); + runTest(ImmutableMap.of(), CelAttributePattern.fromQualifiedIdentifier("x.map_int32_int64")); + + source = "x.repeated_nested_message[1]"; + runTest(ImmutableMap.of(), patternX); + runTest( + ImmutableMap.of(), + CelAttributePattern.fromQualifiedIdentifier("x.repeated_nested_message")); + + source = "x.single_nested_message.bb"; + runTest(ImmutableMap.of(), patternX); + runTest( + ImmutableMap.of(), + CelAttributePattern.fromQualifiedIdentifier("x.single_nested_message.bb")); + + source = "{1: x.single_int32}"; + runTest(ImmutableMap.of(), patternX); + runTest(ImmutableMap.of(), CelAttributePattern.fromQualifiedIdentifier("x.single_int32")); + + source = "[1, x.single_int32]"; + runTest(ImmutableMap.of(), patternX); + runTest(ImmutableMap.of(), CelAttributePattern.fromQualifiedIdentifier("x.single_int32")); + } + + @Test + public void planner_unknownResultSet_success() { + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + TestAllTypes message = + TestAllTypes.newBuilder() + .setSingleString("test") + .setSingleTimestamp(Timestamp.newBuilder().setSeconds(15)) + .build(); + ImmutableMap variables = ImmutableMap.of("x", message); + CelAttributePattern unknownInt32 = + CelAttributePattern.fromQualifiedIdentifier("x.single_int32"); + CelAttributePattern unknownInt64 = + CelAttributePattern.fromQualifiedIdentifier("x.single_int64"); + + source = "x.single_int32 == 1 && true"; + runTest(variables, unknownInt32); + + source = "x.single_int32 == 1 && false"; + runTest(variables, unknownInt32); + + source = "x.single_int32 == 1 && x.single_int64 == 1"; + runTest(variables, unknownInt32, unknownInt64); + + source = "true && x.single_int32 == 1"; + runTest(variables, unknownInt32); + + source = "false && x.single_int32 == 1"; + runTest(variables, unknownInt32); + + source = "x.single_int32 == 1 || x.single_string == \"test\""; + runTest(variables, unknownInt32); + + source = "x.single_int32 == 1 || x.single_string != \"test\""; + runTest(variables, unknownInt32); + + source = "x.single_int32 == 1 || x.single_int64 == 1"; + runTest(variables, unknownInt32, unknownInt64); + + source = "true || x.single_int32 == 1"; + runTest(variables, unknownInt32); + + source = "false || x.single_int32 == 1"; + runTest(variables, unknownInt32); + + // dispatch test + declareFunction( + "f", memberOverload("f", Arrays.asList(SimpleType.INT, SimpleType.INT), SimpleType.BOOL)); + celRuntime = + newBaseRuntimeBuilder( + CelOptions.current() + .enableHeterogeneousNumericComparisons(true) + .enableOptionalSyntax(true) + .comprehensionMaxIterations(1_000) + .build()) + .addFunctionBindings( + CelFunctionBinding.from("f", Integer.class, Integer.class, Objects::equals)) + .setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())) + .build(); + + source = "x.single_int32.f(1)"; + runTest(variables, unknownInt32); + + source = "1.f(x.single_int32)"; + runTest(variables, unknownInt32); + + source = "x.single_int64.f(x.single_int32)"; + runTest(variables, unknownInt32, unknownInt64); + + source = "[0, 2, 4].exists(z, z == 2 || z == x.single_int32)"; + runTest(variables, unknownInt32); + + source = "[0, 2, 4].exists(z, z == x.single_int32)"; + runTest(variables, unknownInt32); + + source = + "[0, 2, 4].exists_one(z, z == 0 || (z == 2 && z == x.single_int32) " + + "|| (z == 4 && z == x.single_int64))"; + runTest(variables, unknownInt32, unknownInt64); + + source = "[0, 2].all(z, z == 2 || z == x.single_int32)"; + runTest(variables, unknownInt32); + + source = + "[0, 2, 4].filter(z, z == 0 || (z == 2 && z == x.single_int32) " + + "|| (z == 4 && z == x.single_int64))"; + runTest(variables, unknownInt32, unknownInt64); + + source = + "[0, 2, 4].map(z, z == 0 || (z == 2 && z == x.single_int32) " + + "|| (z == 4 && z == x.single_int64))"; + runTest(variables, unknownInt32, unknownInt64); + + source = "x.single_int32 == 1 ? 1 : 2"; + runTest(variables, unknownInt32); + + source = "true ? x.single_int32 : 2"; + runTest(variables, unknownInt32); + + source = "true ? 1 : x.single_int32"; + runTest(variables, unknownInt32); + + source = "false ? x.single_int32 : 2"; + runTest(variables, unknownInt32); + + source = "false ? 1 : x.single_int32"; + runTest(variables, unknownInt32); + + source = "x.single_int64 == 1 ? x.single_int32 : x.single_int32"; + runTest(variables, unknownInt32, unknownInt64); + + source = "{x.single_int32: 2, 3: 4}"; + runTest(variables, unknownInt32); + + source = "{1: x.single_int32, 3: 4}"; + runTest(variables, unknownInt32); + + source = "{1: x.single_int32, x.single_int64: 4}"; + runTest(variables, unknownInt32, unknownInt64); + + source = "[1, x.single_int32, 3, 4]"; + runTest(variables, unknownInt32); + + source = "[1, x.single_int32, x.single_int64, 4]"; + runTest(variables, unknownInt32, unknownInt64); + + source = "TestAllTypes{single_int32: x.single_int32}.single_int32 == 2"; + runTest(variables, unknownInt32); + + source = "TestAllTypes{single_int32: x.single_int32, single_int64: x.single_int64}"; + runTest(variables, unknownInt32, unknownInt64); + + clearAllDeclarations(); + declareVariable("unknown_list", ListType.create(SimpleType.INT)); + source = "unknown_list.map(x, x)"; + runTest(variables, CelAttributePattern.fromQualifiedIdentifier("unknown_list")); + + clearAllDeclarations(); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + source = "cel.bind(x, [1, 2, 3], 1 in x)"; + runTest(variables, CelAttributePattern.fromQualifiedIdentifier("x")); + } + + @Test + public void planner_unknownResultSet_errors() { + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + TestAllTypes message = + TestAllTypes.newBuilder() + .setSingleString("test") + .setSingleTimestamp(Timestamp.newBuilder().setSeconds(15)) + .build(); + ImmutableMap variables = ImmutableMap.of("x", message); + CelAttributePattern unknownInt32 = + CelAttributePattern.fromQualifiedIdentifier("x.single_int32"); + + source = "x.single_int32 == 1 && x.single_timestamp <= timestamp(\"bad timestamp string\")"; + runTest(variables, unknownInt32); + + source = "x.single_timestamp <= timestamp(\"bad timestamp string\") && x.single_int32 == 1"; + runTest(variables, unknownInt32); + + source = + "x.single_timestamp <= timestamp(\"bad timestamp string\") " + + "&& x.single_timestamp > timestamp(\"another bad timestamp string\")"; + runTest(variables, unknownInt32); + + source = "x.single_int32 == 1 || x.single_timestamp <= timestamp(\"bad timestamp string\")"; + runTest(variables, unknownInt32); + + source = "x.single_timestamp <= timestamp(\"bad timestamp string\") || x.single_int32 == 1"; + runTest(variables, unknownInt32); + + source = + "x.single_timestamp <= timestamp(\"bad timestamp string\") " + + "|| x.single_timestamp > timestamp(\"another bad timestamp string\")"; + runTest(variables, unknownInt32); + + source = "x"; + runTest(ImmutableMap.of(), CelAttributePattern.fromQualifiedIdentifier("x")); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/ProtoMessageRuntimeEqualityTest.java b/runtime/src/test/java/dev/cel/runtime/ProtoMessageRuntimeEqualityTest.java new file mode 100644 index 000000000..dc4607e5f --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/ProtoMessageRuntimeEqualityTest.java @@ -0,0 +1,691 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.NullValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import com.google.rpc.context.AttributeContext; +import com.google.rpc.context.AttributeContext.Auth; +import com.google.rpc.context.AttributeContext.Peer; +import com.google.rpc.context.AttributeContext.Request; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelRuntimeException; +import dev.cel.common.internal.AdaptingTypes; +import dev.cel.common.internal.BidiConverter; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.values.CelByteString; +import java.util.Arrays; +import java.util.List; +import org.jspecify.annotations.Nullable; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +public final class ProtoMessageRuntimeEqualityTest { + private static final CelOptions EMPTY_OPTIONS = + CelOptions.newBuilder().disableCelStandardEquality(false).build(); + private static final CelOptions PROTO_EQUALITY = + CelOptions.newBuilder() + .disableCelStandardEquality(false) + .enableProtoDifferencerEquality(true) + .build(); + private static final DynamicProto DYNAMIC_PROTO = + DynamicProto.create( + DefaultMessageFactory.create( + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + AttributeContext.getDescriptor().getFile())))); + + private static final ProtoMessageRuntimeEquality RUNTIME_EQUALITY_LEGACY_OPTIONS = + ProtoMessageRuntimeEquality.create(DYNAMIC_PROTO, CelOptions.LEGACY); + + private static final ProtoMessageRuntimeEquality RUNTIME_EQUALITY_DEFAULT_OPTIONS = + ProtoMessageRuntimeEquality.create(DYNAMIC_PROTO, CelOptions.DEFAULT); + + private static final ProtoMessageRuntimeEquality RUNTIME_EQUALITY_EMPTY_OPTIONS = + ProtoMessageRuntimeEquality.create(DYNAMIC_PROTO, EMPTY_OPTIONS); + + private static final ProtoMessageRuntimeEquality RUNTIME_EQUALITY_PROTO_EQUALITY = + ProtoMessageRuntimeEquality.create(DYNAMIC_PROTO, PROTO_EQUALITY); + + @Test + public void inMap() throws Exception { + ImmutableMap map = ImmutableMap.of("key", "value", "key2", "value2"); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(map, "key2")).isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(map, "key3")).isFalse(); + + ImmutableMap mixedKeyMap = + ImmutableMap.of( + "key", "value", 2L, "value2", UnsignedLong.valueOf(42), "answer to everything"); + // Integer tests. + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, 2)).isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, 3)).isFalse(); + + // Long tests. + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, -1L)).isFalse(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, 3L)).isFalse(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, 2L)).isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, 42L)).isTrue(); + + // Floating point tests + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, -1.0d)).isFalse(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, 2.1d)).isFalse(); + assertThat( + RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, UnsignedLong.MAX_VALUE.doubleValue())) + .isFalse(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, 2.0d)).isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, Double.NaN)).isFalse(); + + // Unsigned long tests. + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, UnsignedLong.valueOf(1L))) + .isFalse(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, UnsignedLong.valueOf(2L))) + .isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, UnsignedLong.MAX_VALUE)).isFalse(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inMap(mixedKeyMap, UInt64Value.of(2L))).isTrue(); + + // Validate the legacy behavior as well. + assertThat(RUNTIME_EQUALITY_LEGACY_OPTIONS.inMap(mixedKeyMap, 2)).isFalse(); + assertThat(RUNTIME_EQUALITY_LEGACY_OPTIONS.inMap(mixedKeyMap, 2L)).isTrue(); + assertThat(RUNTIME_EQUALITY_LEGACY_OPTIONS.inMap(mixedKeyMap, Int64Value.of(2L))).isFalse(); + assertThat(RUNTIME_EQUALITY_LEGACY_OPTIONS.inMap(mixedKeyMap, UInt64Value.of(2L))).isFalse(); + } + + @Test + public void inList() throws Exception { + ImmutableList list = ImmutableList.of("value", "value2"); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(list, "value")).isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(list, "value3")).isFalse(); + + ImmutableList mixedValueList = ImmutableList.of(1, "value", 2, "value2"); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(mixedValueList, 2)).isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(mixedValueList, 3)).isFalse(); + + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(mixedValueList, 2L)).isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(mixedValueList, 3L)).isFalse(); + + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(mixedValueList, 2.0)).isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(mixedValueList, Double.NaN)).isFalse(); + + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(mixedValueList, UnsignedLong.valueOf(2L))) + .isTrue(); + assertThat(RUNTIME_EQUALITY_EMPTY_OPTIONS.inList(mixedValueList, UnsignedLong.valueOf(3L))) + .isFalse(); + + // Validate the legacy behavior as well. + assertThat(RUNTIME_EQUALITY_LEGACY_OPTIONS.inList(mixedValueList, 2)).isTrue(); + assertThat(RUNTIME_EQUALITY_LEGACY_OPTIONS.inList(mixedValueList, 2L)).isFalse(); + } + + @Test + public void indexMap() throws Exception { + ImmutableMap mixedKeyMap = + ImmutableMap.of(1L, "value", UnsignedLong.valueOf(2L), "value2"); + assertThat(RUNTIME_EQUALITY_DEFAULT_OPTIONS.indexMap(mixedKeyMap, 1.0)).isEqualTo("value"); + assertThat(RUNTIME_EQUALITY_DEFAULT_OPTIONS.indexMap(mixedKeyMap, 2.0)).isEqualTo("value2"); + Assert.assertThrows( + CelRuntimeException.class, + () -> RUNTIME_EQUALITY_LEGACY_OPTIONS.indexMap(mixedKeyMap, 1.0)); + Assert.assertThrows( + CelRuntimeException.class, + () -> RUNTIME_EQUALITY_DEFAULT_OPTIONS.indexMap(mixedKeyMap, 1.1)); + } + + @AutoValue + abstract static class State { + /** + * Expected comparison outcome when equality is performed with the given options. + * + *

The {@code null} value indicates that the outcome is an error. + */ + public abstract @Nullable Boolean outcome(); + + /** Runtime equality instance to use when performing the equality check. */ + public abstract ProtoMessageRuntimeEquality runtimeEquality(); + + public static State create( + @Nullable Boolean outcome, ProtoMessageRuntimeEquality runtimeEquality) { + return new AutoValue_ProtoMessageRuntimeEqualityTest_State(outcome, runtimeEquality); + } + } + + /** Represents expected result states for an equality test case. */ + @AutoValue + abstract static class Result { + + /** The result {@code State} value associated with different feature flag combinations. */ + public abstract ImmutableSet states(); + + /** + * Creates a Result for a comparison that is undefined (throws an Exception) under both equality + * modes. + */ + public static Result undefined() { + return always(null); + } + + /** Creates a Result for a comparison that is false under both equality modes. */ + public static Result alwaysFalse() { + return always(false); + } + + /** Creates a Result for a comparison that is true under both equality modes. */ + public static Result alwaysTrue() { + return always(true); + } + + public static Result unsigned(Boolean outcome) { + return Result.builder() + .states( + ImmutableList.of( + State.create(outcome, RUNTIME_EQUALITY_EMPTY_OPTIONS), + State.create(outcome, RUNTIME_EQUALITY_PROTO_EQUALITY))) + .build(); + } + + private static Result always(@Nullable Boolean outcome) { + return Result.builder() + .states( + ImmutableList.of( + State.create(outcome, RUNTIME_EQUALITY_EMPTY_OPTIONS), + State.create(outcome, RUNTIME_EQUALITY_PROTO_EQUALITY))) + .build(); + } + + private static Result proto(Boolean equalsOutcome, Boolean diffOutcome) { + return Result.builder() + .states( + ImmutableList.of( + State.create(equalsOutcome, RUNTIME_EQUALITY_EMPTY_OPTIONS), + State.create(diffOutcome, RUNTIME_EQUALITY_PROTO_EQUALITY))) + .build(); + } + + public static Builder builder() { + return new AutoValue_ProtoMessageRuntimeEqualityTest_Result.Builder(); + } + + @AutoValue.Builder + public abstract static class Builder { + abstract Builder states(ImmutableList states); + + abstract Result build(); + } + } + + @Parameter(0) + public Object lhs; + + @Parameter(1) + public Object rhs; + + @Parameter(2) + public Result result; + + @Parameters + public static List data() { + return Arrays.asList( + new Object[][] { + // Boolean tests. + {true, true, Result.alwaysTrue()}, + {BoolValue.of(true), true, Result.alwaysTrue()}, + {Any.pack(BoolValue.of(true)), true, Result.alwaysTrue()}, + {Value.newBuilder().setBoolValue(true).build(), true, Result.alwaysTrue()}, + {true, false, Result.alwaysFalse()}, + {0, false, Result.alwaysFalse()}, + + // Bytes tests. + {ByteString.copyFromUtf8("h’"), ByteString.copyFromUtf8("h’"), Result.alwaysTrue()}, + {ByteString.copyFromUtf8("hello"), ByteString.EMPTY, Result.alwaysFalse()}, + {BytesValue.of(ByteString.EMPTY), CelByteString.EMPTY, Result.alwaysTrue()}, + { + BytesValue.of(ByteString.copyFromUtf8("h’")), + CelByteString.copyFromUtf8("h’"), + Result.alwaysTrue() + }, + {Any.pack(BytesValue.of(ByteString.EMPTY)), CelByteString.EMPTY, Result.alwaysTrue()}, + {"h’", CelByteString.copyFromUtf8("h’"), Result.alwaysFalse()}, + + // Double tests. + {1.0, 1.0, Result.alwaysTrue()}, + {Double.valueOf(1.0), 1.0, Result.alwaysTrue()}, + {DoubleValue.of(42.5), 42.5, Result.alwaysTrue()}, + // Floats are unwrapped to double types. + {FloatValue.of(1.0f), 1.0, Result.alwaysTrue()}, + {Value.newBuilder().setNumberValue(-1.5D).build(), -1.5, Result.alwaysTrue()}, + {1.0, -1.0, Result.alwaysFalse()}, + {1.0, 1.0D, Result.alwaysTrue()}, + {1.0, 1.1D, Result.alwaysFalse()}, + {1.0D, 1.1f, Result.alwaysFalse()}, + {1.0, 1, Result.alwaysTrue()}, + + // Float tests. + {1.0f, 1.0f, Result.alwaysTrue()}, + {Float.valueOf(1.0f), 1.0f, Result.alwaysTrue()}, + {1.0f, -1.0f, Result.alwaysFalse()}, + {1.0f, 1.0, Result.alwaysTrue()}, + + // Integer tests. + {16, 16, Result.alwaysTrue()}, + {17, 16, Result.alwaysFalse()}, + {17, 16.0, Result.alwaysFalse()}, + + // Long tests. + {-15L, -15L, Result.alwaysTrue()}, + // Int32 values are unwrapped to int types. + {Int32Value.of(-15), -15L, Result.alwaysTrue()}, + {Int64Value.of(-15L), -15L, Result.alwaysTrue()}, + {Any.pack(Int32Value.of(-15)), -15L, Result.alwaysTrue()}, + {Any.pack(Int64Value.of(-15L)), -15L, Result.alwaysTrue()}, + {-15L, -16L, Result.alwaysFalse()}, + {-15L, -15, Result.alwaysTrue()}, + {-15L, 15.0, Result.alwaysFalse()}, + + // Null tests. + {null, null, Result.alwaysTrue()}, + {false, null, Result.alwaysFalse()}, + {0.0, null, Result.alwaysFalse()}, + {0, null, Result.alwaysFalse()}, + {null, "null", Result.alwaysFalse()}, + {"null", null, Result.alwaysFalse()}, + {null, NullValue.NULL_VALUE, Result.alwaysTrue()}, + {null, ImmutableList.of(), Result.alwaysFalse()}, + {ImmutableMap.of(), null, Result.alwaysFalse()}, + {ByteString.copyFromUtf8(""), null, Result.alwaysFalse()}, + {null, ProtoTimeUtils.TIMESTAMP_EPOCH, Result.alwaysFalse()}, + {ProtoTimeUtils.DURATION_ZERO, null, Result.alwaysFalse()}, + {NullValue.NULL_VALUE, NullValue.NULL_VALUE, Result.alwaysTrue()}, + { + Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build(), + NullValue.NULL_VALUE, + Result.alwaysTrue() + }, + { + Any.pack(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build()), + NullValue.NULL_VALUE, + Result.alwaysTrue() + }, + + // String tests. + {"", "", Result.alwaysTrue()}, + {"str", "str", Result.alwaysTrue()}, + {StringValue.of("str"), "str", Result.alwaysTrue()}, + {Value.newBuilder().setStringValue("str").build(), "str", Result.alwaysTrue()}, + {Any.pack(StringValue.of("str")), "str", Result.alwaysTrue()}, + {Any.pack(Value.newBuilder().setStringValue("str").build()), "str", Result.alwaysTrue()}, + {"", "non-empty", Result.alwaysFalse()}, + + // Uint tests. + {UInt32Value.of(1234), 1234L, Result.alwaysTrue()}, + {UInt64Value.of(1234L), 1234L, Result.alwaysTrue()}, + {UInt64Value.of(1234L), Int64Value.of(1234L), Result.alwaysTrue()}, + {UInt32Value.of(1234), UnsignedLong.valueOf(1234L), Result.alwaysTrue()}, + {UInt64Value.of(1234L), UnsignedLong.valueOf(1234L), Result.alwaysTrue()}, + {Any.pack(UInt64Value.of(1234L)), UnsignedLong.valueOf(1234L), Result.alwaysTrue()}, + {UInt32Value.of(123), UnsignedLong.valueOf(1234L), Result.alwaysFalse()}, + {UInt64Value.of(123L), UnsignedLong.valueOf(1234L), Result.alwaysFalse()}, + {Any.pack(UInt64Value.of(123L)), UnsignedLong.valueOf(1234L), Result.alwaysFalse()}, + + // Cross-type equality tests. + {UInt32Value.of(1234), 1234.0, Result.alwaysTrue()}, + {UInt32Value.of(1234), 1234.0, Result.alwaysTrue()}, + {UInt64Value.of(1234L), 1234L, Result.alwaysTrue()}, + {UInt32Value.of(1234), 1234.1, Result.alwaysFalse()}, + {UInt64Value.of(1234L), 1233L, Result.alwaysFalse()}, + {UnsignedLong.valueOf(1234L), 1234L, Result.alwaysTrue()}, + {UnsignedLong.valueOf(1234L), 1234.1, Result.alwaysFalse()}, + {1234L, 1233.2, Result.alwaysFalse()}, + {-1234L, UnsignedLong.valueOf(1233L), Result.alwaysFalse()}, + + // List tests. + // Note, this list equality behaves equivalently to the following expression: + // 1.0 == 1.0 && "dos" == 2.0 && 3.0 == 4.0 + // The middle predicate is an error; however, the last comparison yields false and so + + // the error is short-circuited away. + {Arrays.asList(1.0, "dos", 3.0), Arrays.asList(1.0, 2.0, 4.0), Result.alwaysFalse()}, + {Arrays.asList("1", 2), ImmutableList.of("1", 2), Result.alwaysTrue()}, + {Arrays.asList("1", 2), ImmutableSet.of("1", 2), Result.alwaysTrue()}, + {Arrays.asList(1.0, 2.0, 3.0), Arrays.asList(1.0, 2.0), Result.alwaysFalse()}, + {Arrays.asList(1.0, 3.0), Arrays.asList(1.0, 2.0), Result.alwaysFalse()}, + { + AdaptingTypes.adaptingList( + ImmutableList.of(1, 2, 3), + BidiConverter.of( + ProtoMessageRuntimeHelpers.INT32_TO_INT64, + ProtoMessageRuntimeHelpers.INT64_TO_INT32)), + Arrays.asList(1L, 2L, 3L), + Result.alwaysTrue() + }, + { + ListValue.newBuilder() + .addValues(Value.newBuilder().setStringValue("hello")) + .addValues(Value.newBuilder().setStringValue("world")) + .build(), + ImmutableList.of("hello", "world"), + Result.alwaysTrue() + }, + { + ListValue.newBuilder() + .addValues(Value.newBuilder().setStringValue("hello")) + .addValues(Value.newBuilder().setListValue(ListValue.getDefaultInstance())) + .build(), + ImmutableList.of("hello", "world"), + Result.alwaysFalse() + }, + { + ListValue.newBuilder() + .addValues(Value.newBuilder().setListValue(ListValue.getDefaultInstance())) + .addValues( + Value.newBuilder() + .setListValue( + ListValue.newBuilder() + .addValues(Value.newBuilder().setBoolValue(true)))) + .build(), + ImmutableList.of(ImmutableList.of(), ImmutableList.of(true)), + Result.alwaysTrue() + }, + { + Value.newBuilder() + .setListValue( + ListValue.newBuilder() + .addValues(Value.newBuilder().setNumberValue(-1.5)) + .addValues(Value.newBuilder().setNumberValue(42.25))) + .build(), + AdaptingTypes.adaptingList( + ImmutableList.of(-1.5f, 42.25f), + BidiConverter.of( + ProtoMessageRuntimeHelpers.FLOAT_TO_DOUBLE, + ProtoMessageRuntimeHelpers.DOUBLE_TO_FLOAT)), + Result.alwaysTrue() + }, + + // Map tests. + {ImmutableMap.of("one", 1), ImmutableMap.of("one", "uno"), Result.alwaysFalse()}, + {ImmutableMap.of("two", 2), ImmutableMap.of("two", 3), Result.alwaysFalse()}, + {ImmutableMap.of("one", 2), ImmutableMap.of("two", 3), Result.alwaysFalse()}, + // Note, this map is the composition of the following two tests above where: + // ("one", 1) == ("one", "uno") -> error + // ("two", 2) == ("two", 3) -> false + // Within CEL error && false -> false, and the key order in the test has specifically + // been chosen to exercise this behavior. + { + ImmutableMap.of("one", 1, "two", 2), + ImmutableMap.of("one", "uno", "two", 3), + Result.alwaysFalse() + }, + {ImmutableMap.of("key", "value"), ImmutableMap.of("key", "value"), Result.alwaysTrue()}, + {ImmutableMap.of(), ImmutableMap.of("key", "value"), Result.alwaysFalse()}, + {ImmutableMap.of("key", "value"), ImmutableMap.of("key", "diff"), Result.alwaysFalse()}, + {ImmutableMap.of("key", 42), ImmutableMap.of("key", 42L), Result.alwaysTrue()}, + {ImmutableMap.of("key", 42.0), ImmutableMap.of("key", 42L), Result.alwaysTrue()}, + { + AdaptingTypes.adaptingMap( + ImmutableMap.of("key1", 42, "key2", 31, "key3", 20), + BidiConverter.identity(), + BidiConverter.of( + ProtoMessageRuntimeHelpers.INT32_TO_INT64, + ProtoMessageRuntimeHelpers.INT64_TO_INT32)), + ImmutableMap.of("key1", 42L, "key2", 31L, "key3", 20L), + Result.alwaysTrue() + }, + { + AdaptingTypes.adaptingMap( + ImmutableMap.of(1, 42.5f, 2, 31f, 3, 20.25f), + BidiConverter.of( + ProtoMessageRuntimeHelpers.INT32_TO_INT64, + ProtoMessageRuntimeHelpers.INT64_TO_INT32), + BidiConverter.of( + ProtoMessageRuntimeHelpers.FLOAT_TO_DOUBLE, + ProtoMessageRuntimeHelpers.DOUBLE_TO_FLOAT)), + ImmutableMap.of(1L, 42.5D, 2L, 31D, 3L, 20.25D), + Result.alwaysTrue() + }, + { + AdaptingTypes.adaptingMap( + ImmutableMap.of("1", 42.5f, "2", 31f, "3", 20.25f), + BidiConverter.identity(), + BidiConverter.of( + ProtoMessageRuntimeHelpers.FLOAT_TO_DOUBLE, + ProtoMessageRuntimeHelpers.DOUBLE_TO_FLOAT)), + Struct.getDefaultInstance(), + Result.alwaysFalse() + }, + { + AdaptingTypes.adaptingMap( + ImmutableMap.of("1", 42.5f, "2", 31f, "3", 20.25f), + BidiConverter.identity(), + BidiConverter.of( + ProtoMessageRuntimeHelpers.FLOAT_TO_DOUBLE, + ProtoMessageRuntimeHelpers.DOUBLE_TO_FLOAT)), + Struct.newBuilder() + .putFields("1", Value.newBuilder().setNumberValue(42.5D).build()) + .putFields("2", Value.newBuilder().setNumberValue(31D).build()) + .putFields("3", Value.newBuilder().setNumberValue(20.25D).build()) + .build(), + Result.alwaysTrue() + }, + { + AdaptingTypes.adaptingMap( + ImmutableMap.of("1", 42.5f, "2", 31f, "3", 20.25f), + BidiConverter.identity(), + BidiConverter.of( + ProtoMessageRuntimeHelpers.FLOAT_TO_DOUBLE, + ProtoMessageRuntimeHelpers.DOUBLE_TO_FLOAT)), + Struct.newBuilder() + .putFields("1", Value.newBuilder().setNumberValue(42.5D).build()) + .putFields("2", Value.newBuilder().setNumberValue(31D).build()) + .putFields("3", Value.newBuilder().setStringValue("oops").build()) + .build(), + Result.alwaysFalse() + }, + + // Protobuf tests. + { + AttributeContext.newBuilder().setRequest(Request.getDefaultInstance()).build(), + AttributeContext.newBuilder().setRequest(Request.newBuilder().setHost("")).build(), + Result.alwaysTrue() + }, + { + AttributeContext.newBuilder() + .setRequest(Request.getDefaultInstance()) + .setOrigin(Peer.getDefaultInstance()) + .build(), + AttributeContext.newBuilder().setRequest(Request.getDefaultInstance()).build(), + Result.alwaysFalse() + }, + // Proto differencer unpacks any values. + { + AttributeContext.newBuilder() + .addExtensions( + Any.newBuilder() + .setTypeUrl("type.googleapis.com/google.rpc.context.AttributeContext") + .setValue(ByteString.copyFromUtf8("\032\000:\000")) + .build()) + .build(), + AttributeContext.newBuilder() + .addExtensions( + Any.newBuilder() + .setTypeUrl("type.googleapis.com/google.rpc.context.AttributeContext") + .setValue(ByteString.copyFromUtf8(":\000\032\000")) + .build()) + .build(), + Result.builder() + .states( + ImmutableList.of( + State.create(false, RUNTIME_EQUALITY_EMPTY_OPTIONS), + State.create(true, RUNTIME_EQUALITY_PROTO_EQUALITY))) + .build() + }, + // If type url is missing, fallback to bytes comparison for payload. + { + AttributeContext.newBuilder() + .addExtensions( + Any.newBuilder().setValue(ByteString.copyFromUtf8("\032\000:\000")).build()) + .build(), + AttributeContext.newBuilder() + .addExtensions( + Any.newBuilder().setValue(ByteString.copyFromUtf8(":\000\032\000")).build()) + .build(), + Result.alwaysFalse() + }, + { + AttributeContext.newBuilder() + .setRequest(Request.getDefaultInstance()) + .setOrigin(Peer.getDefaultInstance()) + .build(), + "test string", + Result.alwaysFalse() + }, + { + AttributeContext.newBuilder() + .setRequest(Request.getDefaultInstance()) + .setOrigin(Peer.getDefaultInstance()) + .build(), + null, + Result.alwaysFalse() + }, + { + AttributeContext.newBuilder() + .addExtensions( + Any.pack( + AttributeContext.newBuilder() + .setRequest(Request.getDefaultInstance()) + .setOrigin(Peer.getDefaultInstance()) + .build())) + .build(), + AttributeContext.newBuilder() + .addExtensions( + Any.pack( + AttributeContext.newBuilder() + .setRequest(Request.getDefaultInstance()) + .build())) + .build(), + Result.alwaysFalse() + }, + { + AttributeContext.getDefaultInstance(), + AttributeContext.newBuilder() + .setRequest(Request.newBuilder().setHost("localhost")) + .build(), + Result.alwaysFalse() + }, + // Differently typed messages aren't comparable. + {AttributeContext.getDefaultInstance(), Auth.getDefaultInstance(), Result.alwaysFalse()}, + // Message.equals() treats NaN values as equal. Message differencer treats NaN values + // as inequal (the same behavior as the C++ implementation). + { + AttributeContext.newBuilder() + .setRequest( + Request.newBuilder() + .setAuth( + Auth.newBuilder() + .setClaims( + Struct.newBuilder() + .putFields( + "custom", + Value.newBuilder() + .setNumberValue(Double.NaN) + .build())))) + .build(), + AttributeContext.newBuilder() + .setRequest( + Request.newBuilder() + .setAuth( + Auth.newBuilder() + .setClaims( + Struct.newBuilder() + .putFields( + "custom", + Value.newBuilder() + .setNumberValue(Double.NaN) + .build())))) + .build(), + Result.proto(/* equalsOutcome= */ true, /* diffOutcome= */ false), + }, + + // Note: this is the motivating use case for converting to heterogeneous equality in + // the future. + { + AttributeContext.newBuilder() + .setRequest( + Request.newBuilder() + .setAuth( + Auth.newBuilder() + .setClaims( + Struct.newBuilder() + .putFields( + "custom", + Value.newBuilder().setNumberValue(123.0).build())))) + .build(), + AttributeContext.newBuilder() + .setRequest( + Request.newBuilder() + .setAuth( + Auth.newBuilder() + .setClaims( + Struct.newBuilder() + .putFields( + "custom", + Value.newBuilder().setBoolValue(true).build())))) + .build(), + Result.alwaysFalse(), + }, + }); + } + + @Test + public void objectEquals() throws Exception { + for (State state : result.states()) { + if (state.outcome() == null) { + Assert.assertThrows( + CelRuntimeException.class, () -> state.runtimeEquality().objectEquals(lhs, rhs)); + Assert.assertThrows( + CelRuntimeException.class, () -> state.runtimeEquality().objectEquals(rhs, lhs)); + return; + } + assertThat(state.runtimeEquality().objectEquals(lhs, rhs)).isEqualTo(state.outcome()); + assertThat(state.runtimeEquality().objectEquals(rhs, lhs)).isEqualTo(state.outcome()); + } + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/ProtoMessageRuntimeHelpersTest.java b/runtime/src/test/java/dev/cel/runtime/ProtoMessageRuntimeHelpersTest.java new file mode 100644 index 000000000..45b050fd1 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/ProtoMessageRuntimeHelpersTest.java @@ -0,0 +1,426 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.Duration; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.NullValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import dev.cel.common.CelOptions; +import dev.cel.common.exceptions.CelNumericOverflowException; +import dev.cel.common.exceptions.CelRuntimeException; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.values.CelByteString; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class ProtoMessageRuntimeHelpersTest { + private static final DynamicProto DYNAMIC_PROTO = + DynamicProto.create(DefaultMessageFactory.INSTANCE); + private static final RuntimeHelpers RUNTIME_HELPER = + ProtoMessageRuntimeHelpers.create(DYNAMIC_PROTO, CelOptions.DEFAULT); + + @Test + public void createDurationFromString() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.createDurationFromString("15.11s")) + .isEqualTo(Duration.newBuilder().setSeconds(15).setNanos(110000000).build()); + } + + @Test + public void createDurationFromString_outOfRange() throws Exception { + assertThrows( + IllegalArgumentException.class, + () -> ProtoMessageRuntimeHelpers.createDurationFromString("-320000000000s")); + } + + @Test + public void int64Add() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.int64Add(1, 1, CelOptions.LEGACY)).isEqualTo(2); + assertThat(ProtoMessageRuntimeHelpers.int64Add(2, 2, CelOptions.DEFAULT)).isEqualTo(4); + assertThat(ProtoMessageRuntimeHelpers.int64Add(1, Long.MAX_VALUE, CelOptions.LEGACY)) + .isEqualTo(Long.MIN_VALUE); + assertThat(ProtoMessageRuntimeHelpers.int64Add(-1, Long.MIN_VALUE, CelOptions.LEGACY)) + .isEqualTo(Long.MAX_VALUE); + assertThrows( + ArithmeticException.class, + () -> ProtoMessageRuntimeHelpers.int64Add(1, Long.MAX_VALUE, CelOptions.DEFAULT)); + assertThrows( + ArithmeticException.class, + () -> ProtoMessageRuntimeHelpers.int64Add(-1, Long.MIN_VALUE, CelOptions.DEFAULT)); + } + + @Test + public void int64Divide() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.int64Divide(-44, 11, CelOptions.LEGACY)).isEqualTo(-4); + assertThat(ProtoMessageRuntimeHelpers.int64Divide(-44, 11, CelOptions.DEFAULT)).isEqualTo(-4); + assertThat(ProtoMessageRuntimeHelpers.int64Divide(Long.MIN_VALUE, -1, CelOptions.LEGACY)) + .isEqualTo(Long.MIN_VALUE); + assertThrows( + CelNumericOverflowException.class, + () -> ProtoMessageRuntimeHelpers.int64Divide(Long.MIN_VALUE, -1, CelOptions.DEFAULT)); + } + + @Test + public void int64Multiply() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.int64Multiply(2, 3, CelOptions.LEGACY)).isEqualTo(6); + assertThat(ProtoMessageRuntimeHelpers.int64Multiply(2, 3, CelOptions.DEFAULT)).isEqualTo(6); + assertThat(ProtoMessageRuntimeHelpers.int64Multiply(Long.MIN_VALUE, -1, CelOptions.LEGACY)) + .isEqualTo(Long.MIN_VALUE); + assertThrows( + ArithmeticException.class, + () -> ProtoMessageRuntimeHelpers.int64Multiply(Long.MIN_VALUE, -1, CelOptions.DEFAULT)); + } + + @Test + public void int64Negate() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.int64Negate(7, CelOptions.LEGACY)).isEqualTo(-7); + assertThat(ProtoMessageRuntimeHelpers.int64Negate(7, CelOptions.DEFAULT)).isEqualTo(-7); + assertThat(ProtoMessageRuntimeHelpers.int64Negate(Long.MIN_VALUE, CelOptions.LEGACY)) + .isEqualTo(Long.MIN_VALUE); + assertThrows( + ArithmeticException.class, + () -> ProtoMessageRuntimeHelpers.int64Negate(Long.MIN_VALUE, CelOptions.DEFAULT)); + } + + @Test + public void int64Subtract() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.int64Subtract(50, 100, CelOptions.LEGACY)).isEqualTo(-50); + assertThat(ProtoMessageRuntimeHelpers.int64Subtract(50, 100, CelOptions.DEFAULT)) + .isEqualTo(-50); + assertThat(ProtoMessageRuntimeHelpers.int64Subtract(Long.MIN_VALUE, 1, CelOptions.LEGACY)) + .isEqualTo(Long.MAX_VALUE); + assertThat(ProtoMessageRuntimeHelpers.int64Subtract(Long.MAX_VALUE, -1, CelOptions.LEGACY)) + .isEqualTo(Long.MIN_VALUE); + assertThrows( + ArithmeticException.class, + () -> ProtoMessageRuntimeHelpers.int64Subtract(Long.MIN_VALUE, 1, CelOptions.DEFAULT)); + assertThrows( + ArithmeticException.class, + () -> ProtoMessageRuntimeHelpers.int64Subtract(Long.MAX_VALUE, -1, CelOptions.DEFAULT)); + } + + @Test + public void uint64CompareTo_unsignedLongs() { + assertThat(ProtoMessageRuntimeHelpers.uint64CompareTo(UnsignedLong.ONE, UnsignedLong.ZERO)) + .isEqualTo(1); + assertThat(ProtoMessageRuntimeHelpers.uint64CompareTo(UnsignedLong.ZERO, UnsignedLong.ONE)) + .isEqualTo(-1); + assertThat(ProtoMessageRuntimeHelpers.uint64CompareTo(UnsignedLong.ONE, UnsignedLong.ONE)) + .isEqualTo(0); + assertThat( + ProtoMessageRuntimeHelpers.uint64CompareTo( + UnsignedLong.valueOf(Long.MAX_VALUE), UnsignedLong.MAX_VALUE)) + .isEqualTo(-1); + } + + @Test + public void uint64CompareTo_throwsWhenNegativeOrGreaterThanSignedLongMax() throws Exception { + assertThrows( + IllegalArgumentException.class, () -> ProtoMessageRuntimeHelpers.uint64CompareTo(-1, 0)); + assertThrows( + IllegalArgumentException.class, () -> ProtoMessageRuntimeHelpers.uint64CompareTo(0, -1)); + } + + @Test + public void uint64CompareTo_unsignedComparisonAndArithmeticIsUnsigned() throws Exception { + // In twos complement, -1 is represented by all bits being set. This is equivalent to the + // maximum value when unsigned. + assertThat(ProtoMessageRuntimeHelpers.uint64CompareTo(-1, 0, CelOptions.DEFAULT)) + .isGreaterThan(0); + assertThat(ProtoMessageRuntimeHelpers.uint64CompareTo(0, -1, CelOptions.DEFAULT)).isLessThan(0); + } + + @Test + public void uint64Add_signedLongs() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.uint64Add(4, 4, CelOptions.LEGACY)).isEqualTo(8); + assertThat(ProtoMessageRuntimeHelpers.uint64Add(4, 4, CelOptions.DEFAULT)).isEqualTo(8); + assertThat(ProtoMessageRuntimeHelpers.uint64Add(-1, 1, CelOptions.LEGACY)).isEqualTo(0); + assertThrows( + CelNumericOverflowException.class, + () -> ProtoMessageRuntimeHelpers.uint64Add(-1, 1, CelOptions.DEFAULT)); + } + + @Test + public void uint64Add_unsignedLongs() throws Exception { + assertThat( + ProtoMessageRuntimeHelpers.uint64Add(UnsignedLong.valueOf(4), UnsignedLong.valueOf(4))) + .isEqualTo(UnsignedLong.valueOf(8)); + assertThat( + ProtoMessageRuntimeHelpers.uint64Add( + UnsignedLong.MAX_VALUE.minus(UnsignedLong.ONE), UnsignedLong.ONE)) + .isEqualTo(UnsignedLong.MAX_VALUE); + assertThrows( + CelNumericOverflowException.class, + () -> ProtoMessageRuntimeHelpers.uint64Add(UnsignedLong.MAX_VALUE, UnsignedLong.ONE)); + } + + @Test + public void uint64Multiply_signedLongs() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.uint64Multiply(32, 2, CelOptions.LEGACY)).isEqualTo(64); + assertThat(ProtoMessageRuntimeHelpers.uint64Multiply(32, 2, CelOptions.DEFAULT)).isEqualTo(64); + assertThat( + ProtoMessageRuntimeHelpers.uint64Multiply( + Long.MIN_VALUE, + 2, + CelOptions.newBuilder() + .enableUnsignedComparisonAndArithmeticIsUnsigned(true) + .build())) + .isEqualTo(0); + assertThrows( + CelNumericOverflowException.class, + () -> ProtoMessageRuntimeHelpers.uint64Multiply(Long.MIN_VALUE, 2, CelOptions.DEFAULT)); + } + + @Test + public void uint64Multiply_unsignedLongs() throws Exception { + assertThat( + ProtoMessageRuntimeHelpers.uint64Multiply( + UnsignedLong.valueOf(32), UnsignedLong.valueOf(2))) + .isEqualTo(UnsignedLong.valueOf(64)); + assertThrows( + CelNumericOverflowException.class, + () -> + ProtoMessageRuntimeHelpers.uint64Multiply( + UnsignedLong.MAX_VALUE, UnsignedLong.valueOf(2))); + } + + @Test + public void uint64Multiply_throwsWhenNegativeOrGreaterThanSignedLongMax() throws Exception { + assertThrows( + IllegalArgumentException.class, () -> ProtoMessageRuntimeHelpers.uint64Multiply(-1, 0)); + assertThrows( + IllegalArgumentException.class, () -> ProtoMessageRuntimeHelpers.uint64Multiply(0, -1)); + } + + @Test + public void uint64Multiply_unsignedComparisonAndArithmeticIsUnsigned() throws Exception { + // In twos complement, -1 is represented by all bits being set. This is equivalent to the + // maximum value when unsigned. + assertThat(ProtoMessageRuntimeHelpers.uint64Multiply(-1, 0, CelOptions.DEFAULT)).isEqualTo(0); + assertThat(ProtoMessageRuntimeHelpers.uint64Multiply(0, -1, CelOptions.DEFAULT)).isEqualTo(0); + } + + @Test + public void uint64Divide_unsignedLongs() { + assertThat(ProtoMessageRuntimeHelpers.uint64Divide(UnsignedLong.ZERO, UnsignedLong.ONE)) + .isEqualTo(UnsignedLong.ZERO); + assertThat( + ProtoMessageRuntimeHelpers.uint64Divide(UnsignedLong.MAX_VALUE, UnsignedLong.MAX_VALUE)) + .isEqualTo(UnsignedLong.ONE); + assertThrows( + CelRuntimeException.class, + () -> ProtoMessageRuntimeHelpers.uint64Divide(UnsignedLong.MAX_VALUE, UnsignedLong.ZERO)); + } + + @Test + public void uint64Divide_throwsWhenNegativeOrGreaterThanSignedLongMax() throws Exception { + assertThrows( + IllegalArgumentException.class, () -> ProtoMessageRuntimeHelpers.uint64Divide(0, -1)); + assertThrows( + IllegalArgumentException.class, () -> ProtoMessageRuntimeHelpers.uint64Divide(-1, -1)); + } + + @Test + public void uint64Divide_unsignedComparisonAndArithmeticIsUnsigned() throws Exception { + // In twos complement, -1 is represented by all bits being set. This is equivalent to the + // maximum value when unsigned. + assertThat(ProtoMessageRuntimeHelpers.uint64Divide(0, -1, CelOptions.DEFAULT)).isEqualTo(0); + assertThat(ProtoMessageRuntimeHelpers.uint64Divide(-1, -1, CelOptions.DEFAULT)).isEqualTo(1); + } + + @Test + public void uint64Mod_unsignedLongs() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.uint64Mod(UnsignedLong.ONE, UnsignedLong.valueOf(2))) + .isEqualTo(UnsignedLong.ONE); + assertThat(ProtoMessageRuntimeHelpers.uint64Mod(UnsignedLong.ONE, UnsignedLong.ONE)) + .isEqualTo(UnsignedLong.ZERO); + assertThrows( + CelRuntimeException.class, + () -> ProtoMessageRuntimeHelpers.uint64Mod(UnsignedLong.ONE, UnsignedLong.ZERO)); + } + + @Test + public void uint64Mod_throwsWhenNegativeOrGreaterThanSignedLongMax() throws Exception { + assertThrows(IllegalArgumentException.class, () -> ProtoMessageRuntimeHelpers.uint64Mod(0, -1)); + assertThrows( + IllegalArgumentException.class, () -> ProtoMessageRuntimeHelpers.uint64Mod(-1, -1)); + } + + @Test + public void uint64Mod_unsignedComparisonAndArithmeticIsUnsigned() throws Exception { + // In twos complement, -1 is represented by all bits being set. This is equivalent to the + // maximum value when unsigned. + assertThat(ProtoMessageRuntimeHelpers.uint64Mod(0, -1, CelOptions.DEFAULT)).isEqualTo(0); + assertThat(ProtoMessageRuntimeHelpers.uint64Mod(-1, -1, CelOptions.DEFAULT)).isEqualTo(0); + } + + @Test + public void uint64Subtract_signedLongs() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.uint64Subtract(-1, 2, CelOptions.LEGACY)).isEqualTo(-3); + assertThat(ProtoMessageRuntimeHelpers.uint64Subtract(-1, 2, CelOptions.DEFAULT)).isEqualTo(-3); + assertThat(ProtoMessageRuntimeHelpers.uint64Subtract(0, 1, CelOptions.LEGACY)).isEqualTo(-1); + assertThrows( + CelNumericOverflowException.class, + () -> ProtoMessageRuntimeHelpers.uint64Subtract(0, 1, CelOptions.DEFAULT)); + assertThrows( + CelNumericOverflowException.class, + () -> ProtoMessageRuntimeHelpers.uint64Subtract(-3, -1, CelOptions.DEFAULT)); + assertThrows( + CelNumericOverflowException.class, + () -> ProtoMessageRuntimeHelpers.uint64Subtract(55, -40, CelOptions.DEFAULT)); + } + + @Test + public void uint64Subtract_unsignedLongs() throws Exception { + assertThat(ProtoMessageRuntimeHelpers.uint64Subtract(UnsignedLong.ONE, UnsignedLong.ONE)) + .isEqualTo(UnsignedLong.ZERO); + assertThat( + ProtoMessageRuntimeHelpers.uint64Subtract( + UnsignedLong.valueOf(3), UnsignedLong.valueOf(2))) + .isEqualTo(UnsignedLong.ONE); + assertThrows( + CelNumericOverflowException.class, + () -> ProtoMessageRuntimeHelpers.uint64Subtract(UnsignedLong.ONE, UnsignedLong.valueOf(2))); + } + + @Test + public void maybeAdaptPrimitive_optionalValues() { + // Optional values containing int/float are adapted into long/double + assertThat(RuntimeHelpers.maybeAdaptPrimitive(Optional.of(5))).isEqualTo(Optional.of(5L)); + assertThat(RuntimeHelpers.maybeAdaptPrimitive(Optional.of(5.5f))).isEqualTo(Optional.of(5.5d)); + // Optional values for the rest of the primitive types are not adapted + assertThat(RuntimeHelpers.maybeAdaptPrimitive(Optional.of(5L))).isEqualTo(Optional.of(5L)); + assertThat(RuntimeHelpers.maybeAdaptPrimitive(Optional.of(5.5d))).isEqualTo(Optional.of(5.5d)); + assertThat(RuntimeHelpers.maybeAdaptPrimitive(Optional.of(true))).isEqualTo(Optional.of(true)); + assertThat(RuntimeHelpers.maybeAdaptPrimitive(Optional.of(false))) + .isEqualTo(Optional.of(false)); + assertThat(RuntimeHelpers.maybeAdaptPrimitive(Optional.of("test"))) + .isEqualTo(Optional.of("test")); + assertThat(RuntimeHelpers.maybeAdaptPrimitive(Optional.of(UnsignedLong.valueOf(5)))) + .isEqualTo(Optional.of(UnsignedLong.valueOf(5))); + assertThat(RuntimeHelpers.maybeAdaptPrimitive(BytesValue.of(ByteString.copyFromUtf8("test")))) + .isEqualTo(BytesValue.of(ByteString.copyFromUtf8("test"))); + } + + @Test + public void adaptProtoToValue_wrapperValues() throws Exception { + assertThat(RUNTIME_HELPER.adaptProtoToValue(BoolValue.of(true))).isEqualTo(true); + assertThat(RUNTIME_HELPER.adaptProtoToValue(BytesValue.of(ByteString.EMPTY))) + .isEqualTo(CelByteString.EMPTY); + assertThat(RUNTIME_HELPER.adaptProtoToValue(DoubleValue.of(1.5d))).isEqualTo(1.5d); + assertThat(RUNTIME_HELPER.adaptProtoToValue(FloatValue.of(1.5f))).isEqualTo(1.5d); + assertThat(RUNTIME_HELPER.adaptProtoToValue(Int32Value.of(12))).isEqualTo(12L); + assertThat(RUNTIME_HELPER.adaptProtoToValue(Int64Value.of(-12L))).isEqualTo(-12L); + assertThat(RUNTIME_HELPER.adaptProtoToValue(UInt32Value.of(123))) + .isEqualTo(UnsignedLong.valueOf(123L)); + assertThat(RUNTIME_HELPER.adaptProtoToValue(UInt64Value.of(1234L))) + .isEqualTo(UnsignedLong.valueOf(1234L)); + assertThat(RUNTIME_HELPER.adaptProtoToValue(StringValue.of("hello"))).isEqualTo("hello"); + + assertThat(RUNTIME_HELPER.adaptProtoToValue(UInt32Value.of(123))) + .isEqualTo(UnsignedLong.valueOf(123L)); + assertThat(RUNTIME_HELPER.adaptProtoToValue(UInt64Value.of(1234L))) + .isEqualTo(UnsignedLong.valueOf(1234L)); + } + + @Test + public void adaptProtoToValue_jsonValues() throws Exception { + assertThat(RUNTIME_HELPER.adaptProtoToValue(Value.newBuilder().setStringValue("json").build())) + .isEqualTo("json"); + + assertThat( + RUNTIME_HELPER.adaptProtoToValue( + Value.newBuilder() + .setListValue( + ListValue.newBuilder() + .addValues(Value.newBuilder().setNumberValue(1.2d).build())) + .build())) + .isEqualTo(ImmutableList.of(1.2d)); + + Map mp = new HashMap<>(); + mp.put("list_value", ImmutableList.of(false, dev.cel.common.values.NullValue.NULL_VALUE)); + assertThat( + RUNTIME_HELPER.adaptProtoToValue( + Struct.newBuilder() + .putFields( + "list_value", + Value.newBuilder() + .setListValue( + ListValue.newBuilder() + .addValues(Value.newBuilder().setBoolValue(false)) + .addValues( + Value.newBuilder().setNullValue(NullValue.NULL_VALUE))) + .build()) + .build())) + .isEqualTo(mp); + } + + @Test + public void adaptProtoToValue_anyValues() throws Exception { + Map mp = new HashMap<>(); + Struct jsonValue = + Struct.newBuilder() + .putFields( + "list_value", + Value.newBuilder() + .setListValue( + ListValue.newBuilder() + .addValues(Value.newBuilder().setBoolValue(false)) + .addValues(Value.newBuilder().setNullValue(NullValue.NULL_VALUE))) + .build()) + .build(); + Any anyJsonValue = Any.pack(jsonValue); + mp.put("list_value", ImmutableList.of(false, dev.cel.common.values.NullValue.NULL_VALUE)); + assertThat(RUNTIME_HELPER.adaptProtoToValue(anyJsonValue)).isEqualTo(mp); + } + + @Test + public void adaptProtoToValue_builderValue() throws Exception { + assertThat(RUNTIME_HELPER.adaptProtoToValue(BoolValue.newBuilder().setValue(true))) + .isEqualTo(true); + } + + @Test + public void indexList() throws Exception { + ImmutableList list = ImmutableList.of("value", "value2"); + assertThat(RuntimeHelpers.indexList(list, 0.0)).isEqualTo("value"); + assertThat(RuntimeHelpers.indexList(list, UnsignedLong.valueOf(1L))).isEqualTo("value2"); + Assert.assertThrows(CelRuntimeException.class, () -> RuntimeHelpers.indexList(list, 1.1)); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/RuntimeEqualityTest.java b/runtime/src/test/java/dev/cel/runtime/RuntimeEqualityTest.java new file mode 100644 index 000000000..00e55873c --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/RuntimeEqualityTest.java @@ -0,0 +1,67 @@ +// Copyright 2025 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 static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.CelOptions; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class RuntimeEqualityTest { + + @Test + public void objectEquals_and_hashCode() { + RuntimeEquality runtimeEquality = + RuntimeEquality.create(RuntimeHelpers.create(), CelOptions.DEFAULT); + assertEqualityAndHashCode(runtimeEquality, 1, 1); + assertEqualityAndHashCode(runtimeEquality, 2, 2L); + assertEqualityAndHashCode(runtimeEquality, 3, 3.0); + assertEqualityAndHashCode(runtimeEquality, 4, UnsignedLong.valueOf(4)); + assertEqualityAndHashCode( + runtimeEquality, + ImmutableList.of(1, 2, 3), + ImmutableList.of(1.0, 2L, UnsignedLong.valueOf(3))); + assertEqualityAndHashCode( + runtimeEquality, + ImmutableMap.of("a", 1, "b", 2), + ImmutableMap.of("a", 1L, "b", UnsignedLong.valueOf(2))); + } + + private void assertEqualityAndHashCode(RuntimeEquality runtimeEquality, Object obj1, Object obj2) { + assertThat(runtimeEquality.objectEquals(obj1, obj2)).isTrue(); + assertThat(runtimeEquality.hashCode(obj1)).isEqualTo(runtimeEquality.hashCode(obj2)); + } + + @Test + public void objectEquals_messageLite_throws() { + RuntimeEquality runtimeEquality = + RuntimeEquality.create(RuntimeHelpers.create(), CelOptions.DEFAULT); + + // Unimplemented until CelLiteDescriptor is available. + assertThrows( + UnsupportedOperationException.class, + () -> + runtimeEquality.objectEquals( + TestAllTypes.newBuilder(), TestAllTypes.getDefaultInstance())); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/TypeResolverTest.java b/runtime/src/test/java/dev/cel/runtime/TypeResolverTest.java new file mode 100644 index 000000000..0437a31e5 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/TypeResolverTest.java @@ -0,0 +1,92 @@ +// Copyright 2025 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 static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.NullValue; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelValueConverter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class TypeResolverTest { + private static final TypeResolver TYPE_RESOLVER = + TypeResolver.create(CelValueConverter.getDefaultInstance()); + + @Test + public void resolveWellKnownObjectType_sentinelRuntimeType() { + Optional resolvedType = + TYPE_RESOLVER.resolveWellKnownObjectType(TypeType.create(SimpleType.INT)); + + assertThat(resolvedType).hasValue(TypeResolver.RUNTIME_TYPE_TYPE); + } + + @Test + public void resolveWellKnownObjectType_commonType( + @TestParameter WellKnownObjectTestCase testCase) { + Optional resolvedType = TYPE_RESOLVER.resolveWellKnownObjectType(testCase.obj); + + assertThat(resolvedType).hasValue(testCase.expectedTypeType); + } + + @Test + public void resolveWellKnownObjectType_unknownObjectType_returnsEmpty() { + Optional resolvedType = TYPE_RESOLVER.resolveWellKnownObjectType(new Object()); + + assertThat(resolvedType).isEmpty(); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum WellKnownObjectTestCase { + BOOLEAN(true, TypeType.create(SimpleType.BOOL)), + DOUBLE(1.0, TypeType.create(SimpleType.DOUBLE)), + LONG(1L, TypeType.create(SimpleType.INT)), + UNSIGNED_LONG(UnsignedLong.valueOf(1L), TypeType.create(SimpleType.UINT)), + STRING("test", TypeType.create(SimpleType.STRING)), + NULL(NullValue.NULL_VALUE, TypeType.create(SimpleType.NULL_TYPE)), + DURATION(ProtoTimeUtils.fromSecondsToDuration(1), TypeType.create(SimpleType.DURATION)), + TIMESTAMP(ProtoTimeUtils.fromSecondsToTimestamp(1), TypeType.create(SimpleType.TIMESTAMP)), + ARRAY_LIST(new ArrayList<>(), TypeType.create(ListType.create(SimpleType.DYN))), + IMMUTABLE_LIST(ImmutableList.of(), TypeType.create(ListType.create(SimpleType.DYN))), + HASH_MAP(new HashMap<>(), TypeType.create(MapType.create(SimpleType.DYN, SimpleType.DYN))), + IMMUTABLE_MAP( + ImmutableMap.of(), TypeType.create(MapType.create(SimpleType.DYN, SimpleType.DYN))), + OPTIONAL(Optional.empty(), TypeType.create(OptionalType.create(SimpleType.DYN))); + ; + + private final Object obj; + private final TypeType expectedTypeType; + + WellKnownObjectTestCase(Object obj, TypeType expectedTypeType) { + this.obj = obj; + this.expectedTypeType = expectedTypeType; + } + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/UnknownContextTest.java b/runtime/src/test/java/dev/cel/runtime/UnknownContextTest.java new file mode 100644 index 000000000..428fa6b26 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/UnknownContextTest.java @@ -0,0 +1,170 @@ +// Copyright 2022 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 static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class UnknownContextTest { + @Test + public void create_variableResolverOnly() { + UnknownContext context = + UnknownContext.create(name -> name.equals("test") ? "test_value" : null); + + CelAttributeResolver attributeResolver = context.createAttributeResolver(); + + assertThat(attributeResolver.resolve(CelAttribute.fromQualifiedIdentifier("test"))).isEmpty(); + assertThat(context.variableResolver().resolve("test")).isEqualTo("test_value"); + } + + @Test + public void create_attributeResolverResolvesUnknown() { + UnknownContext context = + UnknownContext.create( + unused -> Optional.empty(), + ImmutableList.of( + CelAttributePattern.fromQualifiedIdentifier("qualified.Identifier1"), + CelAttributePattern.fromQualifiedIdentifier("qualified.Identifier2.field1"))); + + CelAttributeResolver attributeResolver = context.createAttributeResolver(); + + assertThat( + attributeResolver.resolve( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier1"))) + .hasValue( + CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("qualified.Identifier1"))); + assertThat( + attributeResolver.resolve( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier2"))) + .isEmpty(); + assertThat( + attributeResolver.resolve( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier2.field1"))) + .hasValue( + CelUnknownSet.create( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier2.field1"))); + } + + @Test + public void create_attributeResolverIdentifiesPartials() { + UnknownContext context = + UnknownContext.create( + unused -> Optional.empty(), + ImmutableList.of( + CelAttributePattern.fromQualifiedIdentifier("qualified.Identifier1"), + CelAttributePattern.fromQualifiedIdentifier("qualified.Identifier2.field1"))); + + CelAttributeResolver attributeResolver = context.createAttributeResolver(); + + assertThat( + attributeResolver.maybePartialUnknown( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier1"))) + .hasValue( + CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("qualified.Identifier1"))); + assertThat( + attributeResolver.maybePartialUnknown( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier2"))) + .hasValue( + CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("qualified.Identifier2"))); + assertThat( + attributeResolver.maybePartialUnknown( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier2.field1"))) + .hasValue( + CelUnknownSet.create( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier2.field1"))); + } + + @Test + public void withResolvedAttributes_attributeResolverReturnsValue() { + UnknownContext context = + UnknownContext.create( + unused -> Optional.empty(), + ImmutableList.of( + CelAttributePattern.fromQualifiedIdentifier("qualified.Identifier1"), + CelAttributePattern.fromQualifiedIdentifier("qualified.Identifier2.field1"))); + + CelAttributeResolver attributeResolver = context.createAttributeResolver(); + + assertThat( + attributeResolver.maybePartialUnknown( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier1"))) + .hasValue( + CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("qualified.Identifier1"))); + assertThat( + attributeResolver.maybePartialUnknown( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier2"))) + .hasValue( + CelUnknownSet.create(CelAttribute.fromQualifiedIdentifier("qualified.Identifier2"))); + assertThat( + attributeResolver.maybePartialUnknown( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier2.field1"))) + .hasValue( + CelUnknownSet.create( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier2.field1"))); + } + + @Test + public void withResolvedAttributes_attributeResolverResolves() { + UnknownContext baseContext = + UnknownContext.create(unused -> Optional.empty(), ImmutableList.of()); + + UnknownContext context = + baseContext.withResolvedAttributes( + ImmutableMap.of( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier"), "value1")); + + CelAttributeResolver attributeResolver = context.createAttributeResolver(); + + assertThat( + attributeResolver.resolve(CelAttribute.fromQualifiedIdentifier("qualified.Identifier"))) + .hasValue("value1"); + } + + @Test + public void withResolvedAttributes_attributeResolverPartialsShadowed() { + UnknownContext baseContext = + UnknownContext.create( + unused -> Optional.empty(), + ImmutableList.of( + CelAttributePattern.fromQualifiedIdentifier("qualified.Identifier.field1"), + CelAttributePattern.fromQualifiedIdentifier("qualified.Identifier.field2"))); + + UnknownContext context = + baseContext.withResolvedAttributes( + ImmutableMap.of( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier"), "value1")); + + CelAttributeResolver attributeResolver = context.createAttributeResolver(); + + assertThat( + attributeResolver.resolve(CelAttribute.fromQualifiedIdentifier("qualified.Identifier"))) + .hasValue("value1"); + assertThat( + attributeResolver.maybePartialUnknown( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier.field1"))) + .isEmpty(); + assertThat( + attributeResolver.maybePartialUnknown( + CelAttribute.fromQualifiedIdentifier("qualified.Identifier.field2"))) + .isEmpty(); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/async/BUILD.bazel b/runtime/src/test/java/dev/cel/runtime/async/BUILD.bazel new file mode 100644 index 000000000..29f08eb74 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/async/BUILD.bazel @@ -0,0 +1,43 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = [ + "//:license", + ], +) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*Test.java"]), + deps = [ + "//bundle:cel", + "//common:cel_ast", + "//common:container", + "//common:options", + "//common/testing", + "//common/types", + # "//java/com/google/testing/testsize:annotations", + "//runtime", + "//runtime:unknown_attributes", + "//runtime:unknown_options", + "//runtime/async", + "@maven//:junit_junit", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "//:java_truth", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + ], +) + +junit4_test_suites( + name = "test_suites", + shard_count = 4, + sizes = [ + "medium", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/runtime/src/test/java/dev/cel/runtime/async/CelAsyncRuntimeImplTest.java b/runtime/src/test/java/dev/cel/runtime/async/CelAsyncRuntimeImplTest.java new file mode 100644 index 000000000..d24e99860 --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/async/CelAsyncRuntimeImplTest.java @@ -0,0 +1,526 @@ +// Copyright 2022 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.async; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.util.concurrent.MoreExecutors.newDirectExecutorService; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static java.util.concurrent.TimeUnit.SECONDS; +import static org.junit.Assert.assertThrows; + +import dev.cel.expr.Type; +import dev.cel.expr.Type.ListType; +import dev.cel.expr.Type.PrimitiveType; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.SettableFuture; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +// import com.google.testing.testsize.MediumTest; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.testing.RepeatedTestProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.runtime.CelAttributeParser; +import dev.cel.runtime.CelAttributePattern; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.async.CelAsyncRuntime.AsyncProgram; +import java.time.Duration; +import java.util.concurrent.CancellationException; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeoutException; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +// @MediumTest +public final class CelAsyncRuntimeImplTest { + + @Test + public void asyncProgram_basicUnknownResolution() throws Exception { + // Arrange + CelUnknownAttributeValueResolver resolveName = + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> { + Thread.sleep(500); + return attr.toString(); + }); + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("com.google.var1", SimpleType.STRING) + .addVar("com.google.var2", SimpleType.STRING) + .addVar("com.google.var3", SimpleType.STRING) + .setResultType(SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .build(); + + CelAsyncRuntime asyncRuntime = + CelAsyncRuntimeFactory.defaultAsyncRuntime() + .setRuntime(cel) + .setExecutorService(newDirectExecutorService()) + .build(); + + CelAbstractSyntaxTree ast = + cel.compile( + "var1 == 'com.google.var1' && " + + "var2 == 'com.google.var2' && " + + "var3 == 'com.google.var3'") + .getAst(); + + AsyncProgram program = asyncRuntime.createProgram(ast); + + // Act + ListenableFuture future = + program.evaluateToCompletion( + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var1"), resolveName), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var2"), resolveName), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var3"), resolveName)); + Object result = future.get(2, SECONDS); + + // Assert + assertThat(result).isInstanceOf(Boolean.class); + assertThat(result).isEqualTo(true); + } + + @Test + public void asyncProgram_sequentialUnknownResolution() throws Exception { + // Arrange + CelUnknownAttributeValueResolver resolveName = + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> { + Thread.sleep(500); + return attr.toString(); + }); + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("com.google.var1", SimpleType.BOOL) + .addVar("com.google.var2", SimpleType.STRING) + .addVar("com.google.var3", SimpleType.STRING) + .setResultType(SimpleType.STRING) + .setContainer(CelContainer.ofName("com.google")) + .build(); + + CelAsyncRuntime asyncRuntime = + CelAsyncRuntimeFactory.defaultAsyncRuntime() + .setRuntime(cel) + .setExecutorService(newDirectExecutorService()) + .build(); + + CelAbstractSyntaxTree ast = + cel.compile( + "var1 ? var2 : var3") + .getAst(); + + AsyncProgram program = asyncRuntime.createProgram(ast); + + // Act + ListenableFuture future = + program.evaluateToCompletion( + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var1"), + CelUnknownAttributeValueResolver.fromResolver(unused -> true)), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var2"), resolveName), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var3"), resolveName)); + Object result = future.get(2, SECONDS); + + // Assert + assertThat(result).isInstanceOf(String.class); + assertThat(result).isEqualTo("com.google.var2"); + } + + @Test + public void asyncProgram_basicAsyncResolver() throws Exception { + // Arrange + SettableFuture var1 = SettableFuture.create(); + SettableFuture var2 = SettableFuture.create(); + SettableFuture var3 = SettableFuture.create(); + + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("com.google.var1", SimpleType.STRING) + .addVar("com.google.var2", SimpleType.STRING) + .addVar("com.google.var3", SimpleType.STRING) + .setResultType(SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .build(); + + CelAsyncRuntime asyncRuntime = + CelAsyncRuntimeFactory.defaultAsyncRuntime() + .setRuntime(cel) + .setExecutorService(Executors.newSingleThreadExecutor()) + .build(); + + CelAbstractSyntaxTree ast = + cel.compile("var1 == 'first' && var2 == 'second' && var3 == 'third'").getAst(); + + AsyncProgram program = asyncRuntime.createProgram(ast); + + // Act + ListenableFuture future = + program.evaluateToCompletion( + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var1"), + CelUnknownAttributeValueResolver.fromAsyncResolver((attr) -> var1)), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var2"), + CelUnknownAttributeValueResolver.fromAsyncResolver((attr) -> var2)), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var3"), + CelUnknownAttributeValueResolver.fromAsyncResolver((attr) -> var3))); + assertThrows(TimeoutException.class, () -> future.get(1, SECONDS)); + var1.set("first"); + var2.set("second"); + var3.set("third"); + Object result = future.get(1, SECONDS); + + // Assert + assertThat(result).isInstanceOf(Boolean.class); + assertThat(result).isEqualTo(true); + } + + @Test + public void asyncProgram_honorsCancellation() throws Exception { + // Arrange + SettableFuture var1 = SettableFuture.create(); + SettableFuture var2 = SettableFuture.create(); + SettableFuture var3 = SettableFuture.create(); + + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("com.google.var1", SimpleType.STRING) + .addVar("com.google.var2", SimpleType.STRING) + .addVar("com.google.var3", SimpleType.STRING) + .setResultType(SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .build(); + + CelAsyncRuntime asyncRuntime = + CelAsyncRuntimeFactory.defaultAsyncRuntime() + .setRuntime(cel) + .setExecutorService(Executors.newSingleThreadExecutor()) + .build(); + + CelAbstractSyntaxTree ast = + cel.compile("var1 == 'first' && var2 == 'second' && var3 == 'third'").getAst(); + + AsyncProgram program = asyncRuntime.createProgram(ast); + + // Act + ListenableFuture future = + program.evaluateToCompletion( + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var1"), + CelUnknownAttributeValueResolver.fromAsyncResolver((attr) -> var1)), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var2"), + CelUnknownAttributeValueResolver.fromAsyncResolver((attr) -> var2)), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var3"), + CelUnknownAttributeValueResolver.fromAsyncResolver((attr) -> var3))); + var1.set("first"); + future.cancel(true); + assertThrows(CancellationException.class, () -> future.get(1, SECONDS)); + } + + /** Helper for defining test resolvers. */ + @FunctionalInterface + interface ResolverFactory { + CelUnknownAttributeValueResolver get(String id); + } + + @Test + public void asyncProgram_concurrency( + @TestParameter(valuesProvider = RepeatedTestProvider.class) int testRunIndex) + throws Exception { + Duration taskDelay = Duration.ofMillis(500); + // Arrange + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("com.google.var1", SimpleType.STRING) + .addVar("com.google.var2", SimpleType.STRING) + .addVar("com.google.var3", SimpleType.STRING) + .setResultType(SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .build(); + + ResolverFactory resolverFactory = + (String s) -> + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> { + Thread.sleep(taskDelay.toMillis()); + return s; + }); + + CelAsyncRuntime asyncRuntime = + CelAsyncRuntimeFactory.defaultAsyncRuntime() + .setRuntime(cel) + .setExecutorService(Executors.newFixedThreadPool(3)) + .build(); + + CelAbstractSyntaxTree ast = + cel.compile("var1 == 'first' && var2 == 'second' && var3 == 'third'").getAst(); + + AsyncProgram program = asyncRuntime.createProgram(ast); + + // Act + ListenableFuture future = + program.evaluateToCompletion( + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var1"), + resolverFactory.get("first")), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var2"), + resolverFactory.get("second")), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var3"), + resolverFactory.get("third"))); + + // Total wait is 2 times the worker delay. This is a little conservative for the size of the + // threadpool executor above, but should prevent flakes. + Object result = future.get(taskDelay.multipliedBy(2).toMillis(), MILLISECONDS); + assertThat(result).isInstanceOf(Boolean.class); + assertThat(result).isEqualTo(true); + } + + @Test + public void asyncProgram_elementResolver() throws Exception { + // Arrange + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar( + "com.google.listVar", + Type.newBuilder() + .setListType( + ListType.newBuilder() + .setElemType(Type.newBuilder().setPrimitive(PrimitiveType.STRING))) + .build()) + .setResultType(SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .build(); + + CelUnknownAttributeValueResolver resolver = + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> "el" + attr.qualifiers().reverse().get(0).asInt()); + + CelAsyncRuntime asyncRuntime = + CelAsyncRuntimeFactory.defaultAsyncRuntime() + .setRuntime(cel) + .setExecutorService(Executors.newSingleThreadExecutor()) + .build(); + + CelAbstractSyntaxTree ast = + cel.compile("listVar[0] == 'el0' && listVar[1] == 'el1' && listVar[2] == 'el2'").getAst(); + + AsyncProgram program = asyncRuntime.createProgram(ast); + + // Act + ListenableFuture future = + program.evaluateToCompletion( + CelResolvableAttributePattern.of( + CelAttributeParser.parsePattern("com.google.listVar[0]"), resolver), + CelResolvableAttributePattern.of( + CelAttributeParser.parsePattern("com.google.listVar[1]"), resolver), + CelResolvableAttributePattern.of( + CelAttributeParser.parsePattern("com.google.listVar[2]"), resolver)); + Object result = future.get(1, SECONDS); + + // Assert + assertThat(result).isInstanceOf(Boolean.class); + assertThat(result).isEqualTo(true); + } + + @Test + public void asyncProgram_thrownExceptionPropagatesImmediately() throws Exception { + // Arrange + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("com.google.var1", SimpleType.STRING) + .addVar("com.google.var2", SimpleType.STRING) + .addVar("com.google.var3", SimpleType.STRING) + .setResultType(SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .build(); + + CelUnknownAttributeValueResolver resolveName = + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> { + Thread.sleep(500); + return attr.toString(); + }); + + CelAsyncRuntime asyncRuntime = + CelAsyncRuntimeFactory.defaultAsyncRuntime() + .setRuntime(cel) + .setExecutorService(newDirectExecutorService()) + .build(); + + CelAbstractSyntaxTree ast = + cel.compile( + "var1 == 'com.google.var1' || " + + "var2 == 'com.google.var2' || " + + "var3 == 'com.google.var3'") + .getAst(); + + AsyncProgram program = asyncRuntime.createProgram(ast); + + // Act + ListenableFuture future = + program.evaluateToCompletion( + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var1"), resolveName), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var2"), + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> { + throw new IllegalArgumentException("example_var2"); + })), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var3"), resolveName)); + + // Assert + ExecutionException e = assertThrows(ExecutionException.class, () -> future.get(2, SECONDS)); + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e).hasCauseThat().hasMessageThat().isEqualTo("example_var2"); + } + + @Test + public void asyncProgram_returnedExceptionPropagatesToEvaluator() throws Exception { + // Arrange + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("com.google.var1", SimpleType.STRING) + .addVar("com.google.var2", SimpleType.STRING) + .addVar("com.google.var3", SimpleType.STRING) + .setResultType(SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .build(); + + CelUnknownAttributeValueResolver resolveName = + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> { + Thread.sleep(500); + return attr.toString(); + }); + + CelAsyncRuntime asyncRuntime = + CelAsyncRuntimeFactory.defaultAsyncRuntime() + .setRuntime(cel) + .setExecutorService(newDirectExecutorService()) + .build(); + + CelAbstractSyntaxTree ast = + cel.compile( + "var1 == 'com.google.var1' && " + + "var2 == 'com.google.var2' && " + + "var3 == 'com.google.var3'") + .getAst(); + + AsyncProgram program = asyncRuntime.createProgram(ast); + + // Act + ListenableFuture future = + program.evaluateToCompletion( + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var1"), resolveName), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var2"), + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> new IllegalStateException("example_var2"))), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var3"), resolveName)); + + // Assert + ExecutionException e = assertThrows(ExecutionException.class, () -> future.get(2, SECONDS)); + assertThat(e).hasCauseThat().isInstanceOf(CelEvaluationException.class); + assertThat(e).hasCauseThat().hasCauseThat().isInstanceOf(IllegalStateException.class); + assertThat(e).hasCauseThat().hasCauseThat().hasMessageThat().isEqualTo("example_var2"); + } + + @Test + public void asyncProgram_returnedExceptionPropagatesToEvaluatorIsPruneable() throws Exception { + // Arrange + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().enableUnknownTracking(true).build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addVar("com.google.var1", SimpleType.STRING) + .addVar("com.google.var2", SimpleType.STRING) + .addVar("com.google.var3", SimpleType.STRING) + .setResultType(SimpleType.BOOL) + .setContainer(CelContainer.ofName("com.google")) + .build(); + + CelUnknownAttributeValueResolver resolveName = + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> { + Thread.sleep(500); + return attr.toString(); + }); + + CelAsyncRuntime asyncRuntime = + CelAsyncRuntimeFactory.defaultAsyncRuntime() + .setRuntime(cel) + .setExecutorService(newDirectExecutorService()) + .build(); + + CelAbstractSyntaxTree ast = + cel.compile("var1 == 'incorrect' || " + "var2 == 'error' || " + "var3 == 'com.google.var3'") + .getAst(); + + AsyncProgram program = asyncRuntime.createProgram(ast); + + // Act + ListenableFuture future = + program.evaluateToCompletion( + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var1"), resolveName), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var2"), + CelUnknownAttributeValueResolver.fromResolver( + (attr) -> new IllegalStateException("example"))), + CelResolvableAttributePattern.of( + CelAttributePattern.fromQualifiedIdentifier("com.google.var3"), resolveName)); + Object result = future.get(2, SECONDS); + + // Assert + assertThat(result).isInstanceOf(Boolean.class); + assertThat(result).isEqualTo(true); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/planner/BUILD.bazel b/runtime/src/test/java/dev/cel/runtime/planner/BUILD.bazel new file mode 100644 index 000000000..9116818dc --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/planner/BUILD.bazel @@ -0,0 +1,70 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, +) + +java_library( + name = "tests", + testonly = 1, + srcs = glob( + ["*.java"], + ), + deps = [ + "//:java_truth", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:cel_source", + "//common:compiler_common", + "//common:container", + "//common:error_codes", + "//common:options", + "//common/ast", + "//common/exceptions:divide_by_zero", + "//common/internal:cel_descriptor_pools", + "//common/internal:default_message_factory", + "//common/internal:dynamic_proto", + "//common/types", + "//common/types:default_type_provider", + "//common/types:message_type_provider", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_byte_string", + "//common/values:cel_value_provider", + "//common/values:proto_message_value", + "//common/values:proto_message_value_provider", + "//compiler", + "//compiler:compiler_builder", + "//extensions", + "//parser:macro", + "//runtime", + "//runtime:descriptor_type_resolver", + "//runtime:dispatcher", + "//runtime:function_binding", + "//runtime:partial_vars", + "//runtime:program", + "//runtime:runtime_equality", + "//runtime:runtime_helpers", + "//runtime:standard_functions", + "//runtime:unknown_attributes", + "//runtime/planner:program_planner", + "//runtime/standard:type", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [ + ":tests", + ], +) diff --git a/runtime/src/test/java/dev/cel/runtime/planner/ProgramPlannerTest.java b/runtime/src/test/java/dev/cel/runtime/planner/ProgramPlannerTest.java new file mode 100644 index 000000000..c749028ff --- /dev/null +++ b/runtime/src/test/java/dev/cel/runtime/planner/ProgramPlannerTest.java @@ -0,0 +1,1191 @@ +// Copyright 2025 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.planner; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; +import static dev.cel.common.CelOverloadDecl.newMemberOverload; +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableCollection; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.primitives.UnsignedLong; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelErrorCode; +import dev.cel.common.CelOptions; +import dev.cel.common.CelSource; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.exceptions.CelDivideByZeroException; +import dev.cel.common.internal.CelDescriptorPool; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.DefaultMessageFactory; +import dev.cel.common.internal.DynamicProto; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.CelTypeProvider.CombinedCelTypeProvider; +import dev.cel.common.types.DefaultTypeProvider; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelByteString; +import dev.cel.common.values.CelValueConverter; +import dev.cel.common.values.CelValueProvider; +import dev.cel.common.values.NullValue; +import dev.cel.common.values.ProtoCelValueConverter; +import dev.cel.common.values.ProtoMessageValueProvider; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.expr.conformance.proto3.GlobalEnum; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedMessage; +import dev.cel.extensions.CelExtensions; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelAttribute; +import dev.cel.runtime.CelAttributePattern; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelLateFunctionBindings; +import dev.cel.runtime.CelStandardFunctions; +import dev.cel.runtime.CelStandardFunctions.StandardFunction; +import dev.cel.runtime.CelUnknownSet; +import dev.cel.runtime.DefaultDispatcher; +import dev.cel.runtime.DescriptorTypeResolver; +import dev.cel.runtime.InternalCelFunctionBinding; +import dev.cel.runtime.PartialVars; +import dev.cel.runtime.Program; +import dev.cel.runtime.RuntimeEquality; +import dev.cel.runtime.RuntimeHelpers; +import dev.cel.runtime.standard.TypeFunction; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class ProgramPlannerTest { + // Note that the following deps will be built from top-level builder APIs + private static final CelOptions CEL_OPTIONS = CelOptions.current().build(); + private static final CelTypeProvider TYPE_PROVIDER = + new CombinedCelTypeProvider( + DefaultTypeProvider.getInstance(), + new ProtoMessageTypeProvider(ImmutableSet.of(TestAllTypes.getDescriptor()))); + private static final RuntimeEquality RUNTIME_EQUALITY = + RuntimeEquality.create(RuntimeHelpers.create(), CEL_OPTIONS); + private static final CelDescriptorPool DESCRIPTOR_POOL = + DefaultDescriptorPool.create( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + TestAllTypes.getDescriptor().getFile())); + private static final DynamicProto DYNAMIC_PROTO = + DynamicProto.create(DefaultMessageFactory.create(DESCRIPTOR_POOL)); + private static final CelValueProvider VALUE_PROVIDER = + ProtoMessageValueProvider.newInstance(CEL_OPTIONS, DYNAMIC_PROTO); + private static final CelValueConverter CEL_VALUE_CONVERTER = + ProtoCelValueConverter.newInstance(DESCRIPTOR_POOL, DYNAMIC_PROTO, CelOptions.DEFAULT); + private static final CelContainer CEL_CONTAINER = + CelContainer.newBuilder() + .setName("cel.expr.conformance.proto3") + .addAbbreviations("really.long.abbr") + .build(); + + private static final ProgramPlanner PLANNER = + ProgramPlanner.newPlanner( + TYPE_PROVIDER, + VALUE_PROVIDER, + newDispatcher(), + CEL_VALUE_CONVERTER, + CEL_CONTAINER, + CEL_OPTIONS, + ImmutableSet.of("late_bound_func")); + + private static final CelCompiler CEL_COMPILER = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addFunctionDeclarations( + newFunctionDeclaration( + "late_bound_func", + newGlobalOverload( + "late_bound_func_overload", SimpleType.STRING, SimpleType.STRING))) + .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) + .addVar("map_var", MapType.create(SimpleType.STRING, SimpleType.DYN)) + .addVar("int_var", SimpleType.INT) + .addVar("dyn_var", SimpleType.DYN) + .addVar("really.long.abbr.ident", SimpleType.DYN) + .addFunctionDeclarations( + newFunctionDeclaration("zero", newGlobalOverload("zero_overload", SimpleType.INT)), + newFunctionDeclaration("error", newGlobalOverload("error_overload", SimpleType.INT)), + newFunctionDeclaration( + "neg", + newGlobalOverload("neg_int", SimpleType.INT, SimpleType.INT), + newGlobalOverload("neg_double", SimpleType.DOUBLE, SimpleType.DOUBLE)), + newFunctionDeclaration( + "cel.expr.conformance.proto3.power", + newGlobalOverload( + "power_int_int", SimpleType.INT, SimpleType.INT, SimpleType.INT)), + newFunctionDeclaration( + "concat", + newGlobalOverload( + "concat_bytes_bytes", SimpleType.BYTES, SimpleType.BYTES, SimpleType.BYTES), + newMemberOverload( + "bytes_concat_bytes", SimpleType.BYTES, SimpleType.BYTES, SimpleType.BYTES))) + .addMessageTypes(TestAllTypes.getDescriptor()) + .addLibraries(CelExtensions.optional(), CelExtensions.comprehensions()) + .setContainer(CEL_CONTAINER) + .build(); + + /** + * Configure dispatcher for testing purposes. This is done manually here, but this should be + * driven by the top-level runtime APIs in the future + */ + private static DefaultDispatcher newDispatcher() { + DefaultDispatcher.Builder builder = DefaultDispatcher.newBuilder(); + + // Subsetted StdLib + CelStandardFunctions stdFunctions = + CelStandardFunctions.newBuilder() + .includeFunctions( + StandardFunction.INDEX, + StandardFunction.LOGICAL_NOT, + StandardFunction.ADD, + StandardFunction.GREATER, + StandardFunction.GREATER_EQUALS, + StandardFunction.LESS, + StandardFunction.DIVIDE, + StandardFunction.EQUALS, + StandardFunction.NOT_STRICTLY_FALSE, + StandardFunction.DYN) + .build(); + addBindingsToDispatcher( + builder, stdFunctions.newFunctionBindings(RUNTIME_EQUALITY, CEL_OPTIONS)); + + TypeFunction typeFunction = + TypeFunction.create( + DescriptorTypeResolver.create(TYPE_PROVIDER, CelValueConverter.getDefaultInstance())); + addBindingsToDispatcher( + builder, typeFunction.newFunctionBindings(CEL_OPTIONS, RUNTIME_EQUALITY)); + + // Custom functions + addBindingsToDispatcher( + builder, + CelFunctionBinding.fromOverloads( + "zero", CelFunctionBinding.from("zero_overload", ImmutableList.of(), (unused) -> 0L))); + + addBindingsToDispatcher( + builder, + CelFunctionBinding.fromOverloads( + "error", + CelFunctionBinding.from( + "error_overload", + ImmutableList.of(), + (unused) -> { + throw new IllegalArgumentException("Intentional error"); + }))); + + addBindingsToDispatcher( + builder, + CelFunctionBinding.fromOverloads( + "neg", + CelFunctionBinding.from("neg_int", Long.class, arg -> -arg), + CelFunctionBinding.from("neg_double", Double.class, arg -> -arg))); + + addBindingsToDispatcher( + builder, + CelFunctionBinding.fromOverloads( + "cel.expr.conformance.proto3.power", + CelFunctionBinding.from( + "power_int_int", + Long.class, + Long.class, + (value, power) -> (long) Math.pow(value, power)))); + + addBindingsToDispatcher( + builder, + CelFunctionBinding.fromOverloads( + "concat", + CelFunctionBinding.from( + "concat_bytes_bytes", + CelByteString.class, + CelByteString.class, + ProgramPlannerTest::concatenateByteArrays), + CelFunctionBinding.from( + "bytes_concat_bytes", + CelByteString.class, + CelByteString.class, + ProgramPlannerTest::concatenateByteArrays))); + + return builder.build(); + } + + private static void addBindingsToDispatcher( + DefaultDispatcher.Builder builder, ImmutableCollection overloadBindings) { + if (overloadBindings.isEmpty()) { + throw new IllegalArgumentException("Invalid bindings"); + } + + overloadBindings.forEach( + overload -> + builder.addOverload( + ((InternalCelFunctionBinding) overload).getFunctionName(), + overload.getOverloadId(), + overload.getArgTypes(), + overload.isStrict(), + overload.getDefinition())); + } + + @TestParameter boolean isParseOnly; + + @Test + public void plan_notSet_throws() { + CelAbstractSyntaxTree invalidAst = + CelAbstractSyntaxTree.newParsedAst(CelExpr.ofNotSet(0L), CelSource.newBuilder().build()); + + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> PLANNER.plan(invalidAst)); + + assertThat(e).hasMessageThat().contains("evaluation error: Unsupported kind: NOT_SET"); + } + + @Test + public void plan_constant(@TestParameter ConstantTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = compile(testCase.expression); + Program program = PLANNER.plan(ast); + + Object result = program.eval(); + + assertThat(result).isEqualTo(testCase.expected); + } + + @Test + public void plan_ident_enum() throws Exception { + CelAbstractSyntaxTree ast = + compile(GlobalEnum.getDescriptor().getFullName() + "." + GlobalEnum.GAR); + Program program = PLANNER.plan(ast); + + Object result = program.eval(); + + assertThat(result).isEqualTo(1L); + } + + @Test + public void plan_ident_enumContainer() throws Exception { + CelContainer container = CelContainer.ofName(GlobalEnum.getDescriptor().getFullName()); + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .setContainer(container) + .build(); + CelAbstractSyntaxTree ast = compile(compiler, GlobalEnum.GAR.name()); + ProgramPlanner planner = + ProgramPlanner.newPlanner( + TYPE_PROVIDER, + VALUE_PROVIDER, + newDispatcher(), + CEL_VALUE_CONVERTER, + container, + CEL_OPTIONS, + ImmutableSet.of()); + + Program program = planner.plan(ast); + + Object result = program.eval(); + + assertThat(result).isEqualTo(1L); + } + + @Test + public void plan_ident_variable() throws Exception { + CelAbstractSyntaxTree ast = compile("int_var"); + Program program = PLANNER.plan(ast); + + Object result = program.eval(ImmutableMap.of("int_var", 1L)); + + assertThat(result).isEqualTo(1); + } + + @Test + public void plan_ident_variableWithStructInList() throws Exception { + CelAbstractSyntaxTree ast = compile("dyn_var"); + Program program = PLANNER.plan(ast); + + Object result = + program.eval( + ImmutableMap.of( + "dyn_var", ImmutableList.of(TestAllTypes.newBuilder().setSingleInt32(42).build()))); + + assertThat(result) + .isEqualTo(ImmutableList.of(TestAllTypes.newBuilder().setSingleInt32(42).build())); + } + + @Test + public void plan_ident_variableWithStructInMap() throws Exception { + CelAbstractSyntaxTree ast = compile("dyn_var"); + Program program = PLANNER.plan(ast); + + Object result = + program.eval( + ImmutableMap.of( + "dyn_var", + ImmutableMap.of("foo", TestAllTypes.newBuilder().setSingleInt32(42).build()))); + + assertThat(result) + .isEqualTo(ImmutableMap.of("foo", TestAllTypes.newBuilder().setSingleInt32(42).build())); + } + + @Test + public void planIdent_typeLiteral(@TestParameter TypeLiteralTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = compile(testCase.expression); + Program program = PLANNER.plan(ast); + + TypeType result = (TypeType) program.eval(); + + assertThat(result).isEqualTo(testCase.type); + } + + @Test + public void planIdent_typeLiteral_equality(@TestParameter TypeLiteralTestCase testCase) + throws Exception { + // ex: type(bool) == type, type(TestAllTypes) == type + CelAbstractSyntaxTree ast = compile(String.format("type(%s) == type", testCase.expression)); + Program program = PLANNER.plan(ast); + + boolean result = (boolean) program.eval(); + + assertThat(result).isTrue(); + } + + @Test + public void plan_ident_missingAttribute_throws() throws Exception { + CelAbstractSyntaxTree ast = compile("int_var"); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e).hasMessageThat().contains("evaluation error at :0: No such attribute(s)"); + } + + @Test + public void plan_ident_withContainer() throws Exception { + CelAbstractSyntaxTree ast = compile("abbr.ident"); + Program program = PLANNER.plan(ast); + + Object result = program.eval(ImmutableMap.of("really.long.abbr.ident", 1L)); + + assertThat(result).isEqualTo(1); + } + + @Test + @SuppressWarnings("unchecked") // test only + public void plan_createList() throws Exception { + CelAbstractSyntaxTree ast = compile("[1, 'foo', true, [2, false]]"); + Program program = PLANNER.plan(ast); + + ImmutableList result = (ImmutableList) program.eval(); + + assertThat(result).containsExactly(1L, "foo", true, ImmutableList.of(2L, false)).inOrder(); + } + + @Test + @SuppressWarnings("unchecked") // test only + public void plan_createMap() throws Exception { + CelAbstractSyntaxTree ast = compile("{'foo': 1, true: 'bar'}"); + Program program = PLANNER.plan(ast); + + ImmutableMap result = (ImmutableMap) program.eval(); + + assertThat(result).containsExactly("foo", 1L, true, "bar").inOrder(); + } + + @Test + public void plan_createMap_containsDuplicateKey_throws() throws Exception { + CelAbstractSyntaxTree ast = compile("{true: 1, false: 2, true: 3}"); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :20: duplicate map key [true]"); + } + + @Test + public void plan_createMap_unsupportedKeyType_throws() throws Exception { + CelAbstractSyntaxTree ast = compile("{1.0: 'foo'}"); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :1: Unsupported key type: 1.0"); + } + + @Test + public void plan_createStruct() throws Exception { + CelAbstractSyntaxTree ast = compile("cel.expr.conformance.proto3.TestAllTypes{}"); + Program program = PLANNER.plan(ast); + + TestAllTypes result = (TestAllTypes) program.eval(); + + assertThat(result).isEqualTo(TestAllTypes.getDefaultInstance()); + } + + @Test + public void plan_createStruct_wrapper() throws Exception { + CelAbstractSyntaxTree ast = compile("google.protobuf.StringValue { value: 'foo' }"); + Program program = PLANNER.plan(ast); + + String result = (String) program.eval(); + + assertThat(result).isEqualTo("foo"); + } + + @Test + public void planCreateStruct_withFields() throws Exception { + CelAbstractSyntaxTree ast = + compile( + "cel.expr.conformance.proto3.TestAllTypes{" + + "single_string: 'foo'," + + "single_bool: true" + + "}"); + Program program = PLANNER.plan(ast); + + TestAllTypes result = (TestAllTypes) program.eval(); + + assertThat(result) + .isEqualTo(TestAllTypes.newBuilder().setSingleString("foo").setSingleBool(true).build()); + } + + @Test + public void plan_createStruct_withContainer() throws Exception { + CelAbstractSyntaxTree ast = compile("TestAllTypes{}"); + Program program = PLANNER.plan(ast); + + TestAllTypes result = (TestAllTypes) program.eval(); + + assertThat(result).isEqualTo(TestAllTypes.getDefaultInstance()); + } + + @Test + public void plan_call_zeroArgs() throws Exception { + CelAbstractSyntaxTree ast = compile("zero()"); + Program program = PLANNER.plan(ast); + + Long result = (Long) program.eval(); + + assertThat(result).isEqualTo(0L); + } + + @Test + public void plan_call_throws() throws Exception { + CelAbstractSyntaxTree ast = compile("error()"); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :5: Function 'error' failed with arg(s) ''"); + assertThat(e).hasCauseThat().isInstanceOf(IllegalArgumentException.class); + assertThat(e.getCause()).hasMessageThat().contains("Intentional error"); + } + + @Test + public void plan_call_oneArg_int() throws Exception { + CelAbstractSyntaxTree ast = compile("neg(1)"); + Program program = PLANNER.plan(ast); + + Long result = (Long) program.eval(); + + assertThat(result).isEqualTo(-1L); + } + + @Test + public void plan_call_oneArg_double() throws Exception { + CelAbstractSyntaxTree ast = compile("neg(2.5)"); + Program program = PLANNER.plan(ast); + + Double result = (Double) program.eval(); + + assertThat(result).isEqualTo(-2.5d); + } + + @Test + public void plan_call_twoArgs_global() throws Exception { + CelAbstractSyntaxTree ast = compile("concat(b'abc', b'def')"); + Program program = PLANNER.plan(ast); + + CelByteString result = (CelByteString) program.eval(); + + assertThat(result).isEqualTo(CelByteString.of("abcdef".getBytes(UTF_8))); + } + + @Test + public void plan_call_twoArgs_receiver() throws Exception { + CelAbstractSyntaxTree ast = compile("b'abc'.concat(b'def')"); + Program program = PLANNER.plan(ast); + + CelByteString result = (CelByteString) program.eval(); + + assertThat(result).isEqualTo(CelByteString.of("abcdef".getBytes(UTF_8))); + } + + @Test + public void plan_call_mapIndex() throws Exception { + CelAbstractSyntaxTree ast = compile("map_var['key'][1]"); + Program program = PLANNER.plan(ast); + ImmutableMap mapVarPayload = ImmutableMap.of("key", ImmutableList.of(1L, 2L)); + + Long result = (Long) program.eval(ImmutableMap.of("map_var", mapVarPayload)); + + assertThat(result).isEqualTo(2L); + } + + @Test + public void plan_call_noMatchingOverload_throws() throws Exception { + CelAbstractSyntaxTree ast = compile("concat(b'abc', dyn_var)"); + Program program = PLANNER.plan(ast); + String errorMsg = + "No matching overload for function 'concat'. Overload candidates: concat_bytes_bytes"; + if (isParseOnly) { + // Parsed-only evaluation includes both overloads as candidates due to dynamic dispatch + errorMsg += ", bytes_concat_bytes"; + } + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> program.eval(ImmutableMap.of("dyn_var", "Impossible Overload"))); + + assertThat(e).hasMessageThat().contains(errorMsg); + } + + @Test + @TestParameters("{expression: 'true || true', expectedResult: true}") + @TestParameters("{expression: 'true || false', expectedResult: true}") + @TestParameters("{expression: 'false || true', expectedResult: true}") + @TestParameters("{expression: 'false || false', expectedResult: false}") + @TestParameters("{expression: 'true || (1 / 0 > 2)', expectedResult: true}") + @TestParameters("{expression: '(1 / 0 > 2) || true', expectedResult: true}") + public void plan_call_logicalOr_shortCircuit(String expression, boolean expectedResult) + throws Exception { + CelAbstractSyntaxTree ast = compile(expression); + Program program = PLANNER.plan(ast); + + boolean result = (boolean) program.eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expression: '(1 / 0 > 2) || (1 / 0 > 2)'}") + @TestParameters("{expression: 'false || (1 / 0 > 2)'}") + @TestParameters("{expression: '(1 / 0 > 2) || false'}") + public void plan_call_logicalOr_throws(String expression) throws Exception { + CelAbstractSyntaxTree ast = compile(expression); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e).hasMessageThat().startsWith("evaluation error at :"); + assertThat(e).hasMessageThat().endsWith("/ by zero"); + assertThat(e).hasCauseThat().isInstanceOf(CelDivideByZeroException.class); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.DIVIDE_BY_ZERO); + } + + @Test + @TestParameters("{expression: 'true && true', expectedResult: true}") + @TestParameters("{expression: 'true && false', expectedResult: false}") + @TestParameters("{expression: 'false && true', expectedResult: false}") + @TestParameters("{expression: 'false && false', expectedResult: false}") + @TestParameters("{expression: 'false && (1 / 0 > 2)', expectedResult: false}") + @TestParameters("{expression: '(1 / 0 > 2) && false', expectedResult: false}") + public void plan_call_logicalAnd_shortCircuit(String expression, boolean expectedResult) + throws Exception { + CelAbstractSyntaxTree ast = compile(expression); + Program program = PLANNER.plan(ast); + + boolean result = (boolean) program.eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expression: '(1 / 0 > 2) && (1 / 0 > 2)'}") + @TestParameters("{expression: 'true && (1 / 0 > 2)'}") + @TestParameters("{expression: '(1 / 0 > 2) && true'}") + public void plan_call_logicalAnd_throws(String expression) throws Exception { + CelAbstractSyntaxTree ast = compile(expression); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e).hasMessageThat().startsWith("evaluation error at :"); + assertThat(e).hasMessageThat().endsWith("/ by zero"); + assertThat(e).hasCauseThat().isInstanceOf(CelDivideByZeroException.class); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.DIVIDE_BY_ZERO); + } + + @Test + @TestParameters("{expression: 'false ? (1 / 0) > 2 : false', expectedResult: false}") + @TestParameters("{expression: 'false ? (1 / 0) > 2 : true', expectedResult: true}") + @TestParameters("{expression: 'true ? false : (1 / 0) > 2', expectedResult: false}") + @TestParameters("{expression: 'true ? true : (1 / 0) > 2', expectedResult: true}") + public void plan_call_conditional_shortCircuit(String expression, boolean expectedResult) + throws Exception { + CelAbstractSyntaxTree ast = compile(expression); + Program program = PLANNER.plan(ast); + + boolean result = (boolean) program.eval(); + + assertThat(result).isEqualTo(expectedResult); + } + + @Test + @TestParameters("{expression: '(1 / 0) > 2 ? true : true'}") + @TestParameters("{expression: 'true ? (1 / 0) > 2 : true'}") + @TestParameters("{expression: 'false ? true : (1 / 0) > 2'}") + public void plan_call_conditional_throws(String expression) throws Exception { + CelAbstractSyntaxTree ast = compile(expression); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e).hasMessageThat().startsWith("evaluation error at :"); + assertThat(e).hasMessageThat().endsWith("/ by zero"); + assertThat(e).hasCauseThat().isInstanceOf(CelDivideByZeroException.class); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.DIVIDE_BY_ZERO); + } + + @Test + @TestParameters("{expression: 'power(2,3)'}") + @TestParameters("{expression: 'proto3.power(2,3)'}") + @TestParameters("{expression: 'conformance.proto3.power(2,3)'}") + @TestParameters("{expression: 'expr.conformance.proto3.power(2,3)'}") + @TestParameters("{expression: 'cel.expr.conformance.proto3.power(2,3)'}") + public void plan_call_withContainer(String expression) throws Exception { + CelAbstractSyntaxTree ast = compile(expression); // invokes cel.expr.conformance.proto3.power + Program program = PLANNER.plan(ast); + + Long result = (Long) program.eval(); + + assertThat(result).isEqualTo(8); + } + + @Test + public void plan_call_lateBoundFunction() throws Exception { + CelAbstractSyntaxTree ast = compile("late_bound_func('test')"); + + Program program = PLANNER.plan(ast); + + String result = + (String) + program.eval( + ImmutableMap.of(), + CelLateFunctionBindings.from( + CelFunctionBinding.from( + "late_bound_func_overload", String.class, (arg) -> arg + "_resolved"))); + + assertThat(result).isEqualTo("test_resolved"); + } + + @Test + public void plan_call_typeResolution(@TestParameter TypeObjectTestCase testCase) + throws Exception { + CelAbstractSyntaxTree ast = compile(testCase.expression); + Program program = PLANNER.plan(ast); + + TypeType result = (TypeType) program.eval(); + + assertThat(result).isEqualTo(testCase.type); + } + + @Test + public void plan_select_protoMessageField() throws Exception { + CelAbstractSyntaxTree ast = compile("msg.single_string"); + Program program = PLANNER.plan(ast); + + String result = + (String) + program.eval( + ImmutableMap.of("msg", TestAllTypes.newBuilder().setSingleString("foo").build())); + + assertThat(result).isEqualTo("foo"); + } + + @Test + public void plan_select_nestedProtoMessage() throws Exception { + CelAbstractSyntaxTree ast = compile("msg.single_nested_message"); + NestedMessage nestedMessage = NestedMessage.newBuilder().setBb(42).build(); + Program program = PLANNER.plan(ast); + + Object result = + program.eval( + ImmutableMap.of( + "msg", TestAllTypes.newBuilder().setSingleNestedMessage(nestedMessage).build())); + + assertThat(result).isEqualTo(nestedMessage); + } + + @Test + public void plan_select_nestedProtoMessageField() throws Exception { + CelAbstractSyntaxTree ast = compile("msg.single_nested_message.bb"); + Program program = PLANNER.plan(ast); + + Object result = + program.eval( + ImmutableMap.of( + "msg", + TestAllTypes.newBuilder() + .setSingleNestedMessage(NestedMessage.newBuilder().setBb(42)) + .build())); + + assertThat(result).isEqualTo(42); + } + + @Test + public void plan_select_safeTraversal() throws Exception { + CelAbstractSyntaxTree ast = compile("msg.single_nested_message.bb"); + Program program = PLANNER.plan(ast); + + Object result = program.eval(ImmutableMap.of("msg", TestAllTypes.getDefaultInstance())); + + assertThat(result).isEqualTo(0L); + } + + @Test + public void plan_select_onCreateStruct() throws Exception { + CelAbstractSyntaxTree ast = + compile("cel.expr.conformance.proto3.TestAllTypes{ single_string: 'foo'}.single_string"); + Program program = PLANNER.plan(ast); + + Object result = program.eval(); + + assertThat(result).isEqualTo("foo"); + } + + @Test + public void plan_select_onCreateMap() throws Exception { + CelAbstractSyntaxTree ast = compile("{'foo':'bar'}.foo"); + Program program = PLANNER.plan(ast); + + Object result = program.eval(); + + assertThat(result).isEqualTo("bar"); + } + + @Test + public void plan_select_onMapVariable() throws Exception { + CelAbstractSyntaxTree ast = compile("map_var.foo"); + Program program = PLANNER.plan(ast); + + Object result = program.eval(ImmutableMap.of("map_var", ImmutableMap.of("foo", 42L))); + + assertThat(result).isEqualTo(42L); + } + + @Test + public void plan_select_mapVarInputMissing_throws() throws Exception { + CelAbstractSyntaxTree ast = compile("map_var.foo"); + Program program = PLANNER.plan(ast); + String errorMessage = "evaluation error at :7: No such attribute(s): "; + if (isParseOnly) { + errorMessage += + "cel.expr.conformance.proto3.map_var, cel.expr.conformance.map_var, cel.expr.map_var," + + " cel.map_var, "; + } + errorMessage += "map_var"; + + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> program.eval(ImmutableMap.of())); + + assertThat(e).hasMessageThat().contains(errorMessage); + } + + @Test + public void plan_select_mapVarKeyMissing_throws() throws Exception { + CelAbstractSyntaxTree ast = compile("map_var.foo"); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> program.eval(ImmutableMap.of("map_var", ImmutableMap.of()))); + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :7: key 'foo' is not present in map"); + } + + @Test + public void plan_select_stringQualificationFail_throws() throws Exception { + CelAbstractSyntaxTree ast = compile("map_var.foo"); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> program.eval(ImmutableMap.of("map_var", "bogus string"))); + + assertThat(e) + .hasMessageThat() + .isEqualTo( + "evaluation error at :7: Error resolving field 'foo'. Field selections must be" + + " performed on messages or maps."); + } + + @Test + public void plan_select_presenceTest(@TestParameter PresenceTestCase testCase) throws Exception { + CelAbstractSyntaxTree ast = compile(testCase.expression); + Program program = PLANNER.plan(ast); + + boolean result = + (boolean) + program.eval( + ImmutableMap.of("msg", testCase.inputParam, "map_var", testCase.inputParam)); + + assertThat(result).isEqualTo(testCase.expected); + } + + @Test + public void plan_select_badPresenceTest_throws() throws Exception { + CelAbstractSyntaxTree ast = compile("has(dyn([]).invalid)"); + Program program = PLANNER.plan(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e) + .hasMessageThat() + .contains( + "Error resolving field 'invalid'. Field selections must be performed on messages or" + + " maps."); + } + + @Test + @TestParameters("{expression: '[1,2,3].exists(x, x > 0) == true'}") + @TestParameters("{expression: '[1,2,3].exists(x, x < 0) == false'}") + @TestParameters("{expression: '[1,2,3].exists(i, v, i >= 0 && v > 0) == true'}") + @TestParameters("{expression: '[1,2,3].exists(i, v, i < 0 || v < 0) == false'}") + @TestParameters("{expression: '[1,2,3].map(x, x + 1) == [2,3,4]'}") + public void plan_comprehension_lists(String expression) throws Exception { + CelAbstractSyntaxTree ast = compile(expression); + Program program = PLANNER.plan(ast); + + boolean result = (boolean) program.eval(); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expression: '{\"a\": 1, \"b\": 2}.exists(k, k == \"a\")'}") + @TestParameters("{expression: '{\"a\": 1, \"b\": 2}.exists(k, k == \"c\") == false'}") + @TestParameters("{expression: '{\"a\": \"b\", \"c\": \"c\"}.exists(k, v, k == v)'}") + @TestParameters("{expression: '{\"a\": 1, \"b\": 2}.exists(k, v, v == 3) == false'}") + public void plan_comprehension_maps(String expression) throws Exception { + CelAbstractSyntaxTree ast = compile(expression); + Program program = PLANNER.plan(ast); + + boolean result = (boolean) program.eval(); + + assertThat(result).isTrue(); + } + + @Test + @TestParameters("{expression: '[1, 2, 3, 4, 5, 6].map(x, x)'}") + @TestParameters("{expression: '[1, 2, 3].map(x, [1, 2].map(y, x + y))'}") + public void plan_comprehension_iterationLimit_throws(String expression) throws Exception { + CelOptions options = CelOptions.current().comprehensionMaxIterations(5).build(); + ProgramPlanner planner = + ProgramPlanner.newPlanner( + TYPE_PROVIDER, + ProtoMessageValueProvider.newInstance(options, DYNAMIC_PROTO), + newDispatcher(), + CEL_VALUE_CONVERTER, + CEL_CONTAINER, + options, + ImmutableSet.of()); + CelAbstractSyntaxTree ast = compile(expression); + + Program program = planner.plan(ast); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + assertThat(e).hasMessageThat().contains("Iteration budget exceeded: 5"); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.ITERATION_BUDGET_EXCEEDED); + } + + @Test + public void plan_comprehension_iterationLimit_success() throws Exception { + CelOptions options = CelOptions.current().comprehensionMaxIterations(10).build(); + ProgramPlanner planner = + ProgramPlanner.newPlanner( + TYPE_PROVIDER, + ProtoMessageValueProvider.newInstance(options, DYNAMIC_PROTO), + newDispatcher(), + CEL_VALUE_CONVERTER, + CEL_CONTAINER, + options, + /* lateBoundFunctionNames= */ ImmutableSet.of()); + CelAbstractSyntaxTree ast = compile("[1, 2, 3].map(x, [1, 2].map(y, x + y))"); + + Program program = planner.plan(ast); + + Object result = program.eval(); + assertThat(result) + .isEqualTo( + ImmutableList.of( + ImmutableList.of(2L, 3L), ImmutableList.of(3L, 4L), ImmutableList.of(4L, 5L))); + } + + @Test + public void plan_partialEval_withWildcardQualification() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addVar("unk", MapType.create(SimpleType.STRING, SimpleType.BOOL)) + .addVar("unk.a", SimpleType.BOOL) + .addVar("unk.b", SimpleType.BOOL) + .build(); + CelAbstractSyntaxTree ast = compile(compiler, "unk.a && unk.b && unk['c']"); + + Program program = PLANNER.plan(ast); + + CelUnknownSet result = + (CelUnknownSet) + program.eval( + PartialVars.of( + CelAttributePattern.create("unk") + .qualify(CelAttribute.Qualifier.ofWildCard()))); + + assertThat(result) + .isEqualTo( + CelUnknownSet.create( + ImmutableSet.of( + CelAttribute.create("unk"), + CelAttribute.create("unk").qualify(CelAttribute.Qualifier.ofString("a")), + CelAttribute.create("unk").qualify(CelAttribute.Qualifier.ofString("b"))), + ImmutableSet.of(2L, 5L, 7L))); + } + + @Test + public void localShadowIdentifier_inSelect() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addVar("cel.example.y", SimpleType.INT) + .build(); + ProgramPlanner planner = + ProgramPlanner.newPlanner( + TYPE_PROVIDER, + ProtoMessageValueProvider.newInstance(CEL_OPTIONS, DYNAMIC_PROTO), + newDispatcher(), + CEL_VALUE_CONVERTER, + CelContainer.ofName("cel.example"), + CEL_OPTIONS, + /* lateBoundFunctionNames= */ ImmutableSet.of()); + CelAbstractSyntaxTree ast = compile(celCompiler, "[{'z': 0}].exists(y, y.z == 0)"); + + Program program = planner.plan(ast); + + boolean result = + (boolean) program.eval(ImmutableMap.of("cel.example.y", ImmutableMap.of("z", 1))); + assertThat(result).isTrue(); + } + + @Test + public void localShadowIdentifier_inSelect_globalDisambiguation() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addVar("y.z", SimpleType.INT) + .build(); + ProgramPlanner planner = + ProgramPlanner.newPlanner( + TYPE_PROVIDER, + ProtoMessageValueProvider.newInstance(CEL_OPTIONS, DYNAMIC_PROTO), + newDispatcher(), + CEL_VALUE_CONVERTER, + CelContainer.ofName("y"), + CEL_OPTIONS, + /* lateBoundFunctionNames= */ ImmutableSet.of()); + CelAbstractSyntaxTree ast = compile(celCompiler, "[{'z': 0}].exists(y, y.z == 0 && .y.z == 1)"); + + Program program = planner.plan(ast); + + boolean result = (boolean) program.eval(ImmutableMap.of("y.z", 1)); + assertThat(result).isTrue(); + } + + @Test + public void localShadowIdentifier_withGlobalDisambiguation() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addVar("x", SimpleType.INT) + .build(); + ProgramPlanner planner = + ProgramPlanner.newPlanner( + TYPE_PROVIDER, + ProtoMessageValueProvider.newInstance(CEL_OPTIONS, DYNAMIC_PROTO), + newDispatcher(), + CEL_VALUE_CONVERTER, + CelContainer.newBuilder().build(), + CEL_OPTIONS, + /* lateBoundFunctionNames= */ ImmutableSet.of()); + CelAbstractSyntaxTree ast = compile(celCompiler, "[0].exists(x, x == 0 && .x == 1)"); + + Program program = planner.plan(ast); + + boolean result = (boolean) program.eval(ImmutableMap.of("x", 1)); + assertThat(result).isTrue(); + } + + @Test + public void localDoubleShadowIdentifier_withGlobalDisambiguation() throws Exception { + CelCompiler celCompiler = + CelCompilerFactory.standardCelCompilerBuilder() + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addVar("x", SimpleType.INT) + .build(); + ProgramPlanner planner = + ProgramPlanner.newPlanner( + TYPE_PROVIDER, + ProtoMessageValueProvider.newInstance(CEL_OPTIONS, DYNAMIC_PROTO), + newDispatcher(), + CEL_VALUE_CONVERTER, + CelContainer.newBuilder().build(), + CEL_OPTIONS, + /* lateBoundFunctionNames= */ ImmutableSet.of()); + CelAbstractSyntaxTree ast = compile(celCompiler, "[0].exists(x, [x+1].exists(x, x == .x))"); + + Program program = planner.plan(ast); + + boolean result = (boolean) program.eval(ImmutableMap.of("x", 1)); + assertThat(result).isTrue(); + } + + private CelAbstractSyntaxTree compile(String expression) throws Exception { + return compile(CEL_COMPILER, expression); + } + + private CelAbstractSyntaxTree compile(CelCompiler compiler, String expression) throws Exception { + CelAbstractSyntaxTree ast = compiler.parse(expression).getAst(); + if (isParseOnly) { + return ast; + } + + return compiler.check(ast).getAst(); + } + + private static CelByteString concatenateByteArrays(CelByteString bytes1, CelByteString bytes2) { + if (bytes1.isEmpty()) { + return bytes2; + } + + if (bytes2.isEmpty()) { + return bytes1; + } + + return bytes1.concat(bytes2); + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum ConstantTestCase { + NULL("null", NullValue.NULL_VALUE), + BOOLEAN("true", true), + INT64("42", 42L), + UINT64("42u", UnsignedLong.valueOf(42)), + DOUBLE("1.5", 1.5d), + STRING("'hello world'", "hello world"), + BYTES("b'abc'", CelByteString.of("abc".getBytes(UTF_8))); + + private final String expression; + private final Object expected; + + ConstantTestCase(String expression, Object expected) { + this.expression = expression; + this.expected = expected; + } + } + + @SuppressWarnings("ImmutableEnumChecker") // Test only + private enum TypeLiteralTestCase { + BOOL("bool", SimpleType.BOOL), + BYTES("bytes", SimpleType.BYTES), + DOUBLE("double", SimpleType.DOUBLE), + INT("int", SimpleType.INT), + UINT("uint", SimpleType.UINT), + STRING("string", SimpleType.STRING), + LIST("list", ListType.create(SimpleType.DYN)), + MAP("map", MapType.create(SimpleType.DYN, SimpleType.DYN)), + NULL("null_type", SimpleType.NULL_TYPE), + DURATION("google.protobuf.Duration", SimpleType.DURATION), + TIMESTAMP("google.protobuf.Timestamp", SimpleType.TIMESTAMP), + OPTIONAL("optional_type", OptionalType.create(SimpleType.DYN)), + PROTO_MESSAGE_TYPE( + "cel.expr.conformance.proto3.TestAllTypes", + TYPE_PROVIDER.findType(TestAllTypes.getDescriptor().getFullName()).get()); + + private final String expression; + private final TypeType type; + + TypeLiteralTestCase(String expression, CelType type) { + this.expression = expression; + this.type = TypeType.create(type); + } + } + + private enum TypeObjectTestCase { + BOOL("type(true)", SimpleType.BOOL), + INT("type(1)", SimpleType.INT), + DOUBLE("type(1.5)", SimpleType.DOUBLE), + PROTO_MESSAGE_TYPE( + "type(cel.expr.conformance.proto3.TestAllTypes{})", + TYPE_PROVIDER.findType("cel.expr.conformance.proto3.TestAllTypes").get()); + + private final String expression; + private final TypeType type; + + TypeObjectTestCase(String expression, CelType type) { + this.expression = expression; + this.type = TypeType.create(type); + } + } + + @SuppressWarnings("Immutable") // Test only + private enum PresenceTestCase { + PROTO_FIELD_PRESENT( + "has(msg.single_string)", TestAllTypes.newBuilder().setSingleString("foo").build(), true), + PROTO_FIELD_ABSENT("has(msg.single_string)", TestAllTypes.getDefaultInstance(), false), + PROTO_NESTED_FIELD_PRESENT( + "has(msg.single_nested_message.bb)", + TestAllTypes.newBuilder() + .setSingleNestedMessage(NestedMessage.newBuilder().setBb(42).build()) + .build(), + true), + PROTO_NESTED_FIELD_ABSENT( + "has(msg.single_nested_message.bb)", TestAllTypes.getDefaultInstance(), false), + PROTO_MAP_KEY_PRESENT("has(map_var.foo)", ImmutableMap.of("foo", "1"), true), + PROTO_MAP_KEY_ABSENT("has(map_var.bar)", ImmutableMap.of(), false); + + private final String expression; + private final Object inputParam; + private final Object expected; + + PresenceTestCase(String expression, Object inputParam, Object expected) { + this.expression = expression; + this.inputParam = inputParam; + this.expected = expected; + } + } +} diff --git a/runtime/src/test/resources/BUILD.bazel b/runtime/src/test/resources/BUILD.bazel new file mode 100644 index 000000000..e419ff319 --- /dev/null +++ b/runtime/src/test/resources/BUILD.bazel @@ -0,0 +1,11 @@ +package( + default_applicable_licenses = [ + "//:license", + ], + default_visibility = ["//runtime/testdata:__pkg__"], +) + +filegroup( + name = "resources", + srcs = glob(["*.baseline"]), +) diff --git a/runtime/src/test/resources/abstractType.baseline b/runtime/src/test/resources/abstractType.baseline new file mode 100644 index 000000000..effd28b7a --- /dev/null +++ b/runtime/src/test/resources/abstractType.baseline @@ -0,0 +1,22 @@ +Source: vector([1,2,3]).at(1) == 2 +declare vector { + function vector (list(T)) -> vector(T) +} +declare at { + function at vector(T).(int) -> T +} +=====> +bindings: {} +result: true + +Source: vector([1,2,3]).at(1) + vector([7]).at(0) +declare vector { + function vector (list(T)) -> vector(T) +} +declare at { + function at vector(T).(int) -> T +} +=====> +bindings: {} +result: 9 + diff --git a/runtime/src/test/resources/arithCrossNumericTypes.baseline b/runtime/src/test/resources/arithCrossNumericTypes.baseline new file mode 100644 index 000000000..7ea4929c1 --- /dev/null +++ b/runtime/src/test/resources/arithCrossNumericTypes.baseline @@ -0,0 +1,19 @@ +Source: 1.9 < 2 && 1 < 1.1 && 2u < 2.9 && 1.1 < 2u && 1 < 2u && 2u < 3 +=====> +bindings: {} +result: true + +Source: 1.9 <= 2 && 1 <= 1.1 && 2u <= 2.9 && 1.1 <= 2u && 2 <= 2u && 2u <= 2 +=====> +bindings: {} +result: true + +Source: 1.9 > 2 && 1 > 1.1 && 2u > 2.9 && 1.1 > 2u && 2 > 2u && 2u > 2 +=====> +bindings: {} +result: false + +Source: 1.9 >= 2 && 1 >= 1.1 && 2u >= 2.9 && 1.1 >= 2u && 2 >= 2u && 2u >= 2 +=====> +bindings: {} +result: false diff --git a/runtime/src/test/resources/arithmDouble.baseline b/runtime/src/test/resources/arithmDouble.baseline new file mode 100644 index 000000000..3c219ef29 --- /dev/null +++ b/runtime/src/test/resources/arithmDouble.baseline @@ -0,0 +1,28 @@ +Source: 0.0 == -0.0 +=====> +bindings: {} +result: true + +Source: 1.9 < 2.0 && 1.1 <= 1.1 && 2.0 > 1.9 && 1.1 >= 1.1 && 1.1 == 1.1 && 2.0 != 1.9 +=====> +bindings: {} +result: true + +Source: 1.0 + 2.3 + x * 3.0 / x +declare x { + value double +} +=====> +bindings: {x=3.33} +result: 6.3 + +Source: x + y == 9.99 +declare x { + value double +} +declare y { + value dyn +} +=====> +bindings: {y=6.66} +> {x=3.33} +result: true diff --git a/runtime/src/test/resources/arithmDuration.baseline b/runtime/src/test/resources/arithmDuration.baseline new file mode 100644 index 000000000..9aa73405d --- /dev/null +++ b/runtime/src/test/resources/arithmDuration.baseline @@ -0,0 +1,27 @@ +Source: d1 + d2 == d3 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +declare d3 { + value google.protobuf.Duration +} +=====> +bindings: {d3=PT25.000000045S} +> {d2=PT10.00000002S} +> {d1=PT15.000000025S} +result: true + +Source: d3 - d1 == d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +declare d3 { + value google.protobuf.Duration +} +=====> +bindings: {d3=PT25.000000045S} +> {d2=PT10.00000002S} +> {d1=PT15.000000025S} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/arithmInt64.baseline b/runtime/src/test/resources/arithmInt64.baseline new file mode 100644 index 000000000..5601b390c --- /dev/null +++ b/runtime/src/test/resources/arithmInt64.baseline @@ -0,0 +1,23 @@ +Source: 1 < 2 && 1 <= 1 && 2 > 1 && 1 >= 1 && 1 == 1 && 2 != 1 +=====> +bindings: {} +result: true + +Source: 1 + 2 - x * 3 / x + (x % 3) +declare x { + value int +} +=====> +bindings: {x=-5} +result: -2 + +Source: x + y == 1 +declare x { + value int +} +declare y { + value dyn +} +=====> +bindings: {y=6} +> {x=-5} +result: true diff --git a/runtime/src/test/resources/arithmInt64_error.baseline b/runtime/src/test/resources/arithmInt64_error.baseline new file mode 100644 index 000000000..05080171e --- /dev/null +++ b/runtime/src/test/resources/arithmInt64_error.baseline @@ -0,0 +1,41 @@ +Source: 9223372036854775807 + 1 +=====> +bindings: {} +error: evaluation error at test_location:20: long overflow +error_code: NUMERIC_OVERFLOW + +Source: -9223372036854775808 - 1 +=====> +bindings: {} +error: evaluation error at test_location:21: long overflow +error_code: NUMERIC_OVERFLOW + +Source: -(-9223372036854775808) +=====> +bindings: {} +error: evaluation error at test_location:0: long overflow +error_code: NUMERIC_OVERFLOW + +Source: 5000000000 * 5000000000 +=====> +bindings: {} +error: evaluation error at test_location:11: long overflow +error_code: NUMERIC_OVERFLOW + +Source: (-9223372036854775808)/-1 +=====> +bindings: {} +error: evaluation error at test_location:22: most negative number wraps +error_code: NUMERIC_OVERFLOW + +Source: 1 / 0 +=====> +bindings: {} +error: evaluation error at test_location:2: / by zero +error_code: DIVIDE_BY_ZERO + +Source: 1 % 0 +=====> +bindings: {} +error: evaluation error at test_location:2: / by zero +error_code: DIVIDE_BY_ZERO \ No newline at end of file diff --git a/runtime/src/test/resources/arithmTimestamp.baseline b/runtime/src/test/resources/arithmTimestamp.baseline new file mode 100644 index 000000000..7ddf702ae --- /dev/null +++ b/runtime/src/test/resources/arithmTimestamp.baseline @@ -0,0 +1,55 @@ +Source: ts1 - ts2 == d1 +declare ts1 { + value google.protobuf.Timestamp +} +declare ts2 { + value google.protobuf.Timestamp +} +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {ts2=1970-01-01T00:00:10.000000010Z} +> {ts1=1970-01-01T00:00:25.000000035Z} +> {d1=PT15.000000025S} +result: true + +Source: ts1 - d1 == ts2 +declare ts1 { + value google.protobuf.Timestamp +} +declare ts2 { + value google.protobuf.Timestamp +} +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {ts2=1970-01-01T00:00:10.000000010Z} +> {ts1=1970-01-01T00:00:25.000000035Z} +> {d1=PT15.000000025S} +result: true + +Source: ts2 + d1 == ts1 +declare ts1 { + value google.protobuf.Timestamp +} +declare ts2 { + value google.protobuf.Timestamp +} +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {ts2=1970-01-01T00:00:10.000000010Z} +> {ts1=1970-01-01T00:00:25.000000035Z} +> {d1=PT15.000000025S} +result: true + +Source: d1 + ts2 == ts1 +declare ts1 { + value google.protobuf.Timestamp +} +declare ts2 { + value google.protobuf.Timestamp +} +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {ts2=1970-01-01T00:00:10.000000010Z} +> {ts1=1970-01-01T00:00:25.000000035Z} +> {d1=PT15.000000025S} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/arithmUInt64.baseline b/runtime/src/test/resources/arithmUInt64.baseline new file mode 100644 index 000000000..595c88cee --- /dev/null +++ b/runtime/src/test/resources/arithmUInt64.baseline @@ -0,0 +1,34 @@ +Source: 1u < 2u && 1u <= 1u && 2u > 1u && 1u >= 1u && 1u == 1u && 2u != 1u +=====> +bindings: {} +result: true + +Source: 1u + 2u + x * 3u / x + (x % 3u) +declare x { + value uint +} +=====> +bindings: {x=5} +result: 8 + +Source: x + y == 11u +declare x { + value uint +} +declare y { + value dyn +} +=====> +bindings: {y=6} +> {x=5} +result: true + +Source: x - y == 1u +declare x { + value uint +} +declare y { + value dyn +} +=====> +bindings: {y=5} +> {x=6} +result: true diff --git a/runtime/src/test/resources/arithmUInt64_error.baseline b/runtime/src/test/resources/arithmUInt64_error.baseline new file mode 100644 index 000000000..062e28005 --- /dev/null +++ b/runtime/src/test/resources/arithmUInt64_error.baseline @@ -0,0 +1,29 @@ +Source: 18446744073709551615u + 1u +=====> +bindings: {} +error: evaluation error at test_location:22: range overflow on unsigned addition +error_code: NUMERIC_OVERFLOW + +Source: 0u - 1u +=====> +bindings: {} +error: evaluation error at test_location:3: unsigned subtraction underflow +error_code: NUMERIC_OVERFLOW + +Source: 5000000000u * 5000000000u +=====> +bindings: {} +error: evaluation error at test_location:12: multiply out of unsigned integer range +error_code: NUMERIC_OVERFLOW + +Source: 1u / 0u +=====> +bindings: {} +error: evaluation error at test_location:3: / by zero +error_code: DIVIDE_BY_ZERO + +Source: 1u % 0u +=====> +bindings: {} +error: evaluation error at test_location:3: / by zero +error_code: DIVIDE_BY_ZERO \ No newline at end of file diff --git a/runtime/src/test/resources/boolConversions.baseline b/runtime/src/test/resources/boolConversions.baseline new file mode 100644 index 000000000..46117866f --- /dev/null +++ b/runtime/src/test/resources/boolConversions.baseline @@ -0,0 +1,14 @@ +Source: bool(true) +=====> +bindings: {} +result: true + +Source: bool('true') && bool('TRUE') && bool('True') && bool('t') && bool('1') +=====> +bindings: {} +result: true + +Source: bool('false') || bool('FALSE') || bool('False') || bool('f') || bool('0') +=====> +bindings: {} +result: false \ No newline at end of file diff --git a/runtime/src/test/resources/boolConversions_error.baseline b/runtime/src/test/resources/boolConversions_error.baseline new file mode 100644 index 000000000..a2c6a11dd --- /dev/null +++ b/runtime/src/test/resources/boolConversions_error.baseline @@ -0,0 +1,11 @@ +Source: bool('TrUe') +=====> +bindings: {} +error: evaluation error at test_location:4: Type conversion error from 'string' to 'bool': [TrUe] +error_code: BAD_FORMAT + +Source: bool('FaLsE') +=====> +bindings: {} +error: evaluation error at test_location:4: Type conversion error from 'string' to 'bool': [FaLsE] +error_code: BAD_FORMAT \ No newline at end of file diff --git a/runtime/src/test/resources/booleans.baseline b/runtime/src/test/resources/booleans.baseline new file mode 100644 index 000000000..6c0fb5a1a --- /dev/null +++ b/runtime/src/test/resources/booleans.baseline @@ -0,0 +1,229 @@ +Source: x ? 1 : 0 +declare x { + value bool +} +=====> +bindings: {x=true} +result: 1 + +Source: x ? 1 : 0 +declare x { + value bool +} +=====> +bindings: {x=false} +result: 0 + +Source: (1 / 0 == 0 && false) == (false && 1 / 0 == 0) +declare x { + value bool +} +=====> +bindings: {} +result: true + +Source: (1 / 0 == 0 || true) == (true || 1 / 0 == 0) +declare x { + value bool +} +=====> +bindings: {} +result: true + +Source: 1 / y == 1 || true +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {y=0} +result: true + +Source: 1 / y == 1 && false +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {y=0} +result: false + +Source: (true > false) == true +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (true > true) == false +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (false > true) == false +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (false > false) == false +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (true >= false) == true +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (true >= true) == true +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (false >= false) == true +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (false >= true) == false +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (false < true) == true +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (false < false) == false +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (true < false) == false +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (true < true) == false +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (false <= true) == true +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (false <= false) == true +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (true <= false) == false +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: (true <= true) == true +declare x { + value bool +} +declare y { + value int +} +=====> +bindings: {} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/booleans_error.baseline b/runtime/src/test/resources/booleans_error.baseline new file mode 100644 index 000000000..e7ecf568b --- /dev/null +++ b/runtime/src/test/resources/booleans_error.baseline @@ -0,0 +1,35 @@ +Source: 1 / y == 1 || false +declare y { + value int +} +=====> +bindings: {y=0} +error: evaluation error at test_location:2: / by zero +error_code: DIVIDE_BY_ZERO + +Source: false || 1 / y == 1 +declare y { + value int +} +=====> +bindings: {y=0} +error: evaluation error at test_location:11: / by zero +error_code: DIVIDE_BY_ZERO + +Source: 1 / y == 1 && true +declare y { + value int +} +=====> +bindings: {y=0} +error: evaluation error at test_location:2: / by zero +error_code: DIVIDE_BY_ZERO + +Source: true && 1 / y == 1 +declare y { + value int +} +=====> +bindings: {y=0} +error: evaluation error at test_location:10: / by zero +error_code: DIVIDE_BY_ZERO \ No newline at end of file diff --git a/runtime/src/test/resources/bytes.baseline b/runtime/src/test/resources/bytes.baseline new file mode 100644 index 000000000..1af910ce2 --- /dev/null +++ b/runtime/src/test/resources/bytes.baseline @@ -0,0 +1,4 @@ +Source: b'a' < b'b' && b'a' <= b'b' && b'b' > b'a' && b'a' >= b'a' && b'a' == b'a' && b'a' != b'b' +=====> +bindings: {} +result: true diff --git a/runtime/src/test/resources/bytesConversions.baseline b/runtime/src/test/resources/bytesConversions.baseline new file mode 100644 index 000000000..6324929ce --- /dev/null +++ b/runtime/src/test/resources/bytesConversions.baseline @@ -0,0 +1,9 @@ +Source: bytes('abc\303') +=====> +bindings: {} +result: abcà + +Source: bytes(bytes('abc\303')) +=====> +bindings: {} +result: abcà \ No newline at end of file diff --git a/runtime/src/test/resources/comprehension.baseline b/runtime/src/test/resources/comprehension.baseline new file mode 100644 index 000000000..aa0ecc3f9 --- /dev/null +++ b/runtime/src/test/resources/comprehension.baseline @@ -0,0 +1,54 @@ +Source: [0, 1, 2].map(x, x > 0, x + 1) == [2, 3] +=====> +bindings: {} +result: true + +Source: [0, 1, 2].exists(x, x > 0) +=====> +bindings: {} +result: true + +Source: [0, 1, 2].exists(x, x > 2) +=====> +bindings: {} +result: false + +Source: [0].exists(x, x == 0) +declare com.x { + value int +} +=====> +bindings: {com.x=1} +result: true + +Source: [{'z': 0}].exists(y, y.z == 0) +declare cel.example.y { + value int +} +=====> +bindings: {cel.example.y={z=1}} +result: true + +Source: [{'z': 0}].exists(y, y.z == 0 && .y.z == 1) +declare y.z { + value int +} +=====> +bindings: {y.z=1} +result: true + +Source: [0].exists(x, x == 0 && .x == 1) +declare x { + value int +} +=====> +bindings: {x=1} +result: true + +Source: [0].exists(x, [x+1].exists(x, x == .x)) +declare x { + value int +} +=====> +bindings: {x=1} +result: true diff --git a/runtime/src/test/resources/containers.baseline b/runtime/src/test/resources/containers.baseline new file mode 100644 index 000000000..4e29c64f3 --- /dev/null +++ b/runtime/src/test/resources/containers.baseline @@ -0,0 +1,19 @@ +Source: test_alias.TestAllTypes{} == cel.expr.conformance.proto3.TestAllTypes{} +=====> +bindings: {} +result: true + +Source: proto2.TestAllTypes{} == cel.expr.conformance.proto2.TestAllTypes{} +=====> +bindings: {} +result: true + +Source: proto3.TestAllTypes{} == cel.expr.conformance.proto3.TestAllTypes{} +=====> +bindings: {} +result: true + +Source: SGAR +=====> +bindings: {} +result: 1 diff --git a/runtime/src/test/resources/contextPropagation.baseline b/runtime/src/test/resources/contextPropagation.baseline new file mode 100644 index 000000000..a70382604 --- /dev/null +++ b/runtime/src/test/resources/contextPropagation.baseline @@ -0,0 +1,7 @@ +Source: f() +declare f { + function f () -> string +} +=====> +bindings: {} +result: testpeer \ No newline at end of file diff --git a/runtime/src/test/resources/delayedEvaluation.baseline b/runtime/src/test/resources/delayedEvaluation.baseline new file mode 100644 index 000000000..8604c359c --- /dev/null +++ b/runtime/src/test/resources/delayedEvaluation.baseline @@ -0,0 +1,38 @@ +Source: f_force(f_delay(1 + 2)) == 3 +declare f_delay { + function f_delay (int) -> dyn +} +declare f_force { + function f_force (dyn) -> int +} +=====> +bindings: {} +result: true + +Source: f_force(f_delay(1 + four)) == 5 +declare four { + value int +} +declare f_delay { + function f_delay (int) -> dyn +} +declare f_force { + function f_force (dyn) -> int +} +=====> +bindings: {four=4} +result: true + +Source: [1, 2, 3].map(i, f_delay(i + four)).map(d, f_force(d)) == [5, 6, 7] +declare four { + value int +} +declare f_delay { + function f_delay (int) -> dyn +} +declare f_force { + function f_force (dyn) -> int +} +=====> +bindings: {four=4} +result: true diff --git a/runtime/src/test/resources/dispatcherSnapshot.baseline b/runtime/src/test/resources/dispatcherSnapshot.baseline new file mode 100644 index 000000000..0aeede135 --- /dev/null +++ b/runtime/src/test/resources/dispatcherSnapshot.baseline @@ -0,0 +1,7 @@ +Source: just_undefined("hi there ") == "foo" +declare just_undefined { + function just_undefined (string) -> string +} +=====> +bindings: {} +error: evaluation error at test_location:14: no runtime binding for just_undefined diff --git a/runtime/src/test/resources/doubleConversions.baseline b/runtime/src/test/resources/doubleConversions.baseline new file mode 100644 index 000000000..3c073ec39 --- /dev/null +++ b/runtime/src/test/resources/doubleConversions.baseline @@ -0,0 +1,19 @@ +Source: double('1.1') +=====> +bindings: {} +result: 1.1 + +Source: double(2u) +=====> +bindings: {} +result: 2.0 + +Source: double(-1) +=====> +bindings: {} +result: -1.0 + +Source: double(1.5) +=====> +bindings: {} +result: 1.5 \ No newline at end of file diff --git a/runtime/src/test/resources/doubleConversions_error.baseline b/runtime/src/test/resources/doubleConversions_error.baseline new file mode 100644 index 000000000..69f77ccf1 --- /dev/null +++ b/runtime/src/test/resources/doubleConversions_error.baseline @@ -0,0 +1,5 @@ +Source: double('bad') +=====> +bindings: {} +error: evaluation error at test_location:6: For input string: "bad" +error_code: BAD_FORMAT \ No newline at end of file diff --git a/runtime/src/test/resources/duration.baseline b/runtime/src/test/resources/duration.baseline new file mode 100644 index 000000000..89d058086 --- /dev/null +++ b/runtime/src/test/resources/duration.baseline @@ -0,0 +1,219 @@ +Source: d1 < d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.000000009S} +> {d1=PT10.00000001S} +result: false + +Source: d1 < d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT9.00000001S} +> {d1=PT10.00000001S} +result: false + +Source: d1 < d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT10.00000001S} +result: false + +Source: d1 < d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT10.000000009S} +result: true + +Source: d1 < d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT9.00000001S} +result: true + +Source: d1 <= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.000000009S} +> {d1=PT10.00000001S} +result: false + +Source: d1 <= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT9.00000001S} +> {d1=PT10.00000001S} +result: false + +Source: d1 <= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT10.00000001S} +result: true + +Source: d1 <= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT10.000000009S} +result: true + +Source: d1 <= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT9.00000001S} +result: true + +Source: d1 > d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.000000009S} +> {d1=PT10.00000001S} +result: true + +Source: d1 > d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT9.00000001S} +> {d1=PT10.00000001S} +result: true + +Source: d1 > d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT10.00000001S} +result: false + +Source: d1 > d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT10.000000009S} +result: false + +Source: d1 > d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT9.00000001S} +result: false + +Source: d1 >= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.000000009S} +> {d1=PT10.00000001S} +result: true + +Source: d1 >= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT9.00000001S} +> {d1=PT10.00000001S} +result: true + +Source: d1 >= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT10.00000001S} +result: true + +Source: d1 >= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT10.000000009S} +result: false + +Source: d1 >= d2 +declare d1 { + value google.protobuf.Duration +} +declare d2 { + value google.protobuf.Duration +} +=====> +bindings: {d2=PT10.00000001S} +> {d1=PT9.00000001S} +result: false \ No newline at end of file diff --git a/runtime/src/test/resources/durationFunctions.baseline b/runtime/src/test/resources/durationFunctions.baseline new file mode 100644 index 000000000..9bc61d4ae --- /dev/null +++ b/runtime/src/test/resources/durationFunctions.baseline @@ -0,0 +1,107 @@ +Source: d1.getHours() +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {d1=PT25H59M1.011S} +result: 25 + +Source: d1.getHours() +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {d1=PT-25H-59M-1.011S} +result: -25 + +Source: d1.getMinutes() +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {d1=PT25H59M1.011S} +result: 1559 + +Source: d1.getMinutes() +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {d1=PT-25H-59M-1.011S} +result: -1559 + +Source: d1.getSeconds() +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {d1=PT25H59M1.011S} +result: 93541 + +Source: d1.getSeconds() +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {d1=PT-25H-59M-1.011S} +result: -93541 + +Source: d1.getMilliseconds() +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {d1=PT25H59M1.011S} +result: 11 + +Source: d1.getMilliseconds() +declare d1 { + value google.protobuf.Duration +} +=====> +bindings: {d1=PT-25H-59M-1.011S} +result: -11 + +Source: d1.getHours() < val +declare d1 { + value google.protobuf.Duration +} +declare val { + value int +} +=====> +bindings: {val=30} +> {d1=PT25H59M1.011S} +result: true + +Source: d1.getMinutes() > val +declare d1 { + value google.protobuf.Duration +} +declare val { + value int +} +=====> +bindings: {val=30} +> {d1=PT25H59M1.011S} +result: true + +Source: d1.getSeconds() > val +declare d1 { + value google.protobuf.Duration +} +declare val { + value int +} +=====> +bindings: {val=30} +> {d1=PT25H59M1.011S} +result: true + +Source: d1.getMilliseconds() < val +declare d1 { + value google.protobuf.Duration +} +declare val { + value int +} +=====> +bindings: {val=30} +> {d1=PT25H59M1.011S} +result: true diff --git a/runtime/src/test/resources/dynConversions.baseline b/runtime/src/test/resources/dynConversions.baseline new file mode 100644 index 000000000..a391ad89f --- /dev/null +++ b/runtime/src/test/resources/dynConversions.baseline @@ -0,0 +1,9 @@ +Source: dyn(42) +=====> +bindings: {} +result: 42 + +Source: dyn({'a':1, 'b':2}) +=====> +bindings: {} +result: {a=1, b=2} diff --git a/runtime/src/test/resources/dyn_error.baseline b/runtime/src/test/resources/dyn_error.baseline new file mode 100644 index 000000000..00a0766cd --- /dev/null +++ b/runtime/src/test/resources/dyn_error.baseline @@ -0,0 +1,23 @@ +Source: dyn('hello').invalid +=====> +bindings: {} +error: evaluation error at test_location:12: Error resolving field 'invalid'. Field selections must be performed on messages or maps. +error_code: ATTRIBUTE_NOT_FOUND + +Source: has(dyn('hello').invalid) +=====> +bindings: {} +error: evaluation error at test_location:3: Error resolving field 'invalid'. Field selections must be performed on messages or maps. +error_code: ATTRIBUTE_NOT_FOUND + +Source: dyn([]).invalid +=====> +bindings: {} +error: evaluation error at test_location:7: Error resolving field 'invalid'. Field selections must be performed on messages or maps. +error_code: ATTRIBUTE_NOT_FOUND + +Source: has(dyn([]).invalid) +=====> +bindings: {} +error: evaluation error at test_location:3: Error resolving field 'invalid'. Field selections must be performed on messages or maps. +error_code: ATTRIBUTE_NOT_FOUND diff --git a/runtime/src/test/resources/dynamicMessage_adapted.baseline b/runtime/src/test/resources/dynamicMessage_adapted.baseline new file mode 100644 index 000000000..b012c3727 --- /dev/null +++ b/runtime/src/test/resources/dynamicMessage_adapted.baseline @@ -0,0 +1,945 @@ +Source: msg.single_any +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: bb: 42 + + +Source: msg.single_bool_wrapper +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: true + +Source: msg.single_bytes_wrapper +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: hi + +Source: msg.single_double_wrapper +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: -3.0 + +Source: msg.single_float_wrapper +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: 1.5 + +Source: msg.single_int32_wrapper +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: -12 + +Source: msg.single_int64_wrapper +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: -34 + +Source: msg.single_string_wrapper +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: hello + +Source: msg.single_uint32_wrapper +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: 12 + +Source: msg.single_uint64_wrapper +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: 34 + +Source: msg.single_duration +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: PT10.00000002S + +Source: msg.single_timestamp +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: 1970-01-01T00:01:40.000000200Z + +Source: msg.single_value +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: a + +Source: msg.single_struct +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: {b=c} + +Source: msg.list_value +declare msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {msg=single_any { + type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes.NestedMessage" + value: "\b*" +} +single_duration { + seconds: 10 + nanos: 20 +} +single_timestamp { + seconds: 100 + nanos: 200 +} +single_struct { + fields { + key: "b" + value { + string_value: "c" + } + } +} +single_value { + string_value: "a" +} +single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +list_value { + values { + string_value: "d" + } +} +} +result: [d] diff --git a/runtime/src/test/resources/dynamicMessage_dynamicDescriptor.baseline b/runtime/src/test/resources/dynamicMessage_dynamicDescriptor.baseline new file mode 100644 index 000000000..8f91353b4 --- /dev/null +++ b/runtime/src/test/resources/dynamicMessage_dynamicDescriptor.baseline @@ -0,0 +1,221 @@ +Source: TestAllTypes {} +=====> +bindings: {} +result: + +Source: TestAllTypes { single_int32: 1, single_int64: 2, single_string: 'hello'} +=====> +bindings: {} +result: single_int32: 1 +single_int64: 2 +single_string: "hello" + + +Source: TestAllTypes { single_int32: 1, single_int64: 2, single_string: 'hello'}.single_string +=====> +bindings: {} +result: hello + +Source: TestAllTypes { single_int32_wrapper: 3 }.single_int32_wrapper +=====> +bindings: {} +result: 3 + +Source: TestAllTypes { single_int64_wrapper: 3 }.single_int64_wrapper +=====> +bindings: {} +result: 3 + +Source: TestAllTypes { single_bool_wrapper: true }.single_bool_wrapper +=====> +bindings: {} +result: true + +Source: TestAllTypes { single_bytes_wrapper: b'abc' }.single_bytes_wrapper +=====> +bindings: {} +result: abc + +Source: TestAllTypes { single_float_wrapper: 1.1 }.single_float_wrapper +=====> +bindings: {} +result: 1.100000023841858 + +Source: TestAllTypes { single_double_wrapper: 1.1 }.single_double_wrapper +=====> +bindings: {} +result: 1.1 + +Source: TestAllTypes { single_uint32_wrapper: 2u}.single_uint32_wrapper +=====> +bindings: {} +result: 2 + +Source: TestAllTypes { single_uint64_wrapper: 2u}.single_uint64_wrapper +=====> +bindings: {} +result: 2 + +Source: TestAllTypes { single_list_value: ['a', 1.5, true] }.single_list_value +=====> +bindings: {} +result: [a, 1.5, true] + +Source: TestAllTypes { standalone_message: TestAllTypes.NestedMessage { } }.standalone_message +=====> +bindings: {} +result: + +Source: TestAllTypes { standalone_message: TestAllTypes.NestedMessage { bb: 5} }.standalone_message.bb +=====> +bindings: {} +result: 5 + +Source: TestAllTypes { standalone_enum: TestAllTypes.NestedEnum.BAR }.standalone_enum +=====> +bindings: {} +result: 1 + +Source: TestAllTypes { map_string_string: {'key': 'value'}} +=====> +bindings: {} +result: map_string_string { + key: "key" + value: "value" +} + + +Source: TestAllTypes { map_string_string: {'key': 'value'}}.map_string_string +=====> +bindings: {} +result: {key=value} + +Source: TestAllTypes { map_string_string: {'key': 'value'}}.map_string_string['key'] +=====> +bindings: {} +result: value + +Source: TestAllTypes { single_any: dur }.single_any +declare dur { + value google.protobuf.Timestamp +} +=====> +bindings: {dur=type_url: "type.googleapis.com/google.protobuf.Duration" +value: "\bd" +} +result: PT1M40S + +Source: TestAllTypes { single_any: any_packed_test_msg }.single_any +declare any_packed_test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {any_packed_test_msg=type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes" +value: "r\005hello" +} +result: single_string: "hello" + + +Source: dynamic_msg +declare any_packed_test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare dynamic_msg { + value dev.cel.testing.testdata.serialized.proto3.TestAllTypes +} +=====> +bindings: {dynamic_msg=map_string_string { + key: "foo" + value: "bar" +} +} +result: map_string_string { + key: "foo" + value: "bar" +} + + +Source: dynamic_msg.map_string_string +declare any_packed_test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare dynamic_msg { + value dev.cel.testing.testdata.serialized.proto3.TestAllTypes +} +=====> +bindings: {dynamic_msg=map_string_string { + key: "foo" + value: "bar" +} +} +result: {foo=bar} + +Source: dynamic_msg.map_string_string['foo'] +declare any_packed_test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare dynamic_msg { + value dev.cel.testing.testdata.serialized.proto3.TestAllTypes +} +=====> +bindings: {dynamic_msg=map_string_string { + key: "foo" + value: "bar" +} +} +result: bar + +Source: f_msg(dynamic_msg) +declare any_packed_test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare dynamic_msg { + value dev.cel.testing.testdata.serialized.proto3.TestAllTypes +} +declare f_msg { + function f_msg_generated (cel.expr.conformance.proto3.TestAllTypes) -> bool + function f_msg_dynamic (dev.cel.testing.testdata.serialized.proto3.TestAllTypes) -> bool +} +=====> +bindings: {dynamic_msg=map_string_string { + key: "foo" + value: "bar" +} +, test_msg=single_int64: 10 +} +result: true + +Source: f_msg(test_msg) +declare any_packed_test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare test_msg { + value cel.expr.conformance.proto3.TestAllTypes +} +declare dynamic_msg { + value dev.cel.testing.testdata.serialized.proto3.TestAllTypes +} +declare f_msg { + function f_msg_generated (cel.expr.conformance.proto3.TestAllTypes) -> bool + function f_msg_dynamic (dev.cel.testing.testdata.serialized.proto3.TestAllTypes) -> bool +} +=====> +bindings: {dynamic_msg=map_string_string { + key: "foo" + value: "bar" +} +, test_msg=single_int64: 10 +} +result: true diff --git a/runtime/src/test/resources/extensionManipulation.baseline b/runtime/src/test/resources/extensionManipulation.baseline new file mode 100644 index 000000000..00e2bba9c --- /dev/null +++ b/runtime/src/test/resources/extensionManipulation.baseline @@ -0,0 +1,64 @@ +Source: [y.hasI(), y.getI() == 200, !n.hasI(), n.getI() == 0, + n.assignI(43).hasI(), n.assignI(42).getI() == 42, + y.assignI(99).hasI(), y.assignI(31).getI() == 31, + !n.clearI().hasI(), !y.clearI().hasI(), y.clearI().getI() == 0, + y.hasN(), y.getN().getI() == 0, !y.getN().hasN(), y.getN().getN().getI() == 0, + !n.hasN(), n.assignN(y).getN().hasN(), + !n.clearN().hasN(), !y.clearN().hasN(), + n.getR() == [], y.getR().map(h, h.single_string) == ["alpha", "beta"], + n.assignR(["a", "b"].map(s, TestAllTypes{single_string:s})).getR().map(h, h.single_string) == ["a", "b"], + y.clearR().getR() == []] +declare y { + value cel.expr.conformance.proto2.TestAllTypes +} +declare n { + value cel.expr.conformance.proto2.TestAllTypes +} +declare getI { + function getI cel.expr.conformance.proto2.TestAllTypes.() -> int +} +declare hasI { + function hasI cel.expr.conformance.proto2.TestAllTypes.() -> bool +} +declare assignI { + function assignI cel.expr.conformance.proto2.TestAllTypes.(int) -> cel.expr.conformance.proto2.TestAllTypes +} +declare clearI { + function clearI cel.expr.conformance.proto2.TestAllTypes.() -> cel.expr.conformance.proto2.TestAllTypes +} +declare getN { + function getN cel.expr.conformance.proto2.TestAllTypes.() -> cel.expr.conformance.proto2.TestAllTypes +} +declare hasN { + function hasN cel.expr.conformance.proto2.TestAllTypes.() -> bool +} +declare assignN { + function assignN cel.expr.conformance.proto2.TestAllTypes.(cel.expr.conformance.proto2.TestAllTypes) -> cel.expr.conformance.proto2.TestAllTypes +} +declare clearN { + function clearN cel.expr.conformance.proto2.TestAllTypes.() -> cel.expr.conformance.proto2.TestAllTypes +} +declare getR { + function getR cel.expr.conformance.proto2.TestAllTypes.() -> list(cel.expr.conformance.proto2.TestAllTypes) +} +declare assignR { + function assignR cel.expr.conformance.proto2.TestAllTypes.(list(cel.expr.conformance.proto2.TestAllTypes)) -> cel.expr.conformance.proto2.TestAllTypes +} +declare clearR { + function clearR cel.expr.conformance.proto2.TestAllTypes.() -> cel.expr.conformance.proto2.TestAllTypes +} +=====> +bindings: {y=single_int32: 100 +[cel.expr.conformance.proto2.int32_ext]: 200 +[cel.expr.conformance.proto2.nested_ext] { + single_int32: 50 +} +[cel.expr.conformance.proto2.repeated_test_all_types] { + single_string: "alpha" +} +[cel.expr.conformance.proto2.repeated_test_all_types] { + single_string: "alpha" +} +, n=single_int32: 50 +} +result: [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true] diff --git a/runtime/src/test/resources/fieldManipulation.baseline b/runtime/src/test/resources/fieldManipulation.baseline new file mode 100644 index 000000000..bda3bcac6 --- /dev/null +++ b/runtime/src/test/resources/fieldManipulation.baseline @@ -0,0 +1,119 @@ +Source: TestAllTypes{single_bool: true}.assignSingleInt64(1) == TestAllTypes{single_bool: true, single_int64: 1} +declare assignSingleInt64 { + function assignSingleInt64 cel.expr.conformance.proto3.TestAllTypes.(int) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignRepeatedInt64 { + function assignRepeatedInt64 cel.expr.conformance.proto3.TestAllTypes.(list(int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignMap { + function assignMap cel.expr.conformance.proto3.TestAllTypes.(map(int, int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare clearField { + function clearField cel.expr.conformance.proto3.TestAllTypes.(string) -> cel.expr.conformance.proto3.TestAllTypes +} +declare singletonInt64 { + function singletonInt64 (int) -> cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: TestAllTypes{repeated_int64: [1, 2]}.assignRepeatedInt64([3, 1, 4]) == TestAllTypes{repeated_int64: [3, 1, 4]} +declare assignSingleInt64 { + function assignSingleInt64 cel.expr.conformance.proto3.TestAllTypes.(int) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignRepeatedInt64 { + function assignRepeatedInt64 cel.expr.conformance.proto3.TestAllTypes.(list(int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignMap { + function assignMap cel.expr.conformance.proto3.TestAllTypes.(map(int, int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare clearField { + function clearField cel.expr.conformance.proto3.TestAllTypes.(string) -> cel.expr.conformance.proto3.TestAllTypes +} +declare singletonInt64 { + function singletonInt64 (int) -> cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: TestAllTypes{single_bool: true, single_int64: 1}.clearField("single_bool") == TestAllTypes{single_int64: 1} +declare assignSingleInt64 { + function assignSingleInt64 cel.expr.conformance.proto3.TestAllTypes.(int) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignRepeatedInt64 { + function assignRepeatedInt64 cel.expr.conformance.proto3.TestAllTypes.(list(int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignMap { + function assignMap cel.expr.conformance.proto3.TestAllTypes.(map(int, int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare clearField { + function clearField cel.expr.conformance.proto3.TestAllTypes.(string) -> cel.expr.conformance.proto3.TestAllTypes +} +declare singletonInt64 { + function singletonInt64 (int) -> cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: TestAllTypes{single_bool: false}.assignMap({13: 26, 22: 42}).map_int32_int64[22] == 42 +declare assignSingleInt64 { + function assignSingleInt64 cel.expr.conformance.proto3.TestAllTypes.(int) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignRepeatedInt64 { + function assignRepeatedInt64 cel.expr.conformance.proto3.TestAllTypes.(list(int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignMap { + function assignMap cel.expr.conformance.proto3.TestAllTypes.(map(int, int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare clearField { + function clearField cel.expr.conformance.proto3.TestAllTypes.(string) -> cel.expr.conformance.proto3.TestAllTypes +} +declare singletonInt64 { + function singletonInt64 (int) -> cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: TestAllTypes{single_bool: true, repeated_int64: [1, 2]}.clearField("repeated_int64") == TestAllTypes{single_bool: true} +declare assignSingleInt64 { + function assignSingleInt64 cel.expr.conformance.proto3.TestAllTypes.(int) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignRepeatedInt64 { + function assignRepeatedInt64 cel.expr.conformance.proto3.TestAllTypes.(list(int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignMap { + function assignMap cel.expr.conformance.proto3.TestAllTypes.(map(int, int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare clearField { + function clearField cel.expr.conformance.proto3.TestAllTypes.(string) -> cel.expr.conformance.proto3.TestAllTypes +} +declare singletonInt64 { + function singletonInt64 (int) -> cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: singletonInt64(12) == TestAllTypes{single_int64: 12} +declare assignSingleInt64 { + function assignSingleInt64 cel.expr.conformance.proto3.TestAllTypes.(int) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignRepeatedInt64 { + function assignRepeatedInt64 cel.expr.conformance.proto3.TestAllTypes.(list(int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare assignMap { + function assignMap cel.expr.conformance.proto3.TestAllTypes.(map(int, int)) -> cel.expr.conformance.proto3.TestAllTypes +} +declare clearField { + function clearField cel.expr.conformance.proto3.TestAllTypes.(string) -> cel.expr.conformance.proto3.TestAllTypes +} +declare singletonInt64 { + function singletonInt64 (int) -> cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true diff --git a/runtime/src/test/resources/functionRegistrar.baseline b/runtime/src/test/resources/functionRegistrar.baseline new file mode 100644 index 000000000..5a7129bc4 --- /dev/null +++ b/runtime/src/test/resources/functionRegistrar.baseline @@ -0,0 +1,66 @@ +Source: f_constructor() + "\n" + f_strict("static", 13) + " " + f_strict(dynamic, 14) + "\n" + f_directN("static", true) + " " + f_directN(dynamic, false) + "\n" + f_direct(true, 20) + " " + f_direct(dynamic == "foo", 21) + "\n" + f_direct1("static") + " " + f_direct1(dynamic) + "\n" + f_direct2("static", 30) + " " + f_direct2(dynamic, 31) + "\n" + f_asyncN("static", true) + " " + f_asyncN(dynamic, false) + "\n" + f_async(true, 20) + " " + f_async(dynamic == "foo", 21) + "\n" + f_async1("static") + " " + f_async1(dynamic) + "\n" + f_async2("static", 30) + " " + f_async2(dynamic, 31) + "\n" + f_effect("static") + " " + f_effect(dynamic) + "\n" + f_nobarrier("static") + " " + f_nobarrier(dynamic) + "\n" + f_simple1("static") + " " + f_simple1(dynamic) + "\n" + f_simple2("static", "foo") + " " + f_simple2(dynamic, "bar") + "\n" + f_simpleN("static", 54, 32) + " " + f_simpleN(dynamic, 98,76) +declare dynamic { + value string +} +declare f_constructor { + function f_constructor () -> string +} +declare f_strict { + function f_strict (string, int) -> string +} +declare f_directN { + function f_directN (string, bool) -> string +} +declare f_direct { + function f_direct (bool, int) -> string +} +declare f_direct1 { + function f_direct1 (string) -> string +} +declare f_direct2 { + function f_direct2 (string, int) -> string +} +declare f_asyncN { + function f_asyncN (string, bool) -> string +} +declare f_async { + function f_async (bool, int) -> string +} +declare f_async1 { + function f_async1 (string) -> string +} +declare f_async2 { + function f_async2 (string, int) -> string +} +declare f_effect { + function f_effect (string) -> string +} +declare f_nobarrier { + function f_nobarrier (string) -> string +} +declare f_simple1 { + function f_simple1 (string) -> string +} +declare f_simple2 { + function f_simple2 (string, string) -> string +} +declare f_simpleN { + function f_simpleN (string, int, int) -> string +} +=====> +bindings: {dynamic=dynamic} +result: constructed! +strict: static13 strict: dynamic14 +directN: statictrue directN: dynamicfalse +direct: true20 direct: false21 +direct1:static direct1:dynamic +direct2: static30 direct2: dynamic31 +asyncN: statictrue asyncN: dynamicfalse +async: true20 async: false21 +async1:static async1:dynamic +async2: static30 async2: dynamic31 +effective: static effective: dynamic +nobarrier: static nobarrier: dynamic +simple1: static simple1: dynamic +simple2: static@foo simple2: dynamic@bar +simpleN: static5432 simpleN: dynamic9876 diff --git a/runtime/src/test/resources/globalEnums.baseline b/runtime/src/test/resources/globalEnums.baseline new file mode 100644 index 000000000..1395adf5a --- /dev/null +++ b/runtime/src/test/resources/globalEnums.baseline @@ -0,0 +1,8 @@ +Source: x == dev.cel.testing.testdata.proto3.StandaloneGlobalEnum.SGAR +declare x { + value int +} +=====> +bindings: {x=1} +result: true + diff --git a/runtime/src/test/resources/has.baseline b/runtime/src/test/resources/has.baseline new file mode 100644 index 000000000..a98f2474f --- /dev/null +++ b/runtime/src/test/resources/has.baseline @@ -0,0 +1,23 @@ +Source: has(x.single_int32) && !has(x.single_int64) && has(x.single_bool_wrapper) && has(x.single_int32_wrapper) && !has(x.single_int64_wrapper) && has(x.repeated_int32) && !has(x.repeated_int64) && has(x.optional_bool) && !has(x.optional_string) && has(x.oneof_bool) && !has(x.oneof_type) && has(x.map_int32_int64) && !has(x.map_string_string) && has(x.single_nested_message) && !has(x.single_duration) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_int32: 1 +optional_bool: false +single_nested_message { + bb: 43 +} +repeated_int32: 1 +map_int32_int64 { + key: 1 + value: 2 +} +single_int32_wrapper { + value: 42 +} +single_bool_wrapper { +} +oneof_bool: false +} +result: true diff --git a/runtime/src/test/resources/int64Conversions.baseline b/runtime/src/test/resources/int64Conversions.baseline new file mode 100644 index 000000000..0066c87a1 --- /dev/null +++ b/runtime/src/test/resources/int64Conversions.baseline @@ -0,0 +1,14 @@ +Source: int('-1') +=====> +bindings: {} +result: -1 + +Source: int(2.1) +=====> +bindings: {} +result: 2 + +Source: int(42u) +=====> +bindings: {} +result: 42 \ No newline at end of file diff --git a/runtime/src/test/resources/int64Conversions_error.baseline b/runtime/src/test/resources/int64Conversions_error.baseline new file mode 100644 index 000000000..2a4bda87f --- /dev/null +++ b/runtime/src/test/resources/int64Conversions_error.baseline @@ -0,0 +1,11 @@ +Source: int(18446744073709551615u) +=====> +bindings: {} +error: evaluation error at test_location:3: unsigned out of int range +error_code: NUMERIC_OVERFLOW + +Source: int(1e99) +=====> +bindings: {} +error: evaluation error at test_location:3: double is out of range for int +error_code: NUMERIC_OVERFLOW \ No newline at end of file diff --git a/runtime/src/test/resources/jsonConversions.baseline b/runtime/src/test/resources/jsonConversions.baseline new file mode 100644 index 000000000..3c674b1c4 --- /dev/null +++ b/runtime/src/test/resources/jsonConversions.baseline @@ -0,0 +1,12 @@ +Source: google.protobuf.Struct { fields: {'timestamp': ts, 'duration': du } } +declare ts { + value google.protobuf.Timestamp +} +declare du { + value google.protobuf.Duration +} +=====> +bindings: {ts=seconds: 100 +, du=nanos: 200000000 +} +result: {timestamp=1970-01-01T00:01:40Z, duration=0.200s} diff --git a/runtime/src/test/resources/jsonValueTypes.baseline b/runtime/src/test/resources/jsonValueTypes.baseline new file mode 100644 index 000000000..cc840b24b --- /dev/null +++ b/runtime/src/test/resources/jsonValueTypes.baseline @@ -0,0 +1,191 @@ +Source: x.single_value +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_value { + bool_value: true +} +} +result: true + +Source: x.single_value == double(1) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_value { + number_value: 1.0 +} +} +result: true + +Source: x.single_value == 1.1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_value { + number_value: 1.1 +} +} +result: true + +Source: x.single_value == null +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_value { + null_value: NULL_VALUE +} +} +result: true + +Source: x.single_value == 'hello' +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_value { + string_value: "hello" +} +} +result: true + +Source: google.protobuf.Value{string_value: 'hello'} == 'hello' +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: google.protobuf.Value{number_value: 1.1} == 1.1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: google.protobuf.Value{null_value: google.protobuf.NullValue.NULL_VALUE} == null +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: TestAllTypes{null_value: google.protobuf.NullValue.NULL_VALUE}.null_value == 0 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: TestAllTypes{null_value: google.protobuf.NullValue.NULL_VALUE}.null_value != dyn(null) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: x.single_value[0] == [['hello'], -1.1][0] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_value { + list_value { + values { + list_value { + values { + string_value: "hello" + } + } + } + values { + number_value: -1.1 + } + } +} +} +result: true + +Source: x.single_struct.num == {'str': ['hello'], 'num': -1.1}['num'] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_struct { + fields { + key: "num" + value { + number_value: -1.1 + } + } + fields { + key: "str" + value { + list_value { + values { + string_value: "hello" + } + } + } + } +} +} +result: true + +Source: TestAllTypes{single_struct: TestAllTypes{single_value: {'str': ['hello']}}.single_value} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: single_struct { + fields { + key: "str" + value { + list_value { + values { + string_value: "hello" + } + } + } + } +} + + +Source: pair(x.single_struct.str[0], 'val') +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare pair { + function pair (string, string) -> dyn +} +=====> +bindings: {x=single_struct { + fields { + key: "num" + value { + number_value: -1.1 + } + } + fields { + key: "str" + value { + list_value { + values { + string_value: "hello" + } + } + } + } +} +} +result: {hello=val} \ No newline at end of file diff --git a/runtime/src/test/resources/lateBoundFunctions.baseline b/runtime/src/test/resources/lateBoundFunctions.baseline new file mode 100644 index 000000000..2ae6bddaa --- /dev/null +++ b/runtime/src/test/resources/lateBoundFunctions.baseline @@ -0,0 +1,7 @@ +Source: record('foo', 'bar') +declare record { + function record_string_dyn (string, dyn) -> dyn +} +=====> +bindings: {} +result: bar diff --git a/runtime/src/test/resources/lists.baseline b/runtime/src/test/resources/lists.baseline new file mode 100644 index 000000000..038594505 --- /dev/null +++ b/runtime/src/test/resources/lists.baseline @@ -0,0 +1,97 @@ +Source: ([1, 2, 3] + x.repeated_int32)[3] == 4 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +=====> +bindings: {x=repeated_int32: 4 +} +result: true + +Source: !(y in [1, 2, 3]) && y in [4, 5, 6] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +=====> +bindings: {y=4} +result: true + +Source: TestAllTypes{repeated_int32: [1,2]}.repeated_int32[1] == 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: 1 in TestAllTypes{repeated_int32: [1,2]}.repeated_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: !(4 in [1, 2, 3]) && 1 in [1, 2, 3] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +=====> +bindings: {} +result: true + +Source: !(4 in list) && 1 in list +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +declare list { + value list(int) +} +=====> +bindings: {list=[1, 2, 3]} +result: true + +Source: !(y in list) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +declare list { + value list(int) +} +=====> +bindings: {y=4, list=[1, 2, 3]} +result: true + +Source: y in list +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +declare list { + value list(int) +} +=====> +bindings: {y=1, list=[1, 2, 3]} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/lists_error.baseline b/runtime/src/test/resources/lists_error.baseline new file mode 100644 index 000000000..7fd6cedd7 --- /dev/null +++ b/runtime/src/test/resources/lists_error.baseline @@ -0,0 +1,11 @@ +Source: list[3] +declare y { + value int +} +declare list { + value list(int) +} +=====> +bindings: {y=1, list=[1, 2, 3]} +error: evaluation error at test_location:4: Index out of bounds: 3 +error_code: INDEX_OUT_OF_BOUNDS \ No newline at end of file diff --git a/runtime/src/test/resources/longComprehension.baseline b/runtime/src/test/resources/longComprehension.baseline new file mode 100644 index 000000000..cb6b64e95 --- /dev/null +++ b/runtime/src/test/resources/longComprehension.baseline @@ -0,0 +1,35 @@ +Source: size(constantLongList().map(x, x+1)) == 1000 +declare constantLongList { + function constantLongList () -> list(int) +} +=====> +bindings: {} +result: true + +Source: size(longlist.map(x, x+1)) == 1000 +declare longlist { + value list(int) +} +declare constantLongList { + function constantLongList () -> list(int) +} +=====> +bindings: {longlist=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999]} +result: true + +Source: f_unleash(longlist.map(x, f_slow_inc(x)))[0] == 1 +declare longlist { + value list(int) +} +declare constantLongList { + function constantLongList () -> list(int) +} +declare f_slow_inc { + function f_slow_inc (int) -> int +} +declare f_unleash { + function f_unleash (A) -> A +} +=====> +bindings: {longlist=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999]} +result: true diff --git a/runtime/src/test/resources/maps.baseline b/runtime/src/test/resources/maps.baseline new file mode 100644 index 000000000..ec89b09c6 --- /dev/null +++ b/runtime/src/test/resources/maps.baseline @@ -0,0 +1,143 @@ +Source: {1: 2, 3: 4}[3] == 4 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: 3 in {1: 2, 3: 4} && !(4 in {1: 2, 3: 4}) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: x.map_int32_int64[22] == 23 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=map_int32_int64 { + key: 22 + value: 23 +} +} +result: true + +Source: TestAllTypes{map_int32_int64: {21: 22, 22: 23}}.map_int32_int64[22] == 23 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: TestAllTypes{oneof_type: NestedTestAllTypes{payload: x}}.oneof_type.payload.map_int32_int64[22] == 23 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=map_int32_int64 { + key: 22 + value: 23 +} +} +result: true + +Source: !(4 in map) && 1 in map +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +declare map { + value map(int, int) +} +=====> +bindings: {map={1=4, 2=3, 3=2}} +result: true + +Source: !(y in {1: 4, 2: 3, 3: 2}) && y in {5: 3, 4: 2, 3: 3} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +declare map { + value map(int, int) +} +=====> +bindings: {y=4} +result: true + +Source: !(y in map) && (y + 3) in map +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +declare map { + value map(int, int) +} +=====> +bindings: {y=1, map={4=1, 5=2, 6=3}} +result: true + +Source: TestAllTypes{map_int64_nested_type:{42:NestedTestAllTypes{payload:TestAllTypes{}}}} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +declare map { + value map(int, int) +} +=====> +bindings: {} +result: map_int64_nested_type { + key: 42 + value { + payload { + } + } +} + + +Source: {true: 1, false: 2, true: 3}[true] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +declare map { + value map(int, int) +} +=====> +bindings: {} +error: evaluation error at test_location:20: duplicate map key [true] +error_code: DUPLICATE_ATTRIBUTE + +Source: {b: 1, !b: 2, b: 3}[true] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare y { + value int +} +declare map { + value map(int, int) +} +declare b { + value bool +} +=====> +bindings: {b=true} +error: evaluation error at test_location:14: duplicate map key [true] +error_code: DUPLICATE_ATTRIBUTE diff --git a/runtime/src/test/resources/maxComprehension.baseline b/runtime/src/test/resources/maxComprehension.baseline new file mode 100644 index 000000000..cad955d0f --- /dev/null +++ b/runtime/src/test/resources/maxComprehension.baseline @@ -0,0 +1,42 @@ +Source: size(longlist.map(x, x+1)) == 1000 +declare longlist { + value list(int) +} +=====> +bindings: {longlist=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000]} +error: evaluation error at test_location:17: Iteration budget exceeded: 1000 +error_code: ITERATION_BUDGET_EXCEEDED + +Source: longlist.filter(i, i % 2 == 0).map(i, i * 2).map(i, i / 2).size() == 250 +declare longlist { + value list(int) +} +=====> +bindings: {longlist=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499]} +result: true + +Source: (longlist + [0]).filter(i, i % 2 == 0).map(i, i * 2).map(i, i / 2).size() == 251 +declare longlist { + value list(int) +} +=====> +bindings: {longlist=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499]} +error: evaluation error at test_location:56: Iteration budget exceeded: 1000 +error_code: ITERATION_BUDGET_EXCEEDED + +Source: longlist.map(i, longlist.map(j, longlist.map(k, [i, j, k]))).size() == 9 +declare longlist { + value list(int) +} +=====> +bindings: {longlist=[0, 1, 2, 3, 4, 5, 6, 7, 8]} +result: true + +Source: longlist.map(i, longlist.map(j, longlist.map(k, [i, j, k]))).size() == 9 +declare longlist { + value list(int) +} +=====> +bindings: {longlist=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]} +error: evaluation error at test_location:28: Iteration budget exceeded: 1000 +error_code: ITERATION_BUDGET_EXCEEDED diff --git a/runtime/src/test/resources/messages.baseline b/runtime/src/test/resources/messages.baseline new file mode 100644 index 000000000..f870eb0c3 --- /dev/null +++ b/runtime/src/test/resources/messages.baseline @@ -0,0 +1,33 @@ +Source: x.single_nested_message.bb == 43 && has(x.single_nested_message) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_nested_message { + bb: 43 +} +} +result: true + +Source: single_nested_message.bb == 43 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare single_nested_message { + value cel.expr.conformance.proto3.TestAllTypes.NestedMessage +} +=====> +bindings: {single_nested_message=bb: 43 +} +result: true + +Source: TestAllTypes{single_int64: 1, single_sfixed64: 2, single_int32: 2}.single_int32 == 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare single_nested_message { + value cel.expr.conformance.proto3.TestAllTypes.NestedMessage +} +=====> +bindings: {} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/messages_error.baseline b/runtime/src/test/resources/messages_error.baseline new file mode 100644 index 000000000..47e87cc12 --- /dev/null +++ b/runtime/src/test/resources/messages_error.baseline @@ -0,0 +1,11 @@ +Source: TestAllTypes{single_int32_wrapper: 12345678900} +=====> +bindings: {} +error: evaluation error at test_location:12: Out of range: 12345678900 +error_code: NUMERIC_OVERFLOW + +Source: TestAllTypes{}.map_string_string.a +=====> +bindings: {} +error: evaluation error at test_location:32: key 'a' is not present in map. +error_code: ATTRIBUTE_NOT_FOUND \ No newline at end of file diff --git a/runtime/src/test/resources/namespacedFunctions.baseline b/runtime/src/test/resources/namespacedFunctions.baseline new file mode 100644 index 000000000..e9b8a05d6 --- /dev/null +++ b/runtime/src/test/resources/namespacedFunctions.baseline @@ -0,0 +1,109 @@ +Source: ns.func('hello') +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: 5 + +Source: ns.func('hello').member(ns.func('test')) +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: 9 + +Source: {ns.func('test'): 2} +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: {4=2} + +Source: {2: ns.func('test')} +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: {2=4} + +Source: [ns.func('test'), 2] +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: [4, 2] + +Source: [ns.func('test')].map(x, x * 2) +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: [8] + +Source: [1, 2].map(x, x * ns.func('test')) +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: [4, 8] + +Source: ns.func('hello') +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: 5 + +Source: func('hello') +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: 5 + +Source: func('hello').member(func('test')) +declare ns.func { + function ns_func_overload (string) -> int +} +declare member { + function ns_member_overload int.(int) -> int +} +=====> +bindings: {} +result: 9 diff --git a/runtime/src/test/resources/namespacedVariables.baseline b/runtime/src/test/resources/namespacedVariables.baseline new file mode 100644 index 000000000..9c0db8f0b --- /dev/null +++ b/runtime/src/test/resources/namespacedVariables.baseline @@ -0,0 +1,19 @@ +Source: x +declare ns.x { + value int +} +=====> +bindings: {ns.x=2} +result: 2 + +Source: msgVar.single_int32 +declare ns.x { + value int +} +declare dev.cel.testing.testdata.proto3.msgVar { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {dev.cel.testing.testdata.proto3.msgVar=single_int32: 5 +} +result: 5 \ No newline at end of file diff --git a/runtime/src/test/resources/nestedEnums.baseline b/runtime/src/test/resources/nestedEnums.baseline new file mode 100644 index 000000000..e7e2199bf --- /dev/null +++ b/runtime/src/test/resources/nestedEnums.baseline @@ -0,0 +1,30 @@ +Source: x.single_nested_enum == TestAllTypes.NestedEnum.BAR +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_nested_enum: BAR +} +result: true + +Source: single_nested_enum == TestAllTypes.NestedEnum.BAR +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare single_nested_enum { + value int +} +=====> +bindings: {single_nested_enum=1} +result: true + +Source: TestAllTypes{single_nested_enum : TestAllTypes.NestedEnum.BAR}.single_nested_enum == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare single_nested_enum { + value int +} +=====> +bindings: {} +result: true diff --git a/runtime/src/test/resources/nobarrierFunction.baseline b/runtime/src/test/resources/nobarrierFunction.baseline new file mode 100644 index 000000000..42a5637f6 --- /dev/null +++ b/runtime/src/test/resources/nobarrierFunction.baseline @@ -0,0 +1,16 @@ +Source: F(true, 2, 1 / 0) +declare F { + function F (bool, int, int) -> int +} +=====> +bindings: {} +result: 2 + +Source: F(false, 3, 1 / 0) +declare F { + function F (bool, int, int) -> int +} +=====> +bindings: {} +error: evaluation error: / by zero + diff --git a/runtime/src/test/resources/nonstrictQuantifierTests.baseline b/runtime/src/test/resources/nonstrictQuantifierTests.baseline new file mode 100644 index 000000000..728e4bfc9 --- /dev/null +++ b/runtime/src/test/resources/nonstrictQuantifierTests.baseline @@ -0,0 +1,49 @@ +Source: [0, 2, 4].exists(x, 4/x == 2 && 4/(4-x) == 2) +=====> +bindings: {} +result: true + +Source: ![0, 2, 4].all(x, 4/x != 2 && 4/(4-x) != 2) +=====> +bindings: {} +result: true + +Source: [0, 2, 4].exists(x, four/x == 2 && four/(four-x) == 2) +declare four { + value int +} +=====> +bindings: {four=4} +result: true + +Source: ![0, 2, 4].all(x, four/x != 2 && four/(four-x) != 2) +declare four { + value int +} +=====> +bindings: {four=4} +result: true + +Source: [0, 2, four].exists(x, four/x == 2 && four/(four-x) == 2) +declare four { + value int +} +=====> +bindings: {four=4} +result: true + +Source: ![0, 2, four].all(x, four/x != 2 && four/(four-x) != 2) +declare four { + value int +} +=====> +bindings: {four=4} +result: true + +Source: [0, 1].exists(x, x > four || true) +declare four { + value int +} +=====> +bindings: {} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/nullAssignability.baseline b/runtime/src/test/resources/nullAssignability.baseline new file mode 100644 index 000000000..b60f434ea --- /dev/null +++ b/runtime/src/test/resources/nullAssignability.baseline @@ -0,0 +1,64 @@ +Source: TestAllTypes{single_int64_wrapper: null}.single_int64_wrapper == null +=====> +bindings: {} +result: true + +Source: TestAllTypes{}.single_int64_wrapper == null +=====> +bindings: {} +result: true + +Source: has(TestAllTypes{single_int64_wrapper: null}.single_int64_wrapper) +=====> +bindings: {} +result: false + +Source: TestAllTypes{single_value: null}.single_value == null +=====> +bindings: {} +result: true + +Source: has(TestAllTypes{single_value: null}.single_value) +=====> +bindings: {} +result: true + +Source: TestAllTypes{single_timestamp: null}.single_timestamp == timestamp(0) +=====> +bindings: {} +result: true + +Source: has(TestAllTypes{single_timestamp: null}.single_timestamp) +=====> +bindings: {} +result: false + +Source: TestAllTypes{repeated_timestamp: [timestamp(1), null]}.repeated_timestamp == [timestamp(1)] +=====> +bindings: {} +result: true + +Source: TestAllTypes{map_bool_timestamp: {true: null, false: timestamp(1)}}.map_bool_timestamp == {false: timestamp(1)} +=====> +bindings: {} +result: true + +Source: TestAllTypes{repeated_any: [1, null]}.repeated_any == [1, null] +=====> +bindings: {} +result: true + +Source: TestAllTypes{map_bool_any: {true: null, false: 1}}.map_bool_any == {true: null, false: 1} +=====> +bindings: {} +result: true + +Source: TestAllTypes{repeated_value: [google.protobuf.Value{bool_value: true}, null]}.repeated_value == [true, null] +=====> +bindings: {} +result: true + +Source: TestAllTypes{map_bool_value: {true: null, false: google.protobuf.Value{bool_value: true}}}.map_bool_value == {true: null, false: true} +=====> +bindings: {} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/optional.baseline b/runtime/src/test/resources/optional.baseline new file mode 100644 index 000000000..1e32c2696 --- /dev/null +++ b/runtime/src/test/resources/optional.baseline @@ -0,0 +1,12 @@ +Source: optional.unwrap([]) +=====> +bindings: {} +result: [] + +Source: optional.unwrap([optional.none(), optional.of(1), optional.of(str)]) +declare str { + value string +} +=====> +bindings: {str=foo} +result: [1, foo] diff --git a/runtime/src/test/resources/optional_errors.baseline b/runtime/src/test/resources/optional_errors.baseline new file mode 100644 index 000000000..18b2846fe --- /dev/null +++ b/runtime/src/test/resources/optional_errors.baseline @@ -0,0 +1,5 @@ +Source: optional.unwrap([dyn(1)]) +=====> +bindings: {} +error: evaluation error at test_location:15: Function 'optional_unwrap_list' failed with arg(s) '[1]' +error_code: INTERNAL_ERROR \ No newline at end of file diff --git a/runtime/src/test/resources/packUnpackAny.baseline b/runtime/src/test/resources/packUnpackAny.baseline new file mode 100644 index 000000000..0ebfa02ae --- /dev/null +++ b/runtime/src/test/resources/packUnpackAny.baseline @@ -0,0 +1,274 @@ +Source: any == d +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {d=seconds: 100 +} +> {any=type_url: "type.googleapis.com/google.protobuf.Duration" +value: "\bd" +} +result: true + +Source: any == message.single_any +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {message=single_any { + type_url: "type.googleapis.com/google.protobuf.Duration" + value: "\bd" +} +} +> {any=type_url: "type.googleapis.com/google.protobuf.Duration" +value: "\bd" +} +result: true + +Source: d == message.single_any +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {message=single_any { + type_url: "type.googleapis.com/google.protobuf.Duration" + value: "\bd" +} +} +> {d=seconds: 100 +} +result: true + +Source: any.single_int64 == 1 +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {any=single_int64: 1 +} +result: true + +Source: any == 1 +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {any=type_url: "type.googleapis.com/google.protobuf.Int64Value" +value: "\b\001" +} +result: true + +Source: list[0] == message +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {list=[type_url: "type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes" +value: "\242\0062\n,type.googleapis.com/google.protobuf.Duration\022\002\bd" +], message=single_any { + type_url: "type.googleapis.com/google.protobuf.Duration" + value: "\bd" +} +} +result: true + +Source: TestAllTypes{single_any: d} +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {d=seconds: 100 +} +result: single_any { + type_url: "type.googleapis.com/google.protobuf.Duration" + value: "\bd" +} + + +Source: TestAllTypes{single_any: message.single_int64} +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {message=single_int64: -1 +} +result: single_any { + type_url: "type.googleapis.com/google.protobuf.Int64Value" + value: "\b\377\377\377\377\377\377\377\377\377\001" +} + + +Source: TestAllTypes{single_any: message.single_uint64} +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {message=single_uint64: 1 +} +result: single_any { + type_url: "type.googleapis.com/google.protobuf.UInt64Value" + value: "\b\001" +} + + +Source: TestAllTypes{single_any: 1.0} +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {} +result: single_any { + type_url: "type.googleapis.com/google.protobuf.DoubleValue" + value: "\t\000\000\000\000\000\000\360?" +} + + +Source: TestAllTypes{single_any: true} +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {} +result: single_any { + type_url: "type.googleapis.com/google.protobuf.BoolValue" + value: "\b\001" +} + + +Source: TestAllTypes{single_any: "happy"} +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {} +result: single_any { + type_url: "type.googleapis.com/google.protobuf.StringValue" + value: "\n\005happy" +} + + +Source: TestAllTypes{single_any: message.single_bytes} +declare any { + value any +} +declare d { + value google.protobuf.Duration +} +declare message { + value cel.expr.conformance.proto3.TestAllTypes +} +declare list { + value list(dyn) +} +=====> +bindings: {message=single_bytes: "happy" +} +result: single_any { + type_url: "type.googleapis.com/google.protobuf.BytesValue" + value: "\n\005happy" +} diff --git a/runtime/src/test/resources/planner_optional_errors.baseline b/runtime/src/test/resources/planner_optional_errors.baseline new file mode 100644 index 000000000..3d59fefca --- /dev/null +++ b/runtime/src/test/resources/planner_optional_errors.baseline @@ -0,0 +1,5 @@ +Source: optional.unwrap([dyn(1)]) +=====> +bindings: {} +error: evaluation error at test_location:15: Function 'optional.unwrap' failed with arg(s) '[1]' +error_code: INTERNAL_ERROR diff --git a/runtime/src/test/resources/planner_unknownFieldSelection.baseline b/runtime/src/test/resources/planner_unknownFieldSelection.baseline new file mode 100644 index 000000000..0cbc75299 --- /dev/null +++ b/runtime/src/test/resources/planner_unknownFieldSelection.baseline @@ -0,0 +1,111 @@ +Source: x +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=, unknown_attributes=[x]} +result: CelUnknownSet{attributes=[x], unknownExprIds=[1]} + +Source: x +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x], unknownExprIds=[1]} + +Source: x.single_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x]} +result: CelUnknownSet{attributes=[x], unknownExprIds=[2]} + +Source: x.single_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[2]} + +Source: x.map_int32_int64[22] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x]} +result: CelUnknownSet{attributes=[x], unknownExprIds=[2]} + +Source: x.map_int32_int64[22] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x.map_int32_int64]} +result: CelUnknownSet{attributes=[x.map_int32_int64], unknownExprIds=[2]} + +Source: x.repeated_nested_message[1] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x]} +result: CelUnknownSet{attributes=[x], unknownExprIds=[2]} + +Source: x.repeated_nested_message[1] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x.repeated_nested_message]} +result: CelUnknownSet{attributes=[x.repeated_nested_message], unknownExprIds=[2]} + +Source: x.single_nested_message.bb +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x]} +result: CelUnknownSet{attributes=[x], unknownExprIds=[3]} + +Source: x.single_nested_message.bb +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x.single_nested_message.bb]} +result: CelUnknownSet{attributes=[x.single_nested_message.bb], unknownExprIds=[3]} + +Source: {1: x.single_int32} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x]} +result: CelUnknownSet{attributes=[x], unknownExprIds=[5]} + +Source: {1: x.single_int32} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[5]} + +Source: [1, x.single_int32] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x]} +result: CelUnknownSet{attributes=[x], unknownExprIds=[4]} + +Source: [1, x.single_int32] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[4]} diff --git a/runtime/src/test/resources/planner_unknownResultSet_errors.baseline b/runtime/src/test/resources/planner_unknownResultSet_errors.baseline new file mode 100644 index 000000000..7885e9da1 --- /dev/null +++ b/runtime/src/test/resources/planner_unknownResultSet_errors.baseline @@ -0,0 +1,81 @@ +Source: x.single_int32 == 1 && x.single_timestamp <= timestamp("bad timestamp string") +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[2]} + +Source: x.single_timestamp <= timestamp("bad timestamp string") && x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[8]} + +Source: x.single_timestamp <= timestamp("bad timestamp string") && x.single_timestamp > timestamp("another bad timestamp string") +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +error: evaluation error at test_location:31: Text 'bad timestamp string' could not be parsed at index 0 +error_code: BAD_FORMAT + +Source: x.single_int32 == 1 || x.single_timestamp <= timestamp("bad timestamp string") +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[2]} + +Source: x.single_timestamp <= timestamp("bad timestamp string") || x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[8]} + +Source: x.single_timestamp <= timestamp("bad timestamp string") || x.single_timestamp > timestamp("another bad timestamp string") +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +error: evaluation error at test_location:31: Text 'bad timestamp string' could not be parsed at index 0 +error_code: BAD_FORMAT + +Source: x +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {unknown_attributes=[x]} +result: CelUnknownSet{attributes=[x], unknownExprIds=[1]} \ No newline at end of file diff --git a/runtime/src/test/resources/planner_unknownResultSet_success.baseline b/runtime/src/test/resources/planner_unknownResultSet_success.baseline new file mode 100644 index 000000000..c5e8867db --- /dev/null +++ b/runtime/src/test/resources/planner_unknownResultSet_success.baseline @@ -0,0 +1,473 @@ +Source: x.single_int32 == 1 && true +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[2]} + +Source: x.single_int32 == 1 && false +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: false + +Source: x.single_int32 == 1 && x.single_int64 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int32, x.single_int64], unknownExprIds=[2, 7]} + +Source: true && x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[4]} + +Source: false && x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: false + +Source: x.single_int32 == 1 || x.single_string == "test" +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: true + +Source: x.single_int32 == 1 || x.single_string != "test" +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[2]} + +Source: x.single_int32 == 1 || x.single_int64 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int32, x.single_int64], unknownExprIds=[2, 7]} + +Source: true || x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: true + +Source: false || x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[4]} + +Source: x.single_int32.f(1) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[2]} + +Source: 1.f(x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[4]} + +Source: x.single_int64.f(x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int32, x.single_int64], unknownExprIds=[2, 5]} + +Source: [0, 2, 4].exists(z, z == 2 || z == x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: true + +Source: [0, 2, 4].exists(z, z == x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[10]} + +Source: [0, 2, 4].exists_one(z, z == 0 || (z == 2 && z == x.single_int32) || (z == 4 && z == x.single_int64)) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int64], unknownExprIds=[27]} + +Source: [0, 2].all(z, z == 2 || z == x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[13]} + +Source: [0, 2, 4].filter(z, z == 0 || (z == 2 && z == x.single_int32) || (z == 4 && z == x.single_int64)) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int64], unknownExprIds=[27]} + +Source: [0, 2, 4].map(z, z == 0 || (z == 2 && z == x.single_int32) || (z == 4 && z == x.single_int64)) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int32, x.single_int64], unknownExprIds=[18, 27]} + +Source: x.single_int32 == 1 ? 1 : 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[2]} + +Source: true ? x.single_int32 : 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[4]} + +Source: true ? 1 : x.single_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: 1 + +Source: false ? x.single_int32 : 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: 2 + +Source: false ? 1 : x.single_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[5]} + +Source: x.single_int64 == 1 ? x.single_int32 : x.single_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int64], unknownExprIds=[2]} + +Source: {x.single_int32: 2, 3: 4} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[4]} + +Source: {1: x.single_int32, 3: 4} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[5]} + +Source: {1: x.single_int32, x.single_int64: 4} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int32, x.single_int64], unknownExprIds=[5, 8]} + +Source: [1, x.single_int32, 3, 4] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[4]} + +Source: [1, x.single_int32, x.single_int64, 4] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int32, x.single_int64], unknownExprIds=[4, 6]} + +Source: TestAllTypes{single_int32: x.single_int32}.single_int32 == 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32]} +result: CelUnknownSet{attributes=[x.single_int32], unknownExprIds=[4]} + +Source: TestAllTypes{single_int32: x.single_int32, single_int64: x.single_int64} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x.single_int32, x.single_int64]} +result: CelUnknownSet{attributes=[x.single_int32, x.single_int64], unknownExprIds=[4, 7]} + +Source: unknown_list.map(x, x) +declare unknown_list { + value list(int) +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[unknown_list]} +result: CelUnknownSet{attributes=[unknown_list], unknownExprIds=[1]} + +Source: cel.bind(x, [1, 2, 3], 1 in x) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_string: "test" +single_timestamp { + seconds: 15 +} +, unknown_attributes=[x]} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/quantifiers.baseline b/runtime/src/test/resources/quantifiers.baseline new file mode 100644 index 000000000..48468ec90 --- /dev/null +++ b/runtime/src/test/resources/quantifiers.baseline @@ -0,0 +1,29 @@ +Source: [1,-2,3].exists_one(x, x > 0) +=====> +bindings: {} +result: false + +Source: [-1,-2,3].exists_one(x, x > 0) +=====> +bindings: {} +result: true + +Source: [-1,-2,-3].exists(x, x > 0) +=====> +bindings: {} +result: false + +Source: [1,-2,3].exists(x, x > 0) +=====> +bindings: {} +result: true + +Source: [1,-2,3].all(x, x > 0) +=====> +bindings: {} +result: false + +Source: [1,2,3].all(x, x > 0) +=====> +bindings: {} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/regexpMatches_error.baseline b/runtime/src/test/resources/regexpMatches_error.baseline new file mode 100644 index 000000000..38ff64033 --- /dev/null +++ b/runtime/src/test/resources/regexpMatches_error.baseline @@ -0,0 +1,11 @@ +Source: matches("alpha", "**") +=====> +bindings: {} +error: evaluation error at test_location:7: error parsing regexp: missing argument to repetition operator: `*` +error_code: INVALID_ARGUMENT + +Source: "alpha".matches("**") +=====> +bindings: {} +error: evaluation error at test_location:15: error parsing regexp: missing argument to repetition operator: `*` +error_code: INVALID_ARGUMENT \ No newline at end of file diff --git a/runtime/src/test/resources/regexpMatchingTests.baseline b/runtime/src/test/resources/regexpMatchingTests.baseline new file mode 100644 index 000000000..4700946eb --- /dev/null +++ b/runtime/src/test/resources/regexpMatchingTests.baseline @@ -0,0 +1,319 @@ +Source: matches("alpha", "^al.*") == true +=====> +bindings: {} +result: true + +Source: matches("alpha", "^.al.*") == false +=====> +bindings: {} +result: true + +Source: matches("alpha", ".*ha$") == true +=====> +bindings: {} +result: true + +Source: matches("alpha", "^.*ha.$") == false +=====> +bindings: {} +result: true + +Source: matches("alpha", "") == true +=====> +bindings: {} +result: true + +Source: matches("alpha", "ph") == true +=====> +bindings: {} +result: true + +Source: matches("alpha", "^ph") == false +=====> +bindings: {} +result: true + +Source: matches("alpha", "ph$") == false +=====> +bindings: {} +result: true + +Source: "alpha".matches("^al.*") == true +=====> +bindings: {} +result: true + +Source: "alpha".matches("^.al.*") == false +=====> +bindings: {} +result: true + +Source: "alpha".matches(".*ha$") == true +=====> +bindings: {} +result: true + +Source: "alpha".matches(".*ha.$") == false +=====> +bindings: {} +result: true + +Source: "alpha".matches("") == true +=====> +bindings: {} +result: true + +Source: "alpha".matches("ph") == true +=====> +bindings: {} +result: true + +Source: "alpha".matches("^ph") == false +=====> +bindings: {} +result: true + +Source: "alpha".matches("ph$") == false +=====> +bindings: {} +result: true + +Source: matches("alpha", regexp) == true +declare regexp { + value string +} +=====> +bindings: {regexp=^al.*} +result: true + +Source: matches("alpha", regexp) == false +declare regexp { + value string +} +=====> +bindings: {regexp=^.al.*} +result: true + +Source: matches("alpha", regexp) == true +declare regexp { + value string +} +=====> +bindings: {regexp=.*ha$} +result: true + +Source: matches("alpha", regexp) == false +declare regexp { + value string +} +=====> +bindings: {regexp=.*ha.$} +result: true + +Source: "alpha".matches(regexp) == true +declare regexp { + value string +} +=====> +bindings: {regexp=^al.*} +result: true + +Source: "alpha".matches(regexp) == false +declare regexp { + value string +} +=====> +bindings: {regexp=^.al.*} +result: true + +Source: "alpha".matches(regexp) == true +declare regexp { + value string +} +=====> +bindings: {regexp=.*ha$} +result: true + +Source: "alpha".matches(regexp) == false +declare regexp { + value string +} +=====> +bindings: {regexp=.*ha.$} +result: true + +Source: matches(s, "^al.*") == true +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha} +result: true + +Source: matches(s, "^.al.*") == false +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha} +result: true + +Source: matches(s, ".*ha$") == true +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha} +result: true + +Source: matches(s, "^.*ha.$") == false +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha} +result: true + +Source: s.matches("^al.*") == true +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha} +result: true + +Source: s.matches("^.al.*") == false +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha} +result: true + +Source: s.matches(".*ha$") == true +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha} +result: true + +Source: s.matches("^.*ha.$") == false +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha} +result: true + +Source: matches(s, regexp) == true +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha, regexp=^al.*} +result: true + +Source: matches(s, regexp) == true +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha, regexp=.*ha$} +result: true + +Source: matches(s, regexp) == false +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha, regexp=^.al.*} +result: true + +Source: matches(s, regexp) == false +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha, regexp=.*ha.$} +result: true + +Source: s.matches(regexp) == true +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha, regexp=^al.*} +result: true + +Source: s.matches(regexp) == true +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha, regexp=.*ha$} +result: true + +Source: s.matches(regexp) == false +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha, regexp=^.al.*} +result: true + +Source: s.matches(regexp) == false +declare regexp { + value string +} +declare s { + value string +} +=====> +bindings: {s=alpha, regexp=.*ha.$} +result: true diff --git a/runtime/src/test/resources/sizeTests.baseline b/runtime/src/test/resources/sizeTests.baseline new file mode 100644 index 000000000..0bf9e29a5 --- /dev/null +++ b/runtime/src/test/resources/sizeTests.baseline @@ -0,0 +1,54 @@ +Source: size(b) == 5 && b.size() == 5 +declare str { + value string +} +declare b { + value bytes +} +=====> +bindings: {b=[104, 97, 112, 112, 121]} +result: true + +Source: size(str) == 5 && str.size() == 5 +declare str { + value string +} +declare b { + value bytes +} +=====> +bindings: {str=happy} +result: true + +Source: size(str) == 5 && str.size() == 5 +declare str { + value string +} +declare b { + value bytes +} +=====> +bindings: {str=happ􏿼} +result: true + +Source: size({1:14, 2:15}) == 2 && {1:14, 2:15}.size() == 2 +declare str { + value string +} +declare b { + value bytes +} +=====> +bindings: {} +result: true + +Source: size([1,2,3]) == 3 && [1,2,3].size() == 3 +declare str { + value string +} +declare b { + value bytes +} +=====> +bindings: {} +result: true diff --git a/runtime/src/test/resources/stashedLocal.baseline b/runtime/src/test/resources/stashedLocal.baseline new file mode 100644 index 000000000..d34beccfa --- /dev/null +++ b/runtime/src/test/resources/stashedLocal.baseline @@ -0,0 +1,10 @@ +Source: f_stash([1, 2, 3].map(x, x + f_grab())) == [124, 125, 126] +declare f_stash { + function f_stash (T) -> T +} +declare f_grab { + function f_grab () -> int +} +=====> +bindings: {} +result: true diff --git a/runtime/src/test/resources/stringConversions.baseline b/runtime/src/test/resources/stringConversions.baseline new file mode 100644 index 000000000..9dec559ae --- /dev/null +++ b/runtime/src/test/resources/stringConversions.baseline @@ -0,0 +1,44 @@ +Source: string(1.1) +=====> +bindings: {} +result: 1.1 + +Source: string(2u) +=====> +bindings: {} +result: 2 + +Source: string(-1) +=====> +bindings: {} +result: -1 + +Source: string(true) +=====> +bindings: {} +result: true + +Source: string(b'abc\303\203') +=====> +bindings: {} +result: abcà + +Source: string(bytes('abc\303')) +=====> +bindings: {} +result: abcà + +Source: string(timestamp('2009-02-13T23:31:30Z')) +=====> +bindings: {} +result: 2009-02-13T23:31:30Z + +Source: string(duration('1000000s')) +=====> +bindings: {} +result: 1000000s + +Source: string('hello') +=====> +bindings: {} +result: hello \ No newline at end of file diff --git a/runtime/src/test/resources/stringConversions_error.baseline b/runtime/src/test/resources/stringConversions_error.baseline new file mode 100644 index 000000000..174a70b91 --- /dev/null +++ b/runtime/src/test/resources/stringConversions_error.baseline @@ -0,0 +1,5 @@ +Source: string(b'\xff') +=====> +bindings: {} +error: evaluation error at test_location:6: invalid UTF-8 in bytes, cannot convert to string +error_code: BAD_FORMAT diff --git a/runtime/src/test/resources/strings.baseline b/runtime/src/test/resources/strings.baseline new file mode 100644 index 000000000..6b222258a --- /dev/null +++ b/runtime/src/test/resources/strings.baseline @@ -0,0 +1,12 @@ +Source: 'a' < 'b' && 'a' <= 'b' && 'b' > 'a' && 'a' >= 'a' && 'a' == 'a' && 'a' != 'b' +=====> +bindings: {} +result: true + +Source: 'abc' + x == 'abcdef' && x.endsWith('ef') && x.startsWith('d') && x.contains('de') && !x.contains('abcdef') +declare x { + value string +} +=====> +bindings: {x=def} +result: true diff --git a/runtime/src/test/resources/timeConversions.baseline b/runtime/src/test/resources/timeConversions.baseline new file mode 100644 index 000000000..12a521441 --- /dev/null +++ b/runtime/src/test/resources/timeConversions.baseline @@ -0,0 +1,55 @@ +Source: timestamp("1972-01-01T10:00:20.021-05:00") +declare t1 { + value google.protobuf.Timestamp +} +=====> +bindings: {} +result: 1972-01-01T15:00:20.021Z + +Source: timestamp(123) +declare t1 { + value google.protobuf.Timestamp +} +=====> +bindings: {} +result: 1970-01-01T00:02:03Z + +Source: duration("15.11s") +declare t1 { + value google.protobuf.Timestamp +} +=====> +bindings: {} +result: PT15.11S + +Source: int(t1) == 100 +declare t1 { + value google.protobuf.Timestamp +} +=====> +bindings: {t1=1970-01-01T00:01:40Z} +result: true + +Source: duration("1h2m3.4s") +declare t1 { + value google.protobuf.Timestamp +} +=====> +bindings: {} +result: PT1H2M3.4S + +Source: duration(duration('15.0s')) +declare t1 { + value google.protobuf.Timestamp +} +=====> +bindings: {} +result: PT15S + +Source: timestamp(timestamp(123)) +declare t1 { + value google.protobuf.Timestamp +} +=====> +bindings: {} +result: 1970-01-01T00:02:03Z \ No newline at end of file diff --git a/runtime/src/test/resources/timeConversions_error.baseline b/runtime/src/test/resources/timeConversions_error.baseline new file mode 100644 index 000000000..3b331a3d8 --- /dev/null +++ b/runtime/src/test/resources/timeConversions_error.baseline @@ -0,0 +1,5 @@ +Source: duration('inf') +=====> +bindings: {} +error: evaluation error at test_location:8: invalid duration format +error_code: BAD_FORMAT \ No newline at end of file diff --git a/runtime/src/test/resources/timestamp.baseline b/runtime/src/test/resources/timestamp.baseline new file mode 100644 index 000000000..828e7f912 --- /dev/null +++ b/runtime/src/test/resources/timestamp.baseline @@ -0,0 +1,219 @@ +Source: t1 < t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000009Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: false + +Source: t1 < t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:09.000000010Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: false + +Source: t1 < t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: false + +Source: t1 < t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:10.000000009Z} +result: true + +Source: t1 < t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:09.000000010Z} +result: true + +Source: t1 <= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000009Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: false + +Source: t1 <= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:09.000000010Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: false + +Source: t1 <= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: true + +Source: t1 <= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:10.000000009Z} +result: true + +Source: t1 <= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:09.000000010Z} +result: true + +Source: t1 > t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000009Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: true + +Source: t1 > t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:09.000000010Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: true + +Source: t1 > t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: false + +Source: t1 > t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:10.000000009Z} +result: false + +Source: t1 > t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:09.000000010Z} +result: false + +Source: t1 >= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000009Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: true + +Source: t1 >= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:09.000000010Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: true + +Source: t1 >= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:10.000000010Z} +result: true + +Source: t1 >= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:10.000000009Z} +result: false + +Source: t1 >= t2 +declare t1 { + value google.protobuf.Timestamp +} +declare t2 { + value google.protobuf.Timestamp +} +=====> +bindings: {t2=1970-01-01T00:00:10.000000010Z} +> {t1=1970-01-01T00:00:09.000000010Z} +result: false \ No newline at end of file diff --git a/runtime/src/test/resources/timestampFunctions.baseline b/runtime/src/test/resources/timestampFunctions.baseline new file mode 100644 index 000000000..e932867e8 --- /dev/null +++ b/runtime/src/test/resources/timestampFunctions.baseline @@ -0,0 +1,501 @@ +Source: ts1.getFullYear("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1969 + +Source: ts1.getFullYear() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1970 + +Source: ts1.getFullYear() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1969-12-31T23:59:59Z} +result: 1969 + +Source: ts1.getFullYear("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1970 + +Source: ts1.getFullYear("2:00") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1970 + +Source: ts1.getMonth("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 11 + +Source: ts1.getMonth() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getMonth() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1969-12-31T23:59:59Z} +result: 11 + +Source: ts1.getMonth("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getMonth("-8:15") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 11 + +Source: ts1.getDayOfYear("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 364 + +Source: ts1.getDayOfYear() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getDayOfYear() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1969-12-31T23:59:59Z} +result: 364 + +Source: ts1.getDayOfYear("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getDayOfYear("-9:00") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 364 + +Source: ts1.getDayOfMonth("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 30 + +Source: ts1.getDayOfMonth() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getDayOfMonth() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1969-12-31T23:59:59Z} +result: 30 + +Source: ts1.getDayOfMonth("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getDayOfMonth("8:00") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getDate("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 31 + +Source: ts1.getDate() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1 + +Source: ts1.getDate() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1969-12-31T23:59:59Z} +result: 31 + +Source: ts1.getDate("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1 + +Source: ts1.getDate("9:30") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1 + +Source: ts1.getDayOfWeek("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-04T00:00:00Z} +result: 6 + +Source: ts1.getDayOfWeek() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-04T00:00:00Z} +result: 0 + +Source: ts1.getDayOfWeek() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1969-12-31T23:59:59Z} +result: 3 + +Source: ts1.getDayOfWeek("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-04T00:00:00Z} +result: 0 + +Source: ts1.getDayOfWeek("-9:30") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-04T00:00:00Z} +result: 6 + +Source: ts1.getHours("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 16 + +Source: ts1.getHours() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getHours() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1969-12-31T23:59:59Z} +result: 23 + +Source: ts1.getHours("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 6 + +Source: ts1.getHours("6:30") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 6 + +Source: ts1.getMinutes("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getMinutes() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getMinutes() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1969-12-31T23:59:59Z} +result: 59 + +Source: ts1.getMinutes("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 30 + +Source: ts1.getMinutes("-8:00") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 0 + +Source: ts1.getSeconds("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1 + +Source: ts1.getSeconds() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1 + +Source: ts1.getSeconds() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1969-12-31T23:59:59Z} +result: 59 + +Source: ts1.getSeconds("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1 + +Source: ts1.getSeconds("-8:00") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 1 + +Source: ts1.getMilliseconds("America/Los_Angeles") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 11 + +Source: ts1.getMilliseconds() +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 11 + +Source: ts1.getMilliseconds("Indian/Cocos") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 11 + +Source: ts1.getMilliseconds("-8:00") +declare ts1 { + value google.protobuf.Timestamp +} +=====> +bindings: {ts1=1970-01-01T00:00:01.011Z} +result: 11 + +Source: ts1.getFullYear() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=2013} +> {ts1=1970-01-01T00:00:01.011Z} +result: true + +Source: ts1.getMonth() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=12} +> {ts1=1970-01-01T00:00:01.011Z} +result: true + +Source: ts1.getDayOfYear() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=13} +> {ts1=1970-01-01T00:00:01.011Z} +result: true + +Source: ts1.getDayOfMonth() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=10} +> {ts1=1970-01-01T00:00:01.011Z} +result: true + +Source: ts1.getDate() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=15} +> {ts1=1970-01-01T00:00:01.011Z} +result: true + +Source: ts1.getDayOfWeek() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=15} +> {ts1=1970-01-01T00:00:01.011Z} +result: true + +Source: ts1.getHours() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=15} +> {ts1=1970-01-01T00:00:01.011Z} +result: true + +Source: ts1.getMinutes() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=15} +> {ts1=1970-01-01T00:00:01.011Z} +result: true + +Source: ts1.getSeconds() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=15} +> {ts1=1970-01-01T00:00:01.011Z} +result: true + +Source: ts1.getMilliseconds() < val +declare ts1 { + value google.protobuf.Timestamp +} +declare val { + value int +} +=====> +bindings: {val=15} +> {ts1=1970-01-01T00:00:01.011Z} +result: true \ No newline at end of file diff --git a/runtime/src/test/resources/typeComparisons.baseline b/runtime/src/test/resources/typeComparisons.baseline new file mode 100644 index 000000000..e8fc3473f --- /dev/null +++ b/runtime/src/test/resources/typeComparisons.baseline @@ -0,0 +1,55 @@ +Source: type(1) == int && type(1u) == uint && type(1u) != int && type(1) != uint && type(uint(1.1)) == uint && type(1.1) == double +=====> +bindings: {} +result: true + +Source: type('hello') == string && type(b'¿') == bytes +=====> +bindings: {} +result: true + +Source: type([1, 2, 3]) == list && type({'a': 1, 'b': 2}) == map +=====> +bindings: {} +result: true + +Source: type(true) == bool && type(false) == bool +=====> +bindings: {} +result: true + +Source: type(duration('10s')) == google.protobuf.Duration +=====> +bindings: {} +result: true + +Source: type(TestAllTypes{}) == TestAllTypes && type(TestAllTypes{}) == proto3.TestAllTypes && type(TestAllTypes{}) == .cel.expr.conformance.proto3.TestAllTypes && type(proto3.TestAllTypes{}) == TestAllTypes && type(proto3.TestAllTypes{}) == proto3.TestAllTypes && type(proto3.TestAllTypes{}) == .cel.expr.conformance.proto3.TestAllTypes && type(.cel.expr.conformance.proto3.TestAllTypes{}) == TestAllTypes && type(.cel.expr.conformance.proto3.TestAllTypes{}) == proto3.TestAllTypes && type(.cel.expr.conformance.proto3.TestAllTypes{}) == .cel.expr.conformance.proto3.TestAllTypes +=====> +bindings: {} +result: true + +Source: type(TestAllTypes) == type +=====> +bindings: {} +result: true + +Source: type(TestAllTypes{}) == TestAllTypes +=====> +bindings: {} +result: true + +Source: type(null) == null_type +=====> +bindings: {} +result: true + +Source: type(duration) == google.protobuf.Duration && type(timestamp) == google.protobuf.Timestamp +declare duration { + value dyn +} +declare timestamp { + value dyn +} +=====> +bindings: {duration=PT0S, timestamp=1970-01-01T00:00:00Z} +result: true diff --git a/runtime/src/test/resources/uint64Conversions.baseline b/runtime/src/test/resources/uint64Conversions.baseline new file mode 100644 index 000000000..9f858f474 --- /dev/null +++ b/runtime/src/test/resources/uint64Conversions.baseline @@ -0,0 +1,29 @@ +Source: uint('1') +=====> +bindings: {} +result: 1 + +Source: uint(2.1) +=====> +bindings: {} +result: 2 + +Source: uint(1e19) +=====> +bindings: {} +result: 10000000000000000000 + +Source: uint(42) +=====> +bindings: {} +result: 42 + +Source: uint(1u) +=====> +bindings: {} +result: 1 + +Source: uint(dyn(1u)) +=====> +bindings: {} +result: 1 \ No newline at end of file diff --git a/runtime/src/test/resources/uint64Conversions_error.baseline b/runtime/src/test/resources/uint64Conversions_error.baseline new file mode 100644 index 000000000..0a47ccf88 --- /dev/null +++ b/runtime/src/test/resources/uint64Conversions_error.baseline @@ -0,0 +1,17 @@ +Source: uint(-1) +=====> +bindings: {} +error: evaluation error at test_location:4: int out of uint range +error_code: NUMERIC_OVERFLOW + +Source: uint(6.022e23) +=====> +bindings: {} +error: evaluation error at test_location:4: double out of uint range +error_code: NUMERIC_OVERFLOW + +Source: uint('f1') +=====> +bindings: {} +error: evaluation error at test_location:4: f1 +error_code: BAD_FORMAT \ No newline at end of file diff --git a/runtime/src/test/resources/unknownField.baseline b/runtime/src/test/resources/unknownField.baseline new file mode 100644 index 000000000..8e4598bef --- /dev/null +++ b/runtime/src/test/resources/unknownField.baseline @@ -0,0 +1,55 @@ +Source: x.single_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: x.map_int32_int64[22] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: x.repeated_nested_message[1] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: x.single_timestamp.getSeconds() +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: x.single_nested_message.bb +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: {1: x.single_int32} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[4]} + +Source: [1, x.single_int32] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3]} \ No newline at end of file diff --git a/runtime/src/test/resources/unknownResultSet.baseline b/runtime/src/test/resources/unknownResultSet.baseline new file mode 100644 index 000000000..ad97004f3 --- /dev/null +++ b/runtime/src/test/resources/unknownResultSet.baseline @@ -0,0 +1,431 @@ +Source: x.single_int32 == 1 && true +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: x.single_int32 == 1 && false +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: false + +Source: x.single_int32 == 1 && x.single_int64 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1, 6]} + +Source: x.single_int32 == 1 && x.single_timestamp <= timestamp("bad timestamp string") +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: true && x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3]} + +Source: false && x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: false + +Source: x.single_timestamp <= timestamp("bad timestamp string") && x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[7]} + +Source: x.single_timestamp <= timestamp("bad timestamp string") && x.single_timestamp > timestamp("another bad timestamp string") +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +error: evaluation error at test_location:31: Text 'bad timestamp string' could not be parsed at index 0 +error_code: BAD_FORMAT + +Source: x.single_int32 == 1 || x.single_string == "test" +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1, 6]} + +Source: x.single_int32 == 1 || x.single_string != "test" +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1, 6]} + +Source: x.single_int32 == 1 || x.single_int64 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1, 6]} + +Source: x.single_int32 == 1 || x.single_timestamp <= timestamp("bad timestamp string") +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: true || x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: true + +Source: false || x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3]} + +Source: x.single_timestamp <= timestamp("bad timestamp string") || x.single_int32 == 1 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[7]} + +Source: x.single_timestamp <= timestamp("bad timestamp string") || x.single_timestamp > timestamp("another bad timestamp string") +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {} +error: evaluation error at test_location:31: Text 'bad timestamp string' could not be parsed at index 0 +error_code: BAD_FORMAT + +Source: x.single_int32.f(1) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: 1.f(x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3]} + +Source: x.single_int64.f(x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1, 4]} + +Source: x +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {y=single_string: "test" +single_timestamp { + seconds: 15 +} +} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: x +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {x=CelUnknownSet{attributes=[], unknownExprIds=[1]}} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: x.map_int32_int64.map(x, x > 0, x + 1) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: [0, 2, 4].exists(z, z == 2 || z == x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: true + +Source: [0, 2, 4].exists(z, z == x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[9]} + +Source: [0, 2, 4].exists_one(z, z == 0 || (z == 2 && z == x.single_int32) || (z == 4 && z == x.single_int64)) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[26]} + +Source: [0, 2].all(z, z == 2 || z == x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[12]} + +Source: [0, 2, 4].filter(z, z == 0 || (z == 2 && z == x.single_int32) || (z == 4 && z == x.single_int64)) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[26]} + +Source: [0, 2, 4].map(z, z == 0 || (z == 2 && z == x.single_int32) || (z == 4 && z == x.single_int64)) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[17, 26]} + +Source: x.single_int32 == 1 ? 1 : 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: true ? x.single_int32 : 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3]} + +Source: true ? 1 : x.single_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: 1 + +Source: false ? x.single_int32 : 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: 2 + +Source: false ? 1 : x.single_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[4]} + +Source: x.single_int64 == 1 ? x.single_int32 : x.single_int32 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[1]} + +Source: {x.single_int32: 2, 3: 4} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3]} + +Source: {1: x.single_int32, 3: 4} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[4]} + +Source: {1: x.single_int32, x.single_int64: 4} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[4, 7]} + +Source: [1, x.single_int32, 3, 4] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3]} + +Source: [1, x.single_int32, x.single_int64, 4] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3, 5]} + +Source: TestAllTypes{single_int32: x.single_int32}.single_int32 == 2 +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3]} + +Source: TestAllTypes{single_int32: x.single_int32, single_int64: x.single_int64} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[3, 6]} + +Source: type(x.single_int32) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +result: CelUnknownSet{attributes=[], unknownExprIds=[2]} + +Source: type(1 / 0 > 2) +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare f { + function f int.(int) -> bool +} +=====> +bindings: {} +error: evaluation error at test_location:7: / by zero +error_code: DIVIDE_BY_ZERO \ No newline at end of file diff --git a/runtime/src/test/resources/wrappers.baseline b/runtime/src/test/resources/wrappers.baseline new file mode 100644 index 000000000..d8212059b --- /dev/null +++ b/runtime/src/test/resources/wrappers.baseline @@ -0,0 +1,201 @@ +Source: x.single_bool_wrapper == true && x.single_bytes_wrapper == b'hi' && x.single_double_wrapper == -3.0 && x.single_float_wrapper == 1.5 && x.single_int32_wrapper == -12 && x.single_int64_wrapper == -34 && x.single_string_wrapper == 'hello' && x.single_uint32_wrapper == 12u && x.single_uint64_wrapper == 34u +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { + value: "hello" +} +single_bool_wrapper { + value: true +} +single_bytes_wrapper { + value: "hi" +} +} +result: true + +Source: x.single_bool_wrapper == google.protobuf.BoolValue{} && x.single_bytes_wrapper == google.protobuf.BytesValue{value: b'hi'} && x.single_double_wrapper == google.protobuf.DoubleValue{value: -3.0} && x.single_float_wrapper == google.protobuf.FloatValue{value: 1.5} && x.single_int32_wrapper == google.protobuf.Int32Value{value: -12} && x.single_int64_wrapper == google.protobuf.Int64Value{value: -34} && x.single_string_wrapper == google.protobuf.StringValue{} && x.single_uint32_wrapper == google.protobuf.UInt32Value{value: 12u} && x.single_uint64_wrapper == google.protobuf.UInt64Value{value: 34u} +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { +} +single_bool_wrapper { +} +single_bytes_wrapper { + value: "hi" +} +} +result: true + +Source: x.repeated_int32_wrapper == [1,2] && x.repeated_int64_wrapper == [3] && x.repeated_float_wrapper == [1.5, 2.5] && x.repeated_double_wrapper == [3.5, 4.5] && x.repeated_string_wrapper == ['foo', 'bar'] && x.repeated_bool_wrapper == [true] && x.repeated_uint32_wrapper == [1u, 2u] && x.repeated_uint64_wrapper == [] +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=single_int64_wrapper { + value: -34 +} +single_int32_wrapper { + value: -12 +} +single_double_wrapper { + value: -3.0 +} +single_float_wrapper { + value: 1.5 +} +single_uint64_wrapper { + value: 34 +} +single_uint32_wrapper { + value: 12 +} +single_string_wrapper { +} +single_bool_wrapper { +} +single_bytes_wrapper { + value: "hi" +} +repeated_int64_wrapper { + value: 3 +} +repeated_int32_wrapper { + value: 1 +} +repeated_int32_wrapper { + value: 2 +} +repeated_double_wrapper { + value: 3.5 +} +repeated_double_wrapper { + value: 4.5 +} +repeated_float_wrapper { + value: 1.5 +} +repeated_float_wrapper { + value: 2.5 +} +repeated_uint32_wrapper { + value: 1 +} +repeated_uint32_wrapper { + value: 2 +} +repeated_string_wrapper { + value: "foo" +} +repeated_string_wrapper { + value: "bar" +} +repeated_bool_wrapper { + value: true +} +} +result: true + +Source: x.single_bool_wrapper == null && x.single_bytes_wrapper == null && x.single_double_wrapper == null && x.single_float_wrapper == null && x.single_int32_wrapper == null && x.single_int64_wrapper == null && x.single_string_wrapper == null && x.single_uint32_wrapper == null && x.single_uint64_wrapper == null +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +=====> +bindings: {x=} +result: true + +Source: dyn_var +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare dyn_var { + value dyn +} +=====> +bindings: {dyn_var=NULL_VALUE} +result: NULL_VALUE + +Source: TestAllTypes{repeated_int32: int32_list}.repeated_int32 == [1] && TestAllTypes{repeated_int64: int64_list}.repeated_int64 == [2] && TestAllTypes{repeated_uint32: uint32_list}.repeated_uint32 == [3u] && TestAllTypes{repeated_uint64: uint64_list}.repeated_uint64 == [4u] && TestAllTypes{repeated_float: float_list}.repeated_float == [5.5] && TestAllTypes{repeated_double: double_list}.repeated_double == [6.6] && TestAllTypes{repeated_bool: bool_list}.repeated_bool == [true] && TestAllTypes{repeated_string: string_list}.repeated_string == ['hello'] && TestAllTypes{repeated_bytes: bytes_list}.repeated_bytes == [b'world'] +declare int32_list { + value list(int) +} +declare int64_list { + value list(int) +} +declare uint32_list { + value list(uint) +} +declare uint64_list { + value list(uint) +} +declare float_list { + value list(double) +} +declare double_list { + value list(double) +} +declare bool_list { + value list(bool) +} +declare string_list { + value list(string) +} +declare bytes_list { + value list(bytes) +} +=====> +bindings: {int32_list=[value: 1 +], int64_list=[value: 2 +], uint32_list=[value: 3 +], uint64_list=[value: 4 +], float_list=[value: 5.5 +], double_list=[value: 6.6 +], bool_list=[value: true +], string_list=[value: "hello" +], bytes_list=[value: "world" +]} +result: true + +Source: google.protobuf.Timestamp{ seconds: 253402300800 } +=====> +bindings: {} +result: +10000-01-01T00:00:00Z diff --git a/runtime/standard/BUILD.bazel b/runtime/standard/BUILD.bazel new file mode 100644 index 000000000..c1c040f1d --- /dev/null +++ b/runtime/standard/BUILD.bazel @@ -0,0 +1,437 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "standard_function", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:standard_function"], +) + +cel_android_library( + name = "standard_function_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:standard_function_android"], +) + +java_library( + name = "add", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:add"], +) + +cel_android_library( + name = "add_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:add_android"], +) + +java_library( + name = "subtract", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:subtract"], +) + +cel_android_library( + name = "subtract_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:subtract_android"], +) + +java_library( + name = "bool", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:bool"], +) + +cel_android_library( + name = "bool_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:bool_android"], +) + +java_library( + name = "bytes", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:bytes"], +) + +cel_android_library( + name = "bytes_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:bytes_android"], +) + +java_library( + name = "contains", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:contains"], +) + +cel_android_library( + name = "contains_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:contains_android"], +) + +java_library( + name = "double", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:double"], +) + +cel_android_library( + name = "double_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:double_android"], +) + +java_library( + name = "duration", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:duration"], +) + +cel_android_library( + name = "duration_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:duration_android"], +) + +java_library( + name = "dyn", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:dyn"], +) + +cel_android_library( + name = "dyn_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:dyn_android"], +) + +java_library( + name = "ends_with", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:ends_with"], +) + +cel_android_library( + name = "ends_with_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:ends_with_android"], +) + +java_library( + name = "equals", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:equals"], +) + +cel_android_library( + name = "equals_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:equals_android"], +) + +java_library( + name = "get_day_of_year", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_day_of_year"], +) + +cel_android_library( + name = "get_day_of_year_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_day_of_year_android"], +) + +java_library( + name = "get_day_of_month", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_day_of_month"], +) + +cel_android_library( + name = "get_day_of_month_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_day_of_month_android"], +) + +java_library( + name = "get_day_of_week", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_day_of_week"], +) + +cel_android_library( + name = "get_day_of_week_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_day_of_week_android"], +) + +java_library( + name = "get_date", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_date"], +) + +cel_android_library( + name = "get_date_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_date_android"], +) + +java_library( + name = "get_full_year", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_full_year"], +) + +cel_android_library( + name = "get_full_year_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_full_year_android"], +) + +java_library( + name = "get_hours", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_hours"], +) + +cel_android_library( + name = "get_hours_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_hours_android"], +) + +java_library( + name = "get_milliseconds", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_milliseconds"], +) + +cel_android_library( + name = "get_milliseconds_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_milliseconds_android"], +) + +java_library( + name = "get_minutes", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_minutes"], +) + +cel_android_library( + name = "get_minutes_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_minutes_android"], +) + +java_library( + name = "get_month", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_month"], +) + +cel_android_library( + name = "get_month_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_month_android"], +) + +java_library( + name = "get_seconds", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_seconds"], +) + +cel_android_library( + name = "get_seconds_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:get_seconds_android"], +) + +java_library( + name = "greater", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:greater"], +) + +cel_android_library( + name = "greater_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:greater_android"], +) + +java_library( + name = "greater_equals", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:greater_equals"], +) + +cel_android_library( + name = "greater_equals_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:greater_equals_android"], +) + +java_library( + name = "in", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:in"], +) + +cel_android_library( + name = "in_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:in_android"], +) + +java_library( + name = "index", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:index"], +) + +cel_android_library( + name = "index_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:index_android"], +) + +java_library( + name = "int", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:int"], +) + +cel_android_library( + name = "int_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:int_android"], +) + +java_library( + name = "less", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:less"], +) + +cel_android_library( + name = "less_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:less_android"], +) + +java_library( + name = "less_equals", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:less_equals"], +) + +cel_android_library( + name = "less_equals_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:less_equals_android"], +) + +java_library( + name = "logical_not", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:logical_not"], +) + +cel_android_library( + name = "logical_not_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:logical_not_android"], +) + +java_library( + name = "matches", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:matches"], +) + +cel_android_library( + name = "matches_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:matches_android"], +) + +java_library( + name = "modulo", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:modulo"], +) + +cel_android_library( + name = "modulo_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:modulo_android"], +) + +java_library( + name = "multiply", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:multiply"], +) + +cel_android_library( + name = "multiply_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:multiply_android"], +) + +java_library( + name = "divide", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:divide"], +) + +cel_android_library( + name = "divide_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:divide_android"], +) + +java_library( + name = "negate", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:negate"], +) + +cel_android_library( + name = "negate_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:negate_android"], +) + +java_library( + name = "not_equals", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:not_equals"], +) + +cel_android_library( + name = "not_equals_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:not_equals_android"], +) + +java_library( + name = "size", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:size"], +) + +cel_android_library( + name = "size_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:size_android"], +) + +java_library( + name = "starts_with", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:starts_with"], +) + +cel_android_library( + name = "starts_with_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:starts_with_android"], +) + +java_library( + name = "string", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:string"], +) + +cel_android_library( + name = "string_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:string_android"], +) + +java_library( + name = "timestamp", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:timestamp"], +) + +cel_android_library( + name = "timestamp_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:timestamp_android"], +) + +java_library( + name = "uint", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:uint"], +) + +cel_android_library( + name = "uint_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:uint_android"], +) + +java_library( + name = "type", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:type"], +) + +cel_android_library( + name = "type_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:type_android"], +) + +java_library( + name = "not_strictly_false", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:not_strictly_false"], +) + +cel_android_library( + name = "not_strictly_false_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:not_strictly_false_android"], +) + +java_library( + name = "standard_overload", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:standard_overload"], +) + +cel_android_library( + name = "standard_overload_android", + exports = ["//runtime/src/main/java/dev/cel/runtime/standard:standard_overload_android"], +) diff --git a/runtime/testdata/BUILD.bazel b/runtime/testdata/BUILD.bazel new file mode 100644 index 000000000..743878225 --- /dev/null +++ b/runtime/testdata/BUILD.bazel @@ -0,0 +1,10 @@ +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//:internal"], +) + +alias( + name = "testdata", + actual = "//runtime/src/test/resources", +) diff --git a/testing.bzl b/testing.bzl new file mode 100644 index 000000000..5425f7719 --- /dev/null +++ b/testing.bzl @@ -0,0 +1,98 @@ +# Copyright 2022 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. + +# From: https://github.com/google/guice/blob/master/test_defs.bzl +"""starlark macros to generate test suites.""" + +load("@rules_java//java:defs.bzl", "java_test") + +_TEMPLATE = """package {VAR_PACKAGE}; +import org.junit.runners.Suite; +import org.junit.runner.RunWith; + +@RunWith(Suite.class) +@Suite.SuiteClasses({{{VAR_CLASSES}}}) +public class {VAR_NAME} {{}} +""" + +def _impl(ctx): + classes = ",".join(sorted(ctx.attr.test_classes)) + + ctx.actions.write( + output = ctx.outputs.out, + content = _TEMPLATE.format( + VAR_PACKAGE = ctx.attr.package_name, + VAR_CLASSES = classes, + VAR_NAME = ctx.attr.name, + ), + ) + +_gen_suite = rule( + attrs = { + "test_classes": attr.string_list(), + "package_name": attr.string(), + }, + outputs = {"out": "%{name}.java"}, + implementation = _impl, +) + +def junit4_test_suites( + name, + sizes, + deps, + src_dir, # @unused. + shard_count = None, # @unused. + srcs = None): + """ + Generates tests for test file in srcs ending in "Test.java" + + Args: + name: name of the test suite to generate + sizes: not used, exists only so that the opensource CEL mirror exactly the internal one + deps: list of runtime dependencies required to run the test + src_dir: not used, exists only so that the opensource CEL mirror exactly the internal one + shard_count: not used, exists only so that the opensource CEL mirror exactly the internal one + srcs: list of test source files, uses 'glob(["**/*Test.java"])' if not specified + """ + + package_name = native.package_name() + + # strip the path prefix from package name so that we get the correct test class name + # "common/src/test/java/dev/cel/common/internal" becomes "dev/cel/common/internal" + package_name = package_name.rpartition("/test/java/")[2] + + test_files = srcs or native.glob( + ["**/*Test.java"], + # TODO: Inspect built JAR and derive the included test files from classpath instead (provided from java_library deps). + exclude = ["**/*AndroidTest.java"], + ) + test_classes = [] + for src in test_files: + test_name = src.replace(".java", "") + test_classes.append((package_name + "/" + test_name + ".class").replace("/", ".")) + + suite_name = name + _gen_suite( + name = suite_name, + test_classes = test_classes, + package_name = package_name.replace("/", "."), + ) + + java_test( + name = "AllTestsSuite", + test_class = (package_name + "/" + suite_name).replace("/", "."), + srcs = [":" + suite_name], + deps = deps, + tags = sizes, + ) diff --git a/testing/BUILD.bazel b/testing/BUILD.bazel new file mode 100644 index 000000000..cc389fed1 --- /dev/null +++ b/testing/BUILD.bazel @@ -0,0 +1,52 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//:internal"], +) + +java_library( + name = "adorner", + exports = ["//testing/src/main/java/dev/cel/testing:adorner"], +) + +java_library( + name = "cel_runtime_flavor", + exports = ["//testing/src/main/java/dev/cel/testing:cel_runtime_flavor"], +) + +java_library( + name = "line_differ", + exports = ["//testing/src/main/java/dev/cel/testing:line_differ"], +) + +java_library( + name = "baseline_test_case", + exports = ["//testing/src/main/java/dev/cel/testing:baseline_test_case"], +) + +java_library( + name = "cel_baseline_test_case", + exports = ["//testing/src/main/java/dev/cel/testing:cel_baseline_test_case"], +) + +java_library( + name = "base_interpreter_test", + exports = ["//testing/src/main/java/dev/cel/testing:base_interpreter_test"], +) + +alias( + name = "policy_test_resources", + actual = "//testing/src/test/resources/policy:policy_yaml_files", +) + +java_library( + name = "expr_value_utils", + exports = ["//testing/src/main/java/dev/cel/testing/utils:expr_value_utils"], +) + +java_library( + name = "proto_descriptor_utils", + exports = ["//testing/src/main/java/dev/cel/testing/utils:proto_descriptor_utils"], +) diff --git a/testing/compiled/BUILD.bazel b/testing/compiled/BUILD.bazel new file mode 100644 index 000000000..2040ba9ca --- /dev/null +++ b/testing/compiled/BUILD.bazel @@ -0,0 +1,15 @@ +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//:internal"], +) + +alias( + name = "compiled_expr_utils", + actual = "//testing/src/main/java/dev/cel/testing/compiled:compiled_expr_utils", +) + +alias( + name = "compiled_expr_utils_android", + actual = "//testing/src/main/java/dev/cel/testing/compiled:compiled_expr_utils_android", +) diff --git a/testing/environment/BUILD.bazel b/testing/environment/BUILD.bazel new file mode 100644 index 000000000..5b0127db3 --- /dev/null +++ b/testing/environment/BUILD.bazel @@ -0,0 +1,45 @@ +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//:internal"], +) + +alias( + name = "dump_env", + actual = "//testing/src/test/resources/environment:dump_env", +) + +alias( + name = "extended_env", + actual = "//testing/src/test/resources/environment:extended_env", +) + +alias( + name = "all_extensions", + actual = "//testing/src/test/resources/environment:all_extensions", +) + +alias( + name = "primitive_variables", + actual = "//testing/src/test/resources/environment:primitive_variables", +) + +alias( + name = "custom_functions", + actual = "//testing/src/test/resources/environment:custom_functions", +) + +alias( + name = "library_subset_env", + actual = "//testing/src/test/resources/environment:library_subset_env", +) + +alias( + name = "proto2_message_variables", + actual = "//testing/src/test/resources/environment:proto2_message_variables", +) + +alias( + name = "proto3_message_variables", + actual = "//testing/src/test/resources/environment:proto3_message_variables", +) diff --git a/testing/protos/BUILD.bazel b/testing/protos/BUILD.bazel new file mode 100644 index 000000000..17706ca45 --- /dev/null +++ b/testing/protos/BUILD.bazel @@ -0,0 +1,60 @@ +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//:internal"], +) + +alias( + name = "single_file_java_proto", + actual = "//testing/src/test/resources/protos:single_file_java_proto", +) + +alias( + name = "single_file_extension_java_proto", + actual = "//testing/src/test/resources/protos:single_file_extension_java_proto", +) + +alias( + name = "multi_file_java_proto", + actual = "//testing/src/test/resources/protos:multi_file_java_proto", +) + +alias( + name = "multi_file_cel_java_proto", + actual = "//testing/src/test/resources/protos:multi_file_cel_java_proto", +) + +alias( + name = "message_with_enum_java_proto", + actual = "//testing/src/test/resources/protos:message_with_enum_java_proto", +) + +alias( + name = "multi_file_cel_java_proto_lite", + actual = "//testing/src/test/resources/protos:multi_file_cel_java_proto_lite", +) + +alias( + name = "test_all_types_cel_java_proto2_lite", + actual = "//testing/src/test/resources/protos:test_all_types_cel_java_proto2_lite", +) + +alias( + name = "test_all_types_cel_java_proto3_lite", + actual = "//testing/src/test/resources/protos:test_all_types_cel_java_proto3_lite", +) + +alias( + name = "test_all_types_cel_java_proto2", + actual = "//testing/src/test/resources/protos:test_all_types_cel_java_proto2", +) + +alias( + name = "test_all_types_cel_java_proto3", + actual = "//testing/src/test/resources/protos:test_all_types_cel_java_proto3", +) + +alias( + name = "message_with_enum_cel_java_proto", + actual = "//testing/src/test/resources/protos:message_with_enum_cel_java_proto", +) diff --git a/testing/src/main/java/dev/cel/testing/BUILD.bazel b/testing/src/main/java/dev/cel/testing/BUILD.bazel new file mode 100644 index 000000000..69765b549 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/BUILD.bazel @@ -0,0 +1,116 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//testing:__pkg__"], +) + +java_library( + name = "baseline_test_case", + srcs = [ + "BaselineTestCase.java", + ], + deps = [ + ":line_differ", + "@maven//:com_google_guava_guava", + "@maven//:junit_junit", + ], +) + +java_library( + name = "line_differ", + srcs = ["LineDiffer.java"], + deps = [ + "//:auto_value", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "adorner", + srcs = [ + "CelAdorner.java", + "CelDebug.java", + ], + deps = [ + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "cel_baseline_test_case", + srcs = ["CelBaselineTestCase.java"], + deps = [ + ":baseline_test_case", + "//:java_truth", + "//common:cel_ast", + "//common:compiler_common", + "//common:container", + "//common:options", + "//common/types:cel_types", + "//common/types:message_type_provider", + "//common/types:type_providers", + "//compiler", + "//compiler:compiler_builder", + "//extensions", + "//parser:macro", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "base_interpreter_test", + testonly = 1, + srcs = [ + "BaseInterpreterTest.java", + ], + resources = [ + "//common/resources/testdata/proto3:test_all_types_file_descriptor_set", + "//runtime/testdata", + ], + deps = [ + ":cel_baseline_test_case", + "//:java_truth", + "//common:cel_ast", + "//common:container", + "//common:options", + "//common:proto_ast", + "//common/internal:cel_descriptor_pools", + "//common/internal:file_descriptor_converter", + "//common/internal:proto_time_utils", + "//common/resources/testdata/proto3:standalone_global_enum_java_proto", + "//common/types", + "//common/types:message_type_provider", + "//common/types:type_providers", + "//common/values:cel_byte_string", + "//extensions", + "//extensions:optional_library", + "//runtime", + "//runtime:function_binding", + "//runtime:partial_vars", + "//runtime:unknown_attributes", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@cel_spec//proto/cel/expr:syntax_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_protobuf_protobuf_java_util", + "@maven//:junit_junit", + ], +) + +java_library( + name = "cel_runtime_flavor", + srcs = ["CelRuntimeFlavor.java"], + tags = [ + ], + deps = [ + "//bundle:cel", + ], +) diff --git a/testing/src/main/java/dev/cel/testing/BaseInterpreterTest.java b/testing/src/main/java/dev/cel/testing/BaseInterpreterTest.java new file mode 100644 index 000000000..bda56a19e --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/BaseInterpreterTest.java @@ -0,0 +1,2674 @@ +// Copyright 2022 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.testing; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.runtime.CelVariableResolver.hierarchicalVariableResolver; +import static java.nio.charset.StandardCharsets.UTF_8; + +import dev.cel.expr.CheckedExpr; +import dev.cel.expr.ParsedExpr; +import dev.cel.expr.Type; +import com.google.common.base.Ascii; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.io.Resources; +import com.google.common.primitives.UnsignedLong; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.Any; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.BytesValue; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.ListValue; +import com.google.protobuf.Message; +import com.google.protobuf.NullValue; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.TextFormat; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.UnredactedDebugFormatForTest; +import com.google.protobuf.Value; +import com.google.protobuf.util.JsonFormat; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelOptions; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.common.internal.DefaultDescriptorPool; +import dev.cel.common.internal.FileDescriptorSetConverter; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OpaqueType; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.StructTypeReference; +import dev.cel.common.types.TypeParamType; +import dev.cel.common.values.CelByteString; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedEnum; +import dev.cel.expr.conformance.proto3.TestAllTypes.NestedMessage; +import dev.cel.extensions.CelExtensions; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.runtime.CelAttributePattern; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelLateFunctionBindings; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.runtime.CelUnknownSet; +import dev.cel.runtime.CelVariableResolver; +import dev.cel.runtime.PartialVars; +import dev.cel.testing.testdata.proto3.StandaloneGlobalEnum; +import java.io.IOException; +import java.time.Duration; +import java.time.Instant; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.stream.LongStream; +import org.junit.Test; + +/** Base class for evaluation outputs that can be stored and used as a baseline test. */ +public abstract class BaseInterpreterTest extends CelBaselineTestCase { + + protected static final Descriptor TEST_ALL_TYPE_DYNAMIC_DESCRIPTOR = + getDeserializedTestAllTypeDescriptor(); + + protected static final ImmutableList TEST_FILE_DESCRIPTORS = + ImmutableList.of( + dev.cel.expr.conformance.proto2.TestAllTypes.getDescriptor().getFile(), + TestAllTypes.getDescriptor().getFile(), + StandaloneGlobalEnum.getDescriptor().getFile(), + TEST_ALL_TYPE_DYNAMIC_DESCRIPTOR.getFile()); + + private static final CelOptions BASE_CEL_OPTIONS = + CelOptions.current() + .enableHeterogeneousNumericComparisons(true) + .enableOptionalSyntax(true) + .comprehensionMaxIterations(1_000) + .build(); + protected CelRuntime celRuntime; + private CelOptions celOptions; + + protected BaseInterpreterTest() { + this.celOptions = BASE_CEL_OPTIONS; + this.celRuntime = newBaseRuntimeBuilder(celOptions).build(); + } + + protected BaseInterpreterTest(CelRuntime celRuntime) { + this.celRuntime = celRuntime; + this.celOptions = BASE_CEL_OPTIONS; + } + + protected CelRuntimeBuilder newBaseRuntimeBuilder(CelOptions celOptions) { + return CelRuntimeFactory.standardCelRuntimeBuilder() + .addLibraries(CelOptionalLibrary.INSTANCE) + .addFileTypes(TEST_FILE_DESCRIPTORS) + .setOptions(celOptions); + } + + @Override + protected CelAbstractSyntaxTree prepareTest(List descriptors) { + return prepareTest( + ProtoMessageTypeProvider.newBuilder() + .addFileDescriptors(descriptors) + .setAllowJsonFieldNames(celOptions.enableJsonFieldNames()) + .build()); + } + + @Override + protected void prepareCompiler(CelTypeProvider typeProvider) { + super.prepareCompiler(typeProvider); + this.celCompiler = + celCompiler + .toCompilerBuilder() + .addLibraries(CelOptionalLibrary.INSTANCE, CelExtensions.bindings()) + .setOptions(celOptions) + .build(); + } + + protected void setContainer(CelContainer container) { + this.container = container; + } + + private CelAbstractSyntaxTree compileTestCase() { + CelAbstractSyntaxTree ast = prepareTest(TEST_FILE_DESCRIPTORS); + if (ast == null) { + return null; + } + assertAstRoundTrip(ast); + + return ast; + } + + @CanIgnoreReturnValue + private Object runTest() { + return runTest(ImmutableMap.of()); + } + + @CanIgnoreReturnValue + private Object runTest(CelVariableResolver variableResolver) { + return runTestInternal(variableResolver, Optional.empty()); + } + + /** Helper to run a test for configured instance variables. */ + @CanIgnoreReturnValue + private Object runTest(Map input) { + return runTestInternal(input, Optional.empty()); + } + + /** Helper to run a test for configured instance variables. */ + @CanIgnoreReturnValue + private Object runTest(Map input, CelLateFunctionBindings lateFunctionBindings) { + return runTestInternal(input, Optional.of(lateFunctionBindings)); + } + + @CanIgnoreReturnValue + protected Object runTest(Map input, CelAttributePattern... patterns) { + return runTestInternal(input, Optional.empty(), patterns); + } + + /** + * Helper to run a test for configured instance variables. Input must be of type map or {@link + * CelVariableResolver}. + */ + private Object runTestInternal( + Object input, Optional lateFunctionBindings) { + return runTestInternal(input, lateFunctionBindings, new CelAttributePattern[0]); + } + + // Test only + @SuppressWarnings("unchecked") + private Object runTestInternal( + Object input, + Optional lateFunctionBindings, + CelAttributePattern... patterns) { + CelAbstractSyntaxTree ast = compileTestCase(); + if (ast == null) { + // Usually indicates test was not setup correctly + println("Source compilation failed"); + return null; + } + printBinding(input, patterns); + Object result = null; + try { + CelRuntime.Program program = celRuntime.createProgram(ast); + if (patterns.length > 0) { + PartialVars partialVars = + input instanceof Map + ? PartialVars.of((Map) input, patterns) + : PartialVars.of((CelVariableResolver) input, patterns); + result = program.eval(partialVars); + } else if (lateFunctionBindings.isPresent()) { + if (input instanceof Map) { + Map map = ((Map) input); + CelVariableResolver variableResolver = (name) -> Optional.ofNullable(map.get(name)); + result = program.eval(variableResolver, lateFunctionBindings.get()); + } else { + result = program.eval((CelVariableResolver) input, lateFunctionBindings.get()); + } + } else { + result = + input instanceof Map + ? program.eval(((Map) input)) + : program.eval((CelVariableResolver) input); + } + if (result instanceof CelByteString) { + // Note: this call may fail for printing byte sequences that are not valid UTF-8, but works + // pretty well for test purposes. + result = ((CelByteString) result).toStringUtf8(); + } + println("result: " + UnredactedDebugFormatForTest.unredactedToString(result)); + } catch (CelEvaluationException e) { + println("error: " + e.getMessage()); + println("error_code: " + e.getErrorCode()); + } + println(""); + return result; + } + + @Test + public void arithmInt64() { + source = "1 < 2 && 1 <= 1 && 2 > 1 && 1 >= 1 && 1 == 1 && 2 != 1"; + runTest(); + + declareVariable("x", SimpleType.INT); + source = "1 + 2 - x * 3 / x + (x % 3)"; + runTest(ImmutableMap.of("x", -5L)); + + declareVariable("y", SimpleType.DYN); + source = "x + y == 1"; + runTest(extend(ImmutableMap.of("x", -5L), ImmutableMap.of("y", 6L))); + } + + @Test + public void arithmInt64_error() { + source = "9223372036854775807 + 1"; + runTest(); + + source = "-9223372036854775808 - 1"; + runTest(); + + source = "-(-9223372036854775808)"; + runTest(); + + source = "5000000000 * 5000000000"; + runTest(); + + source = "(-9223372036854775808)/-1"; + runTest(); + + source = "1 / 0"; + runTest(); + + source = "1 % 0"; + runTest(); + } + + @Test + public void arithmUInt64() { + source = "1u < 2u && 1u <= 1u && 2u > 1u && 1u >= 1u && 1u == 1u && 2u != 1u"; + runTest(); + + boolean useUnsignedLongs = BASE_CEL_OPTIONS.enableUnsignedLongs(); + declareVariable("x", SimpleType.UINT); + source = "1u + 2u + x * 3u / x + (x % 3u)"; + runTest(ImmutableMap.of("x", useUnsignedLongs ? UnsignedLong.valueOf(5L) : 5L)); + + declareVariable("y", SimpleType.DYN); + source = "x + y == 11u"; + runTest( + extend( + ImmutableMap.of("x", useUnsignedLongs ? UnsignedLong.valueOf(5L) : 5L), + ImmutableMap.of("y", useUnsignedLongs ? UnsignedLong.valueOf(6L) : 6))); + + source = "x - y == 1u"; + runTest( + extend( + ImmutableMap.of("x", useUnsignedLongs ? UnsignedLong.valueOf(6L) : 6L), + ImmutableMap.of("y", useUnsignedLongs ? UnsignedLong.valueOf(5) : 5))); + } + + @Test + public void arithmUInt64_error() { + source = "18446744073709551615u + 1u"; + runTest(); + + source = "0u - 1u"; + runTest(); + + source = "5000000000u * 5000000000u"; + runTest(); + + source = "1u / 0u"; + runTest(); + + source = "1u % 0u"; + runTest(); + } + + @Test + public void arithmDouble() { + source = "0.0 == -0.0"; + runTest(); + + source = "1.9 < 2.0 && 1.1 <= 1.1 && 2.0 > 1.9 && 1.1 >= 1.1 && 1.1 == 1.1 && 2.0 != 1.9"; + runTest(); + + declareVariable("x", SimpleType.DOUBLE); + source = "1.0 + 2.3 + x * 3.0 / x"; + runTest(ImmutableMap.of("x", 3.33)); + + declareVariable("y", SimpleType.DYN); + source = "x + y == 9.99"; + runTest(extend(ImmutableMap.of("x", 3.33d), ImmutableMap.of("y", 6.66))); + } + + @Test + public void quantifiers() { + source = "[1,-2,3].exists_one(x, x > 0)"; + runTest(); + + source = "[-1,-2,3].exists_one(x, x > 0)"; + runTest(); + + source = "[-1,-2,-3].exists(x, x > 0)"; + runTest(); + + source = "[1,-2,3].exists(x, x > 0)"; + runTest(); + + source = "[1,-2,3].all(x, x > 0)"; + runTest(); + + source = "[1,2,3].all(x, x > 0)"; + runTest(); + } + + @Test + public void arithmTimestamp() { + setContainer(CelContainer.ofName(Type.getDescriptor().getFile().getPackage())); + declareVariable("ts1", SimpleType.TIMESTAMP); + declareVariable("ts2", SimpleType.TIMESTAMP); + declareVariable("d1", SimpleType.DURATION); + Duration d1 = Duration.ofSeconds(15, 25); + Instant ts1 = Instant.ofEpochSecond(25, 35); + Instant ts2 = Instant.ofEpochSecond(10, 10); + CelVariableResolver resolver = + extend( + extend(ImmutableMap.of("d1", d1), ImmutableMap.of("ts1", ts1)), + ImmutableMap.of("ts2", ts2)); + + source = "ts1 - ts2 == d1"; + runTest(resolver); + + source = "ts1 - d1 == ts2"; + runTest(resolver); + + source = "ts2 + d1 == ts1"; + runTest(resolver); + + source = "d1 + ts2 == ts1"; + runTest(resolver); + } + + @Test + public void arithmDuration() { + setContainer(CelContainer.ofName(Type.getDescriptor().getFile().getPackage())); + declareVariable("d1", SimpleType.DURATION); + declareVariable("d2", SimpleType.DURATION); + declareVariable("d3", SimpleType.DURATION); + java.time.Duration d1 = java.time.Duration.ofSeconds(15, 25); + java.time.Duration d2 = java.time.Duration.ofSeconds(10, 20); + java.time.Duration d3 = java.time.Duration.ofSeconds(25, 45); + + CelVariableResolver resolver = + extend( + extend(ImmutableMap.of("d1", d1), ImmutableMap.of("d2", d2)), + ImmutableMap.of("d3", d3)); + + source = "d1 + d2 == d3"; + runTest(resolver); + + source = "d3 - d1 == d2"; + runTest(resolver); + } + + @Test + public void arithCrossNumericTypes() { + if (!BASE_CEL_OPTIONS.enableUnsignedLongs()) { + skipBaselineVerification(); + return; + } + source = "1.9 < 2 && 1 < 1.1 && 2u < 2.9 && 1.1 < 2u && 1 < 2u && 2u < 3"; + runTest(); + + source = "1.9 <= 2 && 1 <= 1.1 && 2u <= 2.9 && 1.1 <= 2u && 2 <= 2u && 2u <= 2"; + runTest(); + + source = "1.9 > 2 && 1 > 1.1 && 2u > 2.9 && 1.1 > 2u && 2 > 2u && 2u > 2"; + runTest(); + + source = "1.9 >= 2 && 1 >= 1.1 && 2u >= 2.9 && 1.1 >= 2u && 2 >= 2u && 2u >= 2"; + runTest(); + } + + @Test + public void booleans() { + declareVariable("x", SimpleType.BOOL); + source = "x ? 1 : 0"; + runTest(ImmutableMap.of("x", true)); + runTest(ImmutableMap.of("x", false)); + + source = "(1 / 0 == 0 && false) == (false && 1 / 0 == 0)"; + runTest(); + + source = "(1 / 0 == 0 || true) == (true || 1 / 0 == 0)"; + runTest(); + + declareVariable("y", SimpleType.INT); + source = "1 / y == 1 || true"; + runTest(ImmutableMap.of("y", 0L)); + + source = "1 / y == 1 && false"; + runTest(ImmutableMap.of("y", 0L)); + + source = "(true > false) == true"; + runTest(); + + source = "(true > true) == false"; + runTest(); + + source = "(false > true) == false"; + runTest(); + + source = "(false > false) == false"; + runTest(); + + source = "(true >= false) == true"; + runTest(); + + source = "(true >= true) == true"; + runTest(); + + source = "(false >= false) == true"; + runTest(); + + source = "(false >= true) == false"; + runTest(); + + source = "(false < true) == true"; + runTest(); + + source = "(false < false) == false"; + runTest(); + + source = "(true < false) == false"; + runTest(); + + source = "(true < true) == false"; + runTest(); + + source = "(false <= true) == true"; + runTest(); + + source = "(false <= false) == true"; + runTest(); + + source = "(true <= false) == false"; + runTest(); + + source = "(true <= true) == true"; + runTest(); + } + + @Test + public void booleans_error() { + declareVariable("y", SimpleType.INT); + + source = "1 / y == 1 || false"; + runTest(ImmutableMap.of("y", 0L)); + + source = "false || 1 / y == 1"; + runTest(ImmutableMap.of("y", 0L)); + + source = "1 / y == 1 && true"; + runTest(ImmutableMap.of("y", 0L)); + + source = "true && 1 / y == 1"; + runTest(ImmutableMap.of("y", 0L)); + } + + @Test + public void strings() throws Exception { + source = "'a' < 'b' && 'a' <= 'b' && 'b' > 'a' && 'a' >= 'a' && 'a' == 'a' && 'a' != 'b'"; + runTest(); + + declareVariable("x", SimpleType.STRING); + source = + "'abc' + x == 'abcdef' && " + + "x.endsWith('ef') && " + + "x.startsWith('d') && " + + "x.contains('de') && " + + "!x.contains('abcdef')"; + runTest(ImmutableMap.of("x", "def")); + } + + @Test + public void messages() throws Exception { + TestAllTypes nestedMessage = + TestAllTypes.newBuilder() + .setSingleNestedMessage(NestedMessage.newBuilder().setBb(43)) + .build(); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + source = "x.single_nested_message.bb == 43 && has(x.single_nested_message)"; + runTest(ImmutableMap.of("x", nestedMessage)); + + declareVariable( + "single_nested_message", + StructTypeReference.create(NestedMessage.getDescriptor().getFullName())); + source = "single_nested_message.bb == 43"; + runTest(ImmutableMap.of("single_nested_message", nestedMessage.getSingleNestedMessage())); + + source = "TestAllTypes{single_int64: 1, single_sfixed64: 2, single_int32: 2}.single_int32 == 2"; + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + runTest(); + } + + @Test + public void messages_error() { + source = "TestAllTypes{single_int32_wrapper: 12345678900}"; + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + runTest(); + + source = "TestAllTypes{}.map_string_string.a"; + runTest(); + } + + @Test + public void optional() { + // TODO: Move existing optional tests here to also test CelValue runtime + source = "optional.unwrap([])"; + runTest(); + + declareVariable("str", SimpleType.STRING); + source = "optional.unwrap([optional.none(), optional.of(1), optional.of(str)])"; + runTest(ImmutableMap.of("str", "foo")); + } + + @Test + public void optional_errors() { + source = "optional.unwrap([dyn(1)])"; + runTest(); + } + + @Test + public void containers() { + setContainer( + CelContainer.newBuilder() + .setName("dev.cel.testing.testdata.proto3.StandaloneGlobalEnum") + .addAlias("test_alias", TestAllTypes.getDescriptor().getFile().getPackage()) + .addAbbreviations("cel.expr.conformance.proto2", "cel.expr.conformance.proto3") + .build()); + source = "test_alias.TestAllTypes{} == cel.expr.conformance.proto3.TestAllTypes{}"; + runTest(); + + source = "proto2.TestAllTypes{} == cel.expr.conformance.proto2.TestAllTypes{}"; + runTest(); + + source = "proto3.TestAllTypes{} == cel.expr.conformance.proto3.TestAllTypes{}"; + runTest(); + + source = "SGAR"; // From StandaloneGlobalEnum + runTest(); + } + + @Test + public void has() throws Exception { + TestAllTypes nestedMessage = + TestAllTypes.newBuilder() + .setSingleInt32(1) + .setSingleInt64(0L) + .setSingleBoolWrapper(BoolValue.newBuilder().setValue(false)) + .setSingleInt32Wrapper(Int32Value.newBuilder().setValue(42)) + .setOptionalBool(false) + .setOneofBool(false) + .addRepeatedInt32(1) + .putMapInt32Int64(1, 2L) + .setSingleNestedMessage(NestedMessage.newBuilder().setBb(43)) + .build(); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + source = + "has(x.single_int32) && !has(x.single_int64) && has(x.single_bool_wrapper)" + + " && has(x.single_int32_wrapper) && !has(x.single_int64_wrapper)" + + " && has(x.repeated_int32) && !has(x.repeated_int64)" + + " && has(x.optional_bool) && !has(x.optional_string)" + + " && has(x.oneof_bool) && !has(x.oneof_type)" + + " && has(x.map_int32_int64) && !has(x.map_string_string)" + + " && has(x.single_nested_message) && !has(x.single_duration)"; + runTest(ImmutableMap.of("x", nestedMessage)); + } + + @Test + public void duration() throws Exception { + declareVariable("d1", SimpleType.DURATION); + declareVariable("d2", SimpleType.DURATION); + java.time.Duration d1010 = java.time.Duration.ofSeconds(10, 10); + java.time.Duration d1009 = java.time.Duration.ofSeconds(10, 9); + java.time.Duration d0910 = java.time.Duration.ofSeconds(9, 10); + setContainer(CelContainer.ofName(Type.getDescriptor().getFile().getPackage())); + + source = "d1 < d2"; + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d1009))); + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d0910))); + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d1010))); + runTest(extend(ImmutableMap.of("d1", d1009), ImmutableMap.of("d2", d1010))); + runTest(extend(ImmutableMap.of("d1", d0910), ImmutableMap.of("d2", d1010))); + + source = "d1 <= d2"; + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d1009))); + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d0910))); + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d1010))); + runTest(extend(ImmutableMap.of("d1", d1009), ImmutableMap.of("d2", d1010))); + runTest(extend(ImmutableMap.of("d1", d0910), ImmutableMap.of("d2", d1010))); + + source = "d1 > d2"; + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d1009))); + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d0910))); + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d1010))); + runTest(extend(ImmutableMap.of("d1", d1009), ImmutableMap.of("d2", d1010))); + runTest(extend(ImmutableMap.of("d1", d0910), ImmutableMap.of("d2", d1010))); + + source = "d1 >= d2"; + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d1009))); + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d0910))); + runTest(extend(ImmutableMap.of("d1", d1010), ImmutableMap.of("d2", d1010))); + runTest(extend(ImmutableMap.of("d1", d1009), ImmutableMap.of("d2", d1010))); + runTest(extend(ImmutableMap.of("d1", d0910), ImmutableMap.of("d2", d1010))); + } + + @Test + public void timestamp() throws Exception { + declareVariable("t1", SimpleType.TIMESTAMP); + declareVariable("t2", SimpleType.TIMESTAMP); + Instant ts1010 = Instant.ofEpochSecond(10, 10); + Instant ts1009 = Instant.ofEpochSecond(10, 9); + Instant ts0910 = Instant.ofEpochSecond(9, 10); + setContainer(CelContainer.ofName(Type.getDescriptor().getFile().getPackage())); + + source = "t1 < t2"; + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts1009))); + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts0910))); + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts1010))); + runTest(extend(ImmutableMap.of("t1", ts1009), ImmutableMap.of("t2", ts1010))); + runTest(extend(ImmutableMap.of("t1", ts0910), ImmutableMap.of("t2", ts1010))); + + source = "t1 <= t2"; + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts1009))); + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts0910))); + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts1010))); + runTest(extend(ImmutableMap.of("t1", ts1009), ImmutableMap.of("t2", ts1010))); + runTest(extend(ImmutableMap.of("t1", ts0910), ImmutableMap.of("t2", ts1010))); + + source = "t1 > t2"; + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts1009))); + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts0910))); + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts1010))); + runTest(extend(ImmutableMap.of("t1", ts1009), ImmutableMap.of("t2", ts1010))); + runTest(extend(ImmutableMap.of("t1", ts0910), ImmutableMap.of("t2", ts1010))); + + source = "t1 >= t2"; + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts1009))); + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts0910))); + runTest(extend(ImmutableMap.of("t1", ts1010), ImmutableMap.of("t2", ts1010))); + runTest(extend(ImmutableMap.of("t1", ts1009), ImmutableMap.of("t2", ts1010))); + runTest(extend(ImmutableMap.of("t1", ts0910), ImmutableMap.of("t2", ts1010))); + } + + @Test + public void packUnpackAny() { + // The use of long values results in the incorrect type being serialized for a uint value. + if (!BASE_CEL_OPTIONS.enableUnsignedLongs()) { + skipBaselineVerification(); + return; + } + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + declareVariable("any", SimpleType.ANY); + declareVariable("d", SimpleType.DURATION); + declareVariable( + "message", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + declareVariable("list", ListType.create(SimpleType.DYN)); + com.google.protobuf.Duration duration = ProtoTimeUtils.fromSecondsToDuration(100); + Any any = Any.pack(duration); + TestAllTypes message = TestAllTypes.newBuilder().setSingleAny(any).build(); + + // unpack any + source = "any == d"; + runTest(extend(ImmutableMap.of("any", any), ImmutableMap.of("d", duration))); + source = "any == message.single_any"; + runTest(extend(ImmutableMap.of("any", any), ImmutableMap.of("message", message))); + source = "d == message.single_any"; + runTest(extend(ImmutableMap.of("d", duration), ImmutableMap.of("message", message))); + source = "any.single_int64 == 1"; + runTest(ImmutableMap.of("any", TestAllTypes.newBuilder().setSingleInt64(1).build())); + source = "any == 1"; + runTest(ImmutableMap.of("any", Any.pack(Int64Value.of(1)))); + source = "list[0] == message"; + runTest(ImmutableMap.of("list", ImmutableList.of(Any.pack(message)), "message", message)); + + // pack any + source = "TestAllTypes{single_any: d}"; + runTest(ImmutableMap.of("d", duration)); + source = "TestAllTypes{single_any: message.single_int64}"; + runTest(ImmutableMap.of("message", TestAllTypes.newBuilder().setSingleInt64(-1).build())); + source = "TestAllTypes{single_any: message.single_uint64}"; + runTest(ImmutableMap.of("message", TestAllTypes.newBuilder().setSingleUint64(1).build())); + source = "TestAllTypes{single_any: 1.0}"; + runTest(); + source = "TestAllTypes{single_any: true}"; + runTest(); + source = "TestAllTypes{single_any: \"happy\"}"; + runTest(); + source = "TestAllTypes{single_any: message.single_bytes}"; + runTest( + ImmutableMap.of( + "message", + TestAllTypes.newBuilder().setSingleBytes(ByteString.copyFromUtf8("happy")).build())); + } + + @Test + public void nestedEnums() { + TestAllTypes nestedEnum = TestAllTypes.newBuilder().setSingleNestedEnum(NestedEnum.BAR).build(); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + source = "x.single_nested_enum == TestAllTypes.NestedEnum.BAR"; + runTest(ImmutableMap.of("x", nestedEnum)); + + declareVariable("single_nested_enum", SimpleType.INT); + source = "single_nested_enum == TestAllTypes.NestedEnum.BAR"; + runTest(ImmutableMap.of("single_nested_enum", nestedEnum.getSingleNestedEnumValue())); + + source = + "TestAllTypes{single_nested_enum : TestAllTypes.NestedEnum.BAR}.single_nested_enum == 1"; + runTest(); + } + + @Test + public void globalEnums() { + declareVariable("x", SimpleType.INT); + source = "x == dev.cel.testing.testdata.proto3.StandaloneGlobalEnum.SGAR"; + runTest(ImmutableMap.of("x", StandaloneGlobalEnum.SGAR.getNumber())); + } + + @Test + public void lists() throws Exception { + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + declareVariable("y", SimpleType.INT); + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + source = "([1, 2, 3] + x.repeated_int32)[3] == 4"; + runTest(ImmutableMap.of("x", TestAllTypes.newBuilder().addRepeatedInt32(4).build())); + + source = "!(y in [1, 2, 3]) && y in [4, 5, 6]"; + runTest(ImmutableMap.of("y", 4L)); + + source = "TestAllTypes{repeated_int32: [1,2]}.repeated_int32[1] == 2"; + runTest(); + + source = "1 in TestAllTypes{repeated_int32: [1,2]}.repeated_int32"; + runTest(); + + source = "!(4 in [1, 2, 3]) && 1 in [1, 2, 3]"; + runTest(); + + declareVariable("list", ListType.create(SimpleType.INT)); + + source = "!(4 in list) && 1 in list"; + runTest(ImmutableMap.of("list", ImmutableList.of(1L, 2L, 3L))); + + source = "!(y in list)"; + runTest(ImmutableMap.of("y", 4L, "list", ImmutableList.of(1L, 2L, 3L))); + + source = "y in list"; + runTest(ImmutableMap.of("y", 1L, "list", ImmutableList.of(1L, 2L, 3L))); + } + + @Test + public void lists_error() { + declareVariable("y", SimpleType.INT); + declareVariable("list", ListType.create(SimpleType.INT)); + + source = "list[3]"; + runTest(ImmutableMap.of("y", 1L, "list", ImmutableList.of(1L, 2L, 3L))); + } + + @Test + public void maps() throws Exception { + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + source = "{1: 2, 3: 4}[3] == 4"; + runTest(); + + // Constant key in constant map. + source = "3 in {1: 2, 3: 4} && !(4 in {1: 2, 3: 4})"; + runTest(); + + source = "x.map_int32_int64[22] == 23"; + runTest(ImmutableMap.of("x", TestAllTypes.newBuilder().putMapInt32Int64(22, 23).build())); + + source = "TestAllTypes{map_int32_int64: {21: 22, 22: 23}}.map_int32_int64[22] == 23"; + runTest(); + + source = + "TestAllTypes{oneof_type: NestedTestAllTypes{payload: x}}" + + ".oneof_type.payload.map_int32_int64[22] == 23"; + runTest(ImmutableMap.of("x", TestAllTypes.newBuilder().putMapInt32Int64(22, 23).build())); + + declareVariable("y", SimpleType.INT); + declareVariable("map", MapType.create(SimpleType.INT, SimpleType.INT)); + + // Constant key in variable map. + source = "!(4 in map) && 1 in map"; + runTest(ImmutableMap.of("map", ImmutableMap.of(1L, 4L, 2L, 3L, 3L, 2L))); + + // Variable key in constant map. + source = "!(y in {1: 4, 2: 3, 3: 2}) && y in {5: 3, 4: 2, 3: 3}"; + runTest(ImmutableMap.of("y", 4L)); + + // Variable key in variable map. + source = "!(y in map) && (y + 3) in map"; + runTest(ImmutableMap.of("y", 1L, "map", ImmutableMap.of(4L, 1L, 5L, 2L, 6L, 3L))); + + // Message value in map + source = "TestAllTypes{map_int64_nested_type:{42:NestedTestAllTypes{payload:TestAllTypes{}}}}"; + runTest(); + + // Repeated key - constant + source = "{true: 1, false: 2, true: 3}[true]"; + runTest(); + + // Repeated key - expressions + declareVariable("b", SimpleType.BOOL); + source = "{b: 1, !b: 2, b: 3}[true]"; + runTest(ImmutableMap.of("b", true)); + } + + @Test + public void comprehension() throws Exception { + source = "[0, 1, 2].map(x, x > 0, x + 1) == [2, 3]"; + runTest(); + + source = "[0, 1, 2].exists(x, x > 0)"; + runTest(); + + source = "[0, 1, 2].exists(x, x > 2)"; + runTest(); + + declareVariable("com.x", SimpleType.INT); + setContainer(CelContainer.ofName("com")); + source = "[0].exists(x, x == 0)"; + runTest(ImmutableMap.of("com.x", 1)); + + clearAllDeclarations(); + declareVariable("cel.example.y", SimpleType.INT); + setContainer(CelContainer.ofName("cel.example")); + source = "[{'z': 0}].exists(y, y.z == 0)"; + runTest(ImmutableMap.of("cel.example.y", ImmutableMap.of("z", 1))); + + clearAllDeclarations(); + declareVariable("y.z", SimpleType.INT); + setContainer(CelContainer.ofName("y")); + source = "[{'z': 0}].exists(y, y.z == 0 && .y.z == 1)"; + runTest(ImmutableMap.of("y.z", 1)); + + clearAllDeclarations(); + declareVariable("x", SimpleType.INT); + source = "[0].exists(x, x == 0 && .x == 1)"; + runTest(ImmutableMap.of("x", 1)); + + source = "[0].exists(x, [x+1].exists(x, x == .x))"; + runTest(ImmutableMap.of("x", 1)); + } + + @Test + public void abstractType() { + CelType typeParam = TypeParamType.create("T"); + CelType abstractType = OpaqueType.create("vector", typeParam); + + // Declare a function to create a vector. + declareFunction( + "vector", + globalOverload("vector", ImmutableList.of(ListType.create(typeParam)), abstractType)); + // Declare a function to access element of a vector. + declareFunction( + "at", memberOverload("at", ImmutableList.of(abstractType, SimpleType.INT), typeParam)); + // Add function bindings for above + addFunctionBinding( + CelFunctionBinding.from( + "vector", + ImmutableList.of(List.class), + (Object[] args) -> { + List list = (List) args[0]; + return list.toArray(new Object[0]); + }), + CelFunctionBinding.from( + "at", + ImmutableList.of(Object[].class, Long.class), + (Object[] args) -> { + Object[] array = (Object[]) args[0]; + return array[(int) (long) args[1]]; + })); + + source = "vector([1,2,3]).at(1) == 2"; + runTest(); + + source = "vector([1,2,3]).at(1) + vector([7]).at(0)"; + runTest(); + } + + @Test + public void namespacedFunctions() { + declareFunction( + "ns.func", + globalOverload("ns_func_overload", ImmutableList.of(SimpleType.STRING), SimpleType.INT)); + declareFunction( + "member", + memberOverload( + "ns_member_overload", + ImmutableList.of(SimpleType.INT, SimpleType.INT), + SimpleType.INT)); + addFunctionBinding( + CelFunctionBinding.fromOverloads( + "ns.func", + CelFunctionBinding.from("ns_func_overload", String.class, s -> (long) s.length()))); + addFunctionBinding( + CelFunctionBinding.fromOverloads( + "member", + CelFunctionBinding.from("ns_member_overload", Long.class, Long.class, Long::sum))); + + source = "ns.func('hello')"; + runTest(); + + source = "ns.func('hello').member(ns.func('test'))"; + runTest(); + + source = "{ns.func('test'): 2}"; + runTest(); + + source = "{2: ns.func('test')}"; + runTest(); + + source = "[ns.func('test'), 2]"; + runTest(); + + source = "[ns.func('test')].map(x, x * 2)"; + runTest(); + + source = "[1, 2].map(x, x * ns.func('test'))"; + runTest(); + + setContainer(CelContainer.ofName("ns")); + // Call with the container set as the function's namespace + source = "ns.func('hello')"; + runTest(); + + source = "func('hello')"; + runTest(); + + source = "func('hello').member(func('test'))"; + runTest(); + } + + @Test + public void namespacedVariables() { + setContainer(CelContainer.ofName("ns")); + declareVariable("ns.x", SimpleType.INT); + source = "x"; + runTest(ImmutableMap.of("ns.x", 2)); + + setContainer(CelContainer.ofName("dev.cel.testing.testdata.proto3")); + CelType messageType = StructTypeReference.create("cel.expr.conformance.proto3.TestAllTypes"); + declareVariable("dev.cel.testing.testdata.proto3.msgVar", messageType); + source = "msgVar.single_int32"; + runTest( + ImmutableMap.of( + "dev.cel.testing.testdata.proto3.msgVar", + TestAllTypes.newBuilder().setSingleInt32(5).build())); + } + + @Test + public void durationFunctions() { + declareVariable("d1", SimpleType.DURATION); + long totalSeconds = 25 * 3600 + 59 * 60 + 1; + long nanos = 11000000; + Duration d1 = Duration.ofSeconds(totalSeconds, nanos); + Duration d2 = Duration.ofSeconds(-totalSeconds, -nanos); + + setContainer(CelContainer.ofName(Type.getDescriptor().getFile().getPackage())); + + source = "d1.getHours()"; + runTest(ImmutableMap.of("d1", d1)); + runTest(ImmutableMap.of("d1", d2)); + + source = "d1.getMinutes()"; + runTest(ImmutableMap.of("d1", d1)); + runTest(ImmutableMap.of("d1", d2)); + + source = "d1.getSeconds()"; + runTest(ImmutableMap.of("d1", d1)); + runTest(ImmutableMap.of("d1", d2)); + + source = "d1.getMilliseconds()"; + runTest(ImmutableMap.of("d1", d1)); + runTest(ImmutableMap.of("d1", d2)); + + declareVariable("val", SimpleType.INT); + source = "d1.getHours() < val"; + runTest(extend(ImmutableMap.of("d1", d1), ImmutableMap.of("val", 30L))); + source = "d1.getMinutes() > val"; + runTest(extend(ImmutableMap.of("d1", d1), ImmutableMap.of("val", 30L))); + source = "d1.getSeconds() > val"; + runTest(extend(ImmutableMap.of("d1", d1), ImmutableMap.of("val", 30L))); + source = "d1.getMilliseconds() < val"; + runTest(extend(ImmutableMap.of("d1", d1), ImmutableMap.of("val", 30L))); + } + + @Test + public void timestampFunctions() { + declareVariable("ts1", SimpleType.TIMESTAMP); + setContainer(CelContainer.ofName(Type.getDescriptor().getFile().getPackage())); + Instant ts1 = Instant.ofEpochSecond(1, 11000000); + Instant ts2 = Instant.ofEpochSecond(-1, 0); + + source = "ts1.getFullYear(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getFullYear()"; + runTest(ImmutableMap.of("ts1", ts1)); + runTest(ImmutableMap.of("ts1", ts2)); + source = "ts1.getFullYear(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getFullYear(\"2:00\")"; + runTest(ImmutableMap.of("ts1", ts1)); + + source = "ts1.getMonth(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getMonth()"; + runTest(ImmutableMap.of("ts1", ts1)); + runTest(ImmutableMap.of("ts1", ts2)); + source = "ts1.getMonth(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getMonth(\"-8:15\")"; + runTest(ImmutableMap.of("ts1", ts1)); + + source = "ts1.getDayOfYear(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getDayOfYear()"; + runTest(ImmutableMap.of("ts1", ts1)); + runTest(ImmutableMap.of("ts1", ts2)); + source = "ts1.getDayOfYear(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getDayOfYear(\"-9:00\")"; + runTest(ImmutableMap.of("ts1", ts1)); + + source = "ts1.getDayOfMonth(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getDayOfMonth()"; + runTest(ImmutableMap.of("ts1", ts1)); + runTest(ImmutableMap.of("ts1", ts2)); + source = "ts1.getDayOfMonth(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getDayOfMonth(\"8:00\")"; + runTest(ImmutableMap.of("ts1", ts1)); + + source = "ts1.getDate(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getDate()"; + runTest(ImmutableMap.of("ts1", ts1)); + runTest(ImmutableMap.of("ts1", ts2)); + source = "ts1.getDate(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getDate(\"9:30\")"; + runTest(ImmutableMap.of("ts1", ts1)); + + Instant tsSunday = Instant.ofEpochSecond(3 * 24 * 3600); + source = "ts1.getDayOfWeek(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", tsSunday)); + source = "ts1.getDayOfWeek()"; + runTest(ImmutableMap.of("ts1", tsSunday)); + runTest(ImmutableMap.of("ts1", ts2)); + source = "ts1.getDayOfWeek(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", tsSunday)); + source = "ts1.getDayOfWeek(\"-9:30\")"; + runTest(ImmutableMap.of("ts1", tsSunday)); + + source = "ts1.getHours(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getHours()"; + runTest(ImmutableMap.of("ts1", ts1)); + runTest(ImmutableMap.of("ts1", ts2)); + source = "ts1.getHours(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getHours(\"6:30\")"; + runTest(ImmutableMap.of("ts1", ts1)); + + source = "ts1.getMinutes(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getMinutes()"; + runTest(ImmutableMap.of("ts1", ts1)); + runTest(ImmutableMap.of("ts1", ts2)); + source = "ts1.getMinutes(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getMinutes(\"-8:00\")"; + runTest(ImmutableMap.of("ts1", ts1)); + + source = "ts1.getSeconds(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getSeconds()"; + runTest(ImmutableMap.of("ts1", ts1)); + runTest(ImmutableMap.of("ts1", ts2)); + source = "ts1.getSeconds(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getSeconds(\"-8:00\")"; + runTest(ImmutableMap.of("ts1", ts1)); + + source = "ts1.getMilliseconds(\"America/Los_Angeles\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getMilliseconds()"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getMilliseconds(\"Indian/Cocos\")"; + runTest(ImmutableMap.of("ts1", ts1)); + source = "ts1.getMilliseconds(\"-8:00\")"; + runTest(ImmutableMap.of("ts1", ts1)); + + declareVariable("val", SimpleType.INT); + source = "ts1.getFullYear() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 2013L))); + source = "ts1.getMonth() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 12L))); + source = "ts1.getDayOfYear() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 13L))); + source = "ts1.getDayOfMonth() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 10L))); + source = "ts1.getDate() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 15L))); + source = "ts1.getDayOfWeek() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 15L))); + source = "ts1.getHours() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 15L))); + source = "ts1.getMinutes() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 15L))); + source = "ts1.getSeconds() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 15L))); + source = "ts1.getMilliseconds() < val"; + runTest(extend(ImmutableMap.of("ts1", ts1), ImmutableMap.of("val", 15L))); + } + + @Test + public void unknownField() { + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + + // Unknown field is accessed. + source = "x.single_int32"; + runTest(); + + source = "x.map_int32_int64[22]"; + runTest(); + + source = "x.repeated_nested_message[1]"; + runTest(); + + // Function call for an unknown field. + source = "x.single_timestamp.getSeconds()"; + runTest(); + + // Unknown field in a nested message + source = "x.single_nested_message.bb"; + runTest(); + + // Unknown field access in a map. + source = "{1: x.single_int32}"; + runTest(); + + // Unknown field access in a list. + source = "[1, x.single_int32]"; + runTest(); + } + + @Test + public void unknownResultSet() { + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + TestAllTypes message = + TestAllTypes.newBuilder() + .setSingleString("test") + .setSingleTimestamp(Timestamp.newBuilder().setSeconds(15)) + .build(); + + // unknown && true ==> unknown + source = "x.single_int32 == 1 && true"; + runTest(); + + // unknown && false ==> false + source = "x.single_int32 == 1 && false"; + runTest(); + + // unknown && Unknown ==> UnknownSet + source = "x.single_int32 == 1 && x.single_int64 == 1"; + runTest(); + + // unknown && error ==> unknown + source = "x.single_int32 == 1 && x.single_timestamp <= timestamp(\"bad timestamp string\")"; + runTest(); + + // true && unknown ==> unknown + source = "true && x.single_int32 == 1"; + runTest(); + + // false && unknown ==> false + source = "false && x.single_int32 == 1"; + runTest(); + + // error && unknown ==> unknown + source = "x.single_timestamp <= timestamp(\"bad timestamp string\") && x.single_int32 == 1"; + runTest(); + + // error && error ==> error + source = + "x.single_timestamp <= timestamp(\"bad timestamp string\") " + + "&& x.single_timestamp > timestamp(\"another bad timestamp string\")"; + runTest(); + + // unknown || true ==> true + source = "x.single_int32 == 1 || x.single_string == \"test\""; + runTest(); + + // unknown || false ==> unknown + source = "x.single_int32 == 1 || x.single_string != \"test\""; + runTest(); + + // unknown || unknown ==> UnknownSet + source = "x.single_int32 == 1 || x.single_int64 == 1"; + runTest(); + + // unknown || error ==> unknown + source = "x.single_int32 == 1 || x.single_timestamp <= timestamp(\"bad timestamp string\")"; + runTest(); + + // true || unknown ==> true + source = "true || x.single_int32 == 1"; + runTest(); + + // false || unknown ==> unknown + source = "false || x.single_int32 == 1"; + runTest(); + + // error || unknown ==> unknown + source = "x.single_timestamp <= timestamp(\"bad timestamp string\") || x.single_int32 == 1"; + runTest(); + + // error || error ==> error + source = + "x.single_timestamp <= timestamp(\"bad timestamp string\") " + + "|| x.single_timestamp > timestamp(\"another bad timestamp string\")"; + runTest(); + + // dispatch test + declareFunction( + "f", memberOverload("f", Arrays.asList(SimpleType.INT, SimpleType.INT), SimpleType.BOOL)); + addFunctionBinding(CelFunctionBinding.from("f", Integer.class, Integer.class, Objects::equals)); + + // dispatch: unknown.f(1) ==> unknown + source = "x.single_int32.f(1)"; + runTest(); + + // dispatch: 1.f(unknown) ==> unknown + source = "1.f(x.single_int32)"; + runTest(); + + // dispatch: unknown.f(unknown) ==> unknownSet + source = "x.single_int64.f(x.single_int32)"; + runTest(); + + // ident is null(x is unbound) ==> unknown + source = "x"; + runTest(ImmutableMap.of("y", message)); + + // ident is unknown ==> unknown + source = "x"; + CelUnknownSet unknownMessage = CelUnknownSet.create(1L); + runTest(ImmutableMap.of("x", unknownMessage)); + + // comprehension test + // iteRange is unknown => unknown + source = "x.map_int32_int64.map(x, x > 0, x + 1)"; + runTest(); + + // exists, loop condition encounters unknown => skip unknown and check other element + source = "[0, 2, 4].exists(z, z == 2 || z == x.single_int32)"; + runTest(); + + // exists, loop condition encounters unknown => skip unknown and check other element, no dupe id + // in result + source = "[0, 2, 4].exists(z, z == x.single_int32)"; + runTest(); + + // exists_one, loop condition encounters unknown => collect all unknowns + source = + "[0, 2, 4].exists_one(z, z == 0 || (z == 2 && z == x.single_int32) " + + "|| (z == 4 && z == x.single_int64))"; + runTest(); + + // all, loop condition encounters unknown => skip unknown and check other element + source = "[0, 2].all(z, z == 2 || z == x.single_int32)"; + runTest(); + + // filter, loop condition encounters unknown => skip unknown and check other element + source = + "[0, 2, 4].filter(z, z == 0 || (z == 2 && z == x.single_int32) " + + "|| (z == 4 && z == x.single_int64))"; + runTest(); + + // map, loop condition encounters unknown => skip unknown and check other element + source = + "[0, 2, 4].map(z, z == 0 || (z == 2 && z == x.single_int32) " + + "|| (z == 4 && z == x.single_int64))"; + runTest(); + + // conditional test + // unknown ? 1 : 2 ==> unknown + source = "x.single_int32 == 1 ? 1 : 2"; + runTest(); + + // true ? unknown : 2 ==> unknown + source = "true ? x.single_int32 : 2"; + runTest(); + + // true ? 1 : unknown ==> 1 + source = "true ? 1 : x.single_int32"; + runTest(); + + // false ? unknown : 2 ==> 2 + source = "false ? x.single_int32 : 2"; + runTest(); + + // false ? 1 : unknown ==> unknown + source = "false ? 1 : x.single_int32"; + runTest(); + + // unknown condition ? unknown : unknown ==> unknown condition + source = "x.single_int64 == 1 ? x.single_int32 : x.single_int32"; + runTest(); + + // map with unknown key => unknown + source = "{x.single_int32: 2, 3: 4}"; + runTest(); + + // map with unknown value => unknown + source = "{1: x.single_int32, 3: 4}"; + runTest(); + + // map with unknown key and value => unknownSet + source = "{1: x.single_int32, x.single_int64: 4}"; + runTest(); + + // list with unknown => unknown + source = "[1, x.single_int32, 3, 4]"; + runTest(); + + // list with multiple unknowns => unknownSet + source = "[1, x.single_int32, x.single_int64, 4]"; + runTest(); + + // message with unknown => unknown + source = "TestAllTypes{single_int32: x.single_int32}.single_int32 == 2"; + runTest(); + + // message with multiple unknowns => unknownSet + source = "TestAllTypes{single_int32: x.single_int32, single_int64: x.single_int64}"; + runTest(); + + // type(unknown) -> unknown + source = "type(x.single_int32)"; + runTest(); + + // type(error) -> error + source = "type(1 / 0 > 2)"; + runTest(); + } + + @Test + public void timeConversions() { + setContainer(CelContainer.ofName(Type.getDescriptor().getFile().getPackage())); + declareVariable("t1", SimpleType.TIMESTAMP); + + source = "timestamp(\"1972-01-01T10:00:20.021-05:00\")"; + runTest(); + + source = "timestamp(123)"; + runTest(); + + source = "duration(\"15.11s\")"; + runTest(); + + source = "int(t1) == 100"; + runTest(ImmutableMap.of("t1", Instant.ofEpochSecond(100))); + + source = "duration(\"1h2m3.4s\")"; + runTest(); + + source = "duration(duration('15.0s'))"; // Identity + runTest(); + + source = "timestamp(timestamp(123))"; // Identity + runTest(); + } + + @Test + public void timeConversions_error() { + source = "duration('inf')"; + runTest(); + } + + @Test + public void sizeTests() { + setContainer(CelContainer.ofName(Type.getDescriptor().getFile().getPackage())); + declareVariable("str", SimpleType.STRING); + declareVariable("b", SimpleType.BYTES); + + source = "size(b) == 5 && b.size() == 5"; + runTest(ImmutableMap.of("b", CelByteString.copyFromUtf8("happy"))); + + source = "size(str) == 5 && str.size() == 5"; + runTest(ImmutableMap.of("str", "happy")); + runTest(ImmutableMap.of("str", "happ\uDBFF\uDFFC")); + + source = "size({1:14, 2:15}) == 2 && {1:14, 2:15}.size() == 2"; + runTest(); + + source = "size([1,2,3]) == 3 && [1,2,3].size() == 3"; + runTest(); + } + + @Test + public void nonstrictQuantifierTests() { + // Plain tests. Everything is constant. + source = "[0, 2, 4].exists(x, 4/x == 2 && 4/(4-x) == 2)"; + runTest(); + + source = "![0, 2, 4].all(x, 4/x != 2 && 4/(4-x) != 2)"; + runTest(); + + declareVariable("four", SimpleType.INT); + + // Condition is dynamic. + source = "[0, 2, 4].exists(x, four/x == 2 && four/(four-x) == 2)"; + runTest(ImmutableMap.of("four", 4L)); + + source = "![0, 2, 4].all(x, four/x != 2 && four/(four-x) != 2)"; + runTest(ImmutableMap.of("four", 4L)); + + // Both range and condition are dynamic. + source = "[0, 2, four].exists(x, four/x == 2 && four/(four-x) == 2)"; + runTest(ImmutableMap.of("four", 4L)); + + source = "![0, 2, four].all(x, four/x != 2 && four/(four-x) != 2)"; + runTest(ImmutableMap.of("four", 4L)); + + // Unknown argument + source = "[0, 1].exists(x, x > four || true)"; + runTest(); + } + + @Test + public void regexpMatchingTests() { + // Constant everything. + source = "matches(\"alpha\", \"^al.*\") == true"; + runTest(); + + source = "matches(\"alpha\", \"^.al.*\") == false"; + runTest(); + + source = "matches(\"alpha\", \".*ha$\") == true"; + runTest(); + + source = "matches(\"alpha\", \"^.*ha.$\") == false"; + runTest(); + + source = "matches(\"alpha\", \"\") == true"; + runTest(); + + source = "matches(\"alpha\", \"ph\") == true"; + runTest(); + + source = "matches(\"alpha\", \"^ph\") == false"; + runTest(); + + source = "matches(\"alpha\", \"ph$\") == false"; + runTest(); + + // Constant everything, receiver-style. + source = "\"alpha\".matches(\"^al.*\") == true"; + runTest(); + + source = "\"alpha\".matches(\"^.al.*\") == false"; + runTest(); + + source = "\"alpha\".matches(\".*ha$\") == true"; + runTest(); + + source = "\"alpha\".matches(\".*ha.$\") == false"; + runTest(); + + source = "\"alpha\".matches(\"\") == true"; + runTest(); + + source = "\"alpha\".matches(\"ph\") == true"; + runTest(); + + source = "\"alpha\".matches(\"^ph\") == false"; + runTest(); + + source = "\"alpha\".matches(\"ph$\") == false"; + runTest(); + + // Constant string. + declareVariable("regexp", SimpleType.STRING); + + source = "matches(\"alpha\", regexp) == true"; + runTest(ImmutableMap.of("regexp", "^al.*")); + + source = "matches(\"alpha\", regexp) == false"; + runTest(ImmutableMap.of("regexp", "^.al.*")); + + source = "matches(\"alpha\", regexp) == true"; + runTest(ImmutableMap.of("regexp", ".*ha$")); + + source = "matches(\"alpha\", regexp) == false"; + runTest(ImmutableMap.of("regexp", ".*ha.$")); + + // Constant string, receiver-style. + source = "\"alpha\".matches(regexp) == true"; + runTest(ImmutableMap.of("regexp", "^al.*")); + + source = "\"alpha\".matches(regexp) == false"; + runTest(ImmutableMap.of("regexp", "^.al.*")); + + source = "\"alpha\".matches(regexp) == true"; + runTest(ImmutableMap.of("regexp", ".*ha$")); + + source = "\"alpha\".matches(regexp) == false"; + runTest(ImmutableMap.of("regexp", ".*ha.$")); + + // Constant regexp. + declareVariable("s", SimpleType.STRING); + + source = "matches(s, \"^al.*\") == true"; + runTest(ImmutableMap.of("s", "alpha")); + + source = "matches(s, \"^.al.*\") == false"; + runTest(ImmutableMap.of("s", "alpha")); + + source = "matches(s, \".*ha$\") == true"; + runTest(ImmutableMap.of("s", "alpha")); + + source = "matches(s, \"^.*ha.$\") == false"; + runTest(ImmutableMap.of("s", "alpha")); + + // Constant regexp, receiver-style. + source = "s.matches(\"^al.*\") == true"; + runTest(ImmutableMap.of("s", "alpha")); + + source = "s.matches(\"^.al.*\") == false"; + runTest(ImmutableMap.of("s", "alpha")); + + source = "s.matches(\".*ha$\") == true"; + runTest(ImmutableMap.of("s", "alpha")); + + source = "s.matches(\"^.*ha.$\") == false"; + runTest(ImmutableMap.of("s", "alpha")); + + // No constants. + source = "matches(s, regexp) == true"; + runTest(ImmutableMap.of("s", "alpha", "regexp", "^al.*")); + runTest(ImmutableMap.of("s", "alpha", "regexp", ".*ha$")); + + source = "matches(s, regexp) == false"; + runTest(ImmutableMap.of("s", "alpha", "regexp", "^.al.*")); + runTest(ImmutableMap.of("s", "alpha", "regexp", ".*ha.$")); + + // No constants, receiver-style. + source = "s.matches(regexp) == true"; + runTest(ImmutableMap.of("s", "alpha", "regexp", "^al.*")); + runTest(ImmutableMap.of("s", "alpha", "regexp", ".*ha$")); + + source = "s.matches(regexp) == false"; + runTest(ImmutableMap.of("s", "alpha", "regexp", "^.al.*")); + runTest(ImmutableMap.of("s", "alpha", "regexp", ".*ha.$")); + } + + @Test + public void regexpMatches_error() { + source = "matches(\"alpha\", \"**\")"; + runTest(); + + source = "\"alpha\".matches(\"**\")"; + runTest(); + } + + @Test + public void int64Conversions() { + source = "int('-1')"; // string converts to -1 + runTest(); + + source = "int(2.1)"; // double converts to 2 + runTest(); + + source = "int(42u)"; // converts to 42 + runTest(); + } + + @Test + public void int64Conversions_error() { + source = "int(18446744073709551615u)"; // 2^64-1 should error + runTest(); + + source = "int(1e99)"; // out of range should error + runTest(); + } + + @Test + public void uint64Conversions() { + // The test case `uint(1e19)` succeeds with unsigned longs and fails with longs in a way that + // cannot be easily tested. + if (!BASE_CEL_OPTIONS.enableUnsignedLongs()) { + skipBaselineVerification(); + return; + } + source = "uint('1')"; // string converts to 1u + runTest(); + + source = "uint(2.1)"; // double converts to 2u + runTest(); + + source = "uint(1e19)"; // valid uint but outside of int range + runTest(); + + source = "uint(42)"; // int converts to 42u + runTest(); + + source = "uint(1u)"; // identity + runTest(); + + source = "uint(dyn(1u))"; // identity, check dynamic dispatch + runTest(); + } + + @Test + public void uint64Conversions_error() { + source = "uint(-1)"; // should error + runTest(); + + source = "uint(6.022e23)"; // outside uint range + runTest(); + + source = "uint('f1')"; // should error + runTest(); + } + + @Test + public void doubleConversions() { + source = "double('1.1')"; // string converts to 1.1 + runTest(); + + source = "double(2u)"; // uint converts to 2.0 + runTest(); + + source = "double(-1)"; // int converts to -1.0 + runTest(); + + source = "double(1.5)"; // Identity + runTest(); + } + + @Test + public void doubleConversions_error() { + source = "double('bad')"; + runTest(); + } + + @Test + public void stringConversions() { + source = "string(1.1)"; // double converts to '1.1' + runTest(); + + source = "string(2u)"; // uint converts to '2' + runTest(); + + source = "string(-1)"; // int converts to '-1' + runTest(); + + source = "string(true)"; // bool converts to 'true' + runTest(); + + // Byte literals in Google SQL only take the leading byte of an escape character. + // This means that to translate a byte literal to a UTF-8 encoded string, all bytes must be + // encoded in the literal as they would be laid out in memory for UTF-8, hence the extra octal + // escape to achieve parity with the bidi test below. + source = "string(b'abc\\303\\203')"; + runTest(); // bytes convert to 'abcÃ' + + // Bi-di conversion for strings and bytes for 'abcÃ', note the difference between the string + // and byte literal values. + source = "string(bytes('abc\\303'))"; + runTest(); + + source = "string(timestamp('2009-02-13T23:31:30Z'))"; + runTest(); + + source = "string(duration('1000000s'))"; + runTest(); + + source = "string('hello')"; // Identity + runTest(); + } + + @Test + public void stringConversions_error() throws Exception { + source = "string(b'\\xff')"; + runTest(); + } + + @Test + public void bytes() throws Exception { + source = + "b'a' < b'b' && b'a' <= b'b' && b'b' > b'a' && b'a' >= b'a' && b'a' == b'a' && b'a' !=" + + " b'b'"; + runTest(); + } + + @Test + public void boolConversions() { + source = "bool(true)"; + runTest(); // Identity + + source = "bool('true') && bool('TRUE') && bool('True') && bool('t') && bool('1')"; + runTest(); // result is true + + source = "bool('false') || bool('FALSE') || bool('False') || bool('f') || bool('0')"; + runTest(); // result is false + } + + @Test + public void boolConversions_error() { + source = "bool('TrUe')"; + runTest(); + + source = "bool('FaLsE')"; + runTest(); + } + + @Test + public void bytesConversions() { + source = "bytes('abc\\303')"; + runTest(); // string converts to abcà in bytes form. + + source = "bytes(bytes('abc\\303'))"; // Identity + runTest(); + } + + @Test + public void dynConversions() { + source = "dyn(42)"; + runTest(); + + source = "dyn({'a':1, 'b':2})"; + runTest(); + } + + @Test + public void dyn_error() { + source = "dyn('hello').invalid"; + runTest(); + + source = "has(dyn('hello').invalid)"; + runTest(); + + source = "dyn([]).invalid"; + runTest(); + + source = "has(dyn([]).invalid)"; + runTest(); + } + + @Test + public void jsonValueTypes() { + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + + // JSON bool selection. + TestAllTypes xBool = + TestAllTypes.newBuilder().setSingleValue(Value.newBuilder().setBoolValue(true)).build(); + source = "x.single_value"; + runTest(ImmutableMap.of("x", xBool)); + + // JSON number selection with int comparison. + TestAllTypes xInt = + TestAllTypes.newBuilder().setSingleValue(Value.newBuilder().setNumberValue(1)).build(); + source = "x.single_value == double(1)"; + runTest(ImmutableMap.of("x", xInt)); + + // JSON number selection with float comparison. + TestAllTypes xFloat = + TestAllTypes.newBuilder().setSingleValue(Value.newBuilder().setNumberValue(1.1)).build(); + source = "x.single_value == 1.1"; + runTest(ImmutableMap.of("x", xFloat)); + + // JSON null selection. + TestAllTypes xNull = + TestAllTypes.newBuilder() + .setSingleValue(Value.newBuilder().setNullValue(NullValue.NULL_VALUE)) + .build(); + source = "x.single_value == null"; + runTest(ImmutableMap.of("x", xNull)); + + // JSON string selection. + TestAllTypes xString = + TestAllTypes.newBuilder() + .setSingleValue(Value.newBuilder().setStringValue("hello")) + .build(); + source = "x.single_value == 'hello'"; + runTest(ImmutableMap.of("x", xString)); + + // json manual construction + source = "google.protobuf.Value{string_value: 'hello'} == 'hello'"; + runTest(); + + source = "google.protobuf.Value{number_value: 1.1} == 1.1"; + runTest(); + + source = "google.protobuf.Value{null_value: google.protobuf.NullValue.NULL_VALUE} == null"; + runTest(); + + // NULL_VALUE is not the same as null. + source = "TestAllTypes{null_value: google.protobuf.NullValue.NULL_VALUE}.null_value == 0"; + runTest(); + source = + "TestAllTypes{null_value: google.protobuf.NullValue.NULL_VALUE}.null_value != dyn(null)"; + runTest(); + + // JSON list equality. + TestAllTypes xList = + TestAllTypes.newBuilder() + .setSingleValue( + Value.newBuilder() + .setListValue( + ListValue.newBuilder() + .addValues( + Value.newBuilder() + .setListValue( + ListValue.newBuilder() + .addValues(Value.newBuilder().setStringValue("hello")))) + .addValues(Value.newBuilder().setNumberValue(-1.1)))) + .build(); + source = "x.single_value[0] == [['hello'], -1.1][0]"; + runTest(ImmutableMap.of("x", xList)); + + // JSON struct equality. + TestAllTypes xStruct = + TestAllTypes.newBuilder() + .setSingleStruct( + Struct.newBuilder() + .putFields( + "str", + Value.newBuilder() + .setListValue( + ListValue.newBuilder() + .addValues(Value.newBuilder().setStringValue("hello"))) + .build()) + .putFields("num", Value.newBuilder().setNumberValue(-1.1).build())) + .build(); + source = "x.single_struct.num == {'str': ['hello'], 'num': -1.1}['num']"; + runTest(ImmutableMap.of("x", xStruct)); + + // Build a proto message using a dynamically constructed map and assign the map to a struct + // value. + source = + "TestAllTypes{" + + "single_struct: " + + "TestAllTypes{single_value: {'str': ['hello']}}.single_value" + + "}"; + runTest(); + + // Ensure that types are being wrapped and unwrapped on function dispatch. + declareFunction( + "pair", + globalOverload( + "pair", ImmutableList.of(SimpleType.STRING, SimpleType.STRING), SimpleType.DYN)); + addFunctionBinding( + CelFunctionBinding.from( + "pair", + ImmutableList.of(String.class, String.class), + (Object[] args) -> { + String key = (String) args[0]; + String val = (String) args[1]; + return Value.newBuilder() + .setStructValue( + Struct.newBuilder() + .putFields(key, Value.newBuilder().setStringValue(val).build())) + .build(); + })); + source = "pair(x.single_struct.str[0], 'val')"; + runTest(ImmutableMap.of("x", xStruct)); + } + + @Test + public void jsonConversions() { + declareVariable("ts", SimpleType.TIMESTAMP); + declareVariable("du", SimpleType.DURATION); + source = "google.protobuf.Struct { fields: {'timestamp': ts, 'duration': du } }"; + runTest( + ImmutableMap.of( + "ts", + ProtoTimeUtils.fromSecondsToTimestamp(100), + "du", + ProtoTimeUtils.fromMillisToDuration(200))); + } + + @Test + public void typeComparisons() { + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + + // Test numeric types. + source = + "type(1) == int && type(1u) == uint && " + + "type(1u) != int && type(1) != uint && " + + "type(uint(1.1)) == uint && " + + "type(1.1) == double"; + runTest(); + + // Test string and bytes types. + source = "type('hello') == string && type(b'\277') == bytes"; + runTest(); + + // Test list and map types. + source = "type([1, 2, 3]) == list && type({'a': 1, 'b': 2}) == map"; + runTest(); + + // Test bool types. + source = "type(true) == bool && type(false) == bool"; + runTest(); + + // Test well-known proto-based types. + source = "type(duration('10s')) == google.protobuf.Duration"; + runTest(); + + // Test external proto-based types with container resolution. + source = + "type(TestAllTypes{}) == TestAllTypes && " + + "type(TestAllTypes{}) == proto3.TestAllTypes && " + + "type(TestAllTypes{}) == .cel.expr.conformance.proto3.TestAllTypes && " + + "type(proto3.TestAllTypes{}) == TestAllTypes && " + + "type(proto3.TestAllTypes{}) == proto3.TestAllTypes && " + + "type(proto3.TestAllTypes{}) == .cel.expr.conformance.proto3.TestAllTypes && " + + "type(.cel.expr.conformance.proto3.TestAllTypes{}) == TestAllTypes && " + + "type(.cel.expr.conformance.proto3.TestAllTypes{}) == proto3.TestAllTypes && " + + "type(.cel.expr.conformance.proto3.TestAllTypes{}) == " + + ".cel.expr.conformance.proto3.TestAllTypes"; + runTest(); + + // Test whether a type name is recognized as a type. + source = "type(TestAllTypes) == type"; + runTest(); + + // Test whether the type resolution of a proto object is recognized as the message's type. + source = "type(TestAllTypes{}) == TestAllTypes"; + runTest(); + + // Test whether null resolves to null_type. + source = "type(null) == null_type"; + runTest(); + + // Test runtime resolution of types + source = + "type(duration) == google.protobuf.Duration && " + + "type(timestamp) == google.protobuf.Timestamp"; + // Intentionally declare as dyns + declareVariable("duration", SimpleType.DYN); + declareVariable("timestamp", SimpleType.DYN); + runTest(ImmutableMap.of("duration", java.time.Duration.ZERO, "timestamp", Instant.EPOCH)); + } + + @Test + public void wrappers() throws Exception { + TestAllTypes.Builder wrapperBindings = + TestAllTypes.newBuilder() + .setSingleBoolWrapper(BoolValue.of(true)) + .setSingleBytesWrapper(BytesValue.of(ByteString.copyFrom(new byte[] {'h', 'i'}))) + .setSingleDoubleWrapper(DoubleValue.of(-3.0)) + .setSingleFloatWrapper(FloatValue.of(1.5f)) + .setSingleInt32Wrapper(Int32Value.of(-12)) + .setSingleInt64Wrapper(Int64Value.of(-34)) + .setSingleStringWrapper(StringValue.of("hello")) + .setSingleUint32Wrapper(UInt32Value.of(12)) + .setSingleUint64Wrapper(UInt64Value.of(34)); + + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + source = + "x.single_bool_wrapper == true && " + + "x.single_bytes_wrapper == b'hi' && " + + "x.single_double_wrapper == -3.0 && " + + "x.single_float_wrapper == 1.5 && " + + "x.single_int32_wrapper == -12 && " + + "x.single_int64_wrapper == -34 && " + + "x.single_string_wrapper == 'hello' && " + + "x.single_uint32_wrapper == 12u && " + + "x.single_uint64_wrapper == 34u"; + runTest(ImmutableMap.of("x", wrapperBindings)); + + source = + "x.single_bool_wrapper == google.protobuf.BoolValue{} && " + + "x.single_bytes_wrapper == google.protobuf.BytesValue{value: b'hi'} && " + + "x.single_double_wrapper == google.protobuf.DoubleValue{value: -3.0} && " + + "x.single_float_wrapper == google.protobuf.FloatValue{value: 1.5} && " + + "x.single_int32_wrapper == google.protobuf.Int32Value{value: -12} && " + + "x.single_int64_wrapper == google.protobuf.Int64Value{value: -34} && " + + "x.single_string_wrapper == google.protobuf.StringValue{} && " + + "x.single_uint32_wrapper == google.protobuf.UInt32Value{value: 12u} && " + + "x.single_uint64_wrapper == google.protobuf.UInt64Value{value: 34u}"; + runTest( + ImmutableMap.of( + "x", + wrapperBindings + .setSingleBoolWrapper(BoolValue.getDefaultInstance()) + .setSingleStringWrapper(StringValue.getDefaultInstance()))); + + source = + "x.repeated_int32_wrapper == [1,2] && " + + "x.repeated_int64_wrapper == [3] && " + + "x.repeated_float_wrapper == [1.5, 2.5] && " + + "x.repeated_double_wrapper == [3.5, 4.5] && " + + "x.repeated_string_wrapper == ['foo', 'bar'] && " + + "x.repeated_bool_wrapper == [true] && " + + "x.repeated_uint32_wrapper == [1u, 2u] && " + + "x.repeated_uint64_wrapper == []"; + + runTest( + ImmutableMap.of( + "x", + wrapperBindings + .addRepeatedInt32Wrapper(Int32Value.of(1)) + .addRepeatedInt32Wrapper(Int32Value.of(2)) + .addRepeatedInt64Wrapper(Int64Value.of(3)) + .addRepeatedFloatWrapper(FloatValue.of(1.5f)) + .addRepeatedFloatWrapper(FloatValue.of(2.5f)) + .addRepeatedDoubleWrapper(DoubleValue.of(3.5f)) + .addRepeatedDoubleWrapper(DoubleValue.of(4.5f)) + .addRepeatedStringWrapper(StringValue.of("foo")) + .addRepeatedStringWrapper(StringValue.of("bar")) + .addRepeatedBoolWrapper(BoolValue.of(true)) + .addRepeatedUint32Wrapper(UInt32Value.of(1)) + .addRepeatedUint32Wrapper(UInt32Value.of(2)))); + + source = + "x.single_bool_wrapper == null && " + + "x.single_bytes_wrapper == null && " + + "x.single_double_wrapper == null && " + + "x.single_float_wrapper == null && " + + "x.single_int32_wrapper == null && " + + "x.single_int64_wrapper == null && " + + "x.single_string_wrapper == null && " + + "x.single_uint32_wrapper == null && " + + "x.single_uint64_wrapper == null"; + runTest(ImmutableMap.of("x", TestAllTypes.getDefaultInstance())); + + declareVariable("dyn_var", SimpleType.DYN); + source = "dyn_var"; + runTest(ImmutableMap.of("dyn_var", NullValue.NULL_VALUE)); + + clearAllDeclarations(); + declareVariable("int32_list", ListType.create(SimpleType.INT)); + declareVariable("int64_list", ListType.create(SimpleType.INT)); + declareVariable("uint32_list", ListType.create(SimpleType.UINT)); + declareVariable("uint64_list", ListType.create(SimpleType.UINT)); + declareVariable("float_list", ListType.create(SimpleType.DOUBLE)); + declareVariable("double_list", ListType.create(SimpleType.DOUBLE)); + declareVariable("bool_list", ListType.create(SimpleType.BOOL)); + declareVariable("string_list", ListType.create(SimpleType.STRING)); + declareVariable("bytes_list", ListType.create(SimpleType.BYTES)); + + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFullName())); + source = + "TestAllTypes{repeated_int32: int32_list}.repeated_int32 == [1] && " + + "TestAllTypes{repeated_int64: int64_list}.repeated_int64 == [2] && " + + "TestAllTypes{repeated_uint32: uint32_list}.repeated_uint32 == [3u] && " + + "TestAllTypes{repeated_uint64: uint64_list}.repeated_uint64 == [4u] && " + + "TestAllTypes{repeated_float: float_list}.repeated_float == [5.5] && " + + "TestAllTypes{repeated_double: double_list}.repeated_double == [6.6] && " + + "TestAllTypes{repeated_bool: bool_list}.repeated_bool == [true] && " + + "TestAllTypes{repeated_string: string_list}.repeated_string == ['hello'] && " + + "TestAllTypes{repeated_bytes: bytes_list}.repeated_bytes == [b'world']"; + + runTest( + ImmutableMap.builder() + .put("int32_list", ImmutableList.of(Int32Value.of(1))) + .put("int64_list", ImmutableList.of(Int64Value.of(2))) + .put("uint32_list", ImmutableList.of(UInt32Value.of(3))) + .put("uint64_list", ImmutableList.of(UInt64Value.of(4))) + .put("float_list", ImmutableList.of(FloatValue.of(5.5f))) + .put("double_list", ImmutableList.of(DoubleValue.of(6.6))) + .put("bool_list", ImmutableList.of(BoolValue.of(true))) + .put("string_list", ImmutableList.of(StringValue.of("hello"))) + .put("bytes_list", ImmutableList.of(BytesValue.of(ByteString.copyFromUtf8("world")))) + .buildOrThrow()); + + clearAllDeclarations(); + // Currently allowed, but will be an error + // See https://github.com/google/cel-spec/pull/501 + source = "google.protobuf.Timestamp{ seconds: 253402300800 }"; + runTest(); + } + + @Test + public void nullAssignability() throws Exception { + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + source = "TestAllTypes{single_int64_wrapper: null}.single_int64_wrapper == null"; + runTest(); + + source = "TestAllTypes{}.single_int64_wrapper == null"; + runTest(); + + source = "has(TestAllTypes{single_int64_wrapper: null}.single_int64_wrapper)"; + runTest(); + + source = "TestAllTypes{single_value: null}.single_value == null"; + runTest(); + + source = "has(TestAllTypes{single_value: null}.single_value)"; + runTest(); + + source = "TestAllTypes{single_timestamp: null}.single_timestamp == timestamp(0)"; + runTest(); + + source = "has(TestAllTypes{single_timestamp: null}.single_timestamp)"; + runTest(); + + source = + "TestAllTypes{repeated_timestamp: [timestamp(1), null]}.repeated_timestamp ==" + + " [timestamp(1)]"; + runTest(); + + source = + "TestAllTypes{map_bool_timestamp: {true: null, false: timestamp(1)}}.map_bool_timestamp ==" + + " {false: timestamp(1)}"; + runTest(); + + source = "TestAllTypes{repeated_any: [1, null]}.repeated_any == [1, null]"; + runTest(); + + source = + "TestAllTypes{map_bool_any: {true: null, false: 1}}.map_bool_any == {true: null, false: 1}"; + runTest(); + + source = + "TestAllTypes{repeated_value: [google.protobuf.Value{bool_value: true}," + + " null]}.repeated_value == [true, null]"; + runTest(); + + source = + "TestAllTypes{map_bool_value: {true: null, false: google.protobuf.Value{bool_value:" + + " true}}}.map_bool_value == {true: null, false: true}"; + runTest(); + } + + @Test + public void longComprehension() { + ImmutableList l = LongStream.range(0L, 1000L).boxed().collect(toImmutableList()); + addFunctionBinding( + CelFunctionBinding.from("constantLongList", ImmutableList.of(), unused -> l)); + + // Comprehension over compile-time constant long list. + declareFunction( + "constantLongList", + globalOverload("constantLongList", ImmutableList.of(), ListType.create(SimpleType.INT))); + source = "size(constantLongList().map(x, x+1)) == 1000"; + runTest(); + + // Comprehension over long list that is not compile-time constant. + declareVariable("longlist", ListType.create(SimpleType.INT)); + source = "size(longlist.map(x, x+1)) == 1000"; + runTest(ImmutableMap.of("longlist", l)); + + // Comprehension over long list where the computation is very slow. + // (This is here pro-forma only since in the synchronous interpreter there + // is no notion of a computation being slow so that another computation can + // build up a stack while waiting.) + addFunctionBinding( + CelFunctionBinding.from("f_slow_inc", Long.class, n -> n + 1L), + CelFunctionBinding.from("f_unleash", Object.class, x -> x)); + declareFunction( + "f_slow_inc", + globalOverload("f_slow_inc", ImmutableList.of(SimpleType.INT), SimpleType.INT)); + declareFunction( + "f_unleash", + globalOverload( + "f_unleash", ImmutableList.of(TypeParamType.create("A")), TypeParamType.create("A"))); + source = "f_unleash(longlist.map(x, f_slow_inc(x)))[0] == 1"; + runTest(ImmutableMap.of("longlist", l)); + } + + @Test + public void maxComprehension() { + // Comprehension over long list that is not compile-time constant. + declareVariable("longlist", ListType.create(SimpleType.INT)); + source = "size(longlist.map(x, x+1)) == 1000"; + + // Comprehension which exceeds the configured iteration limit. + ImmutableList tooLongList = + LongStream.range(0L, COMPREHENSION_MAX_ITERATIONS + 1).boxed().collect(toImmutableList()); + runTest(ImmutableMap.of("longlist", tooLongList)); + + // Sequential iterations within the collective limit of 1000. + source = "longlist.filter(i, i % 2 == 0).map(i, i * 2).map(i, i / 2).size() == 250"; + ImmutableList l = + LongStream.range(0L, COMPREHENSION_MAX_ITERATIONS / 2).boxed().collect(toImmutableList()); + runTest(ImmutableMap.of("longlist", l)); + + // Sequential iterations outside the limit of 1000. + source = "(longlist + [0]).filter(i, i % 2 == 0).map(i, i * 2).map(i, i / 2).size() == 251"; + runTest(ImmutableMap.of("longlist", l)); + + // Nested iteration within the iteration limit. + // Note, there is some double-counting of the inner-loops which causes the iteration limit to + // get tripped sooner than one might expect for the nested case. + source = "longlist.map(i, longlist.map(j, longlist.map(k, [i, j, k]))).size() == 9"; + l = LongStream.range(0L, 9).boxed().collect(toImmutableList()); + runTest(ImmutableMap.of("longlist", l)); + + // Nested iteration which exceeds the iteration limit. This result may be surprising, but the + // limit is tripped precisely because each complete iteration of an inner-loop counts as inner- + // loop + 1 as there's not a clean way to deduct an iteration and only count the inner most + // loop. + l = LongStream.range(0L, 10).boxed().collect(toImmutableList()); + runTest(ImmutableMap.of("longlist", l)); + } + + @Test + public void dynamicMessage_adapted() throws Exception { + TestAllTypes wrapperBindings = + TestAllTypes.newBuilder() + .setSingleAny(Any.pack(NestedMessage.newBuilder().setBb(42).build())) + .setSingleBoolWrapper(BoolValue.of(true)) + .setSingleBytesWrapper(BytesValue.of(ByteString.copyFrom(new byte[] {'h', 'i'}))) + .setSingleDoubleWrapper(DoubleValue.of(-3.0)) + .setSingleFloatWrapper(FloatValue.of(1.5f)) + .setSingleInt32Wrapper(Int32Value.of(-12)) + .setSingleInt64Wrapper(Int64Value.of(-34)) + .setSingleStringWrapper(StringValue.of("hello")) + .setSingleUint32Wrapper(UInt32Value.of(12)) + .setSingleUint64Wrapper(UInt64Value.of(34)) + .setSingleDuration( + com.google.protobuf.Duration.newBuilder().setSeconds(10).setNanos(20)) + .setSingleTimestamp(Timestamp.newBuilder().setSeconds(100).setNanos(200)) + .setSingleValue(Value.newBuilder().setStringValue("a")) + .setSingleStruct( + Struct.newBuilder().putFields("b", Value.newBuilder().setStringValue("c").build())) + .setListValue( + ListValue.newBuilder().addValues(Value.newBuilder().setStringValue("d")).build()) + .build(); + + ImmutableMap input = + ImmutableMap.of( + "msg", + DynamicMessage.parseFrom( + TestAllTypes.getDescriptor(), + wrapperBindings.toByteArray(), + DefaultDescriptorPool.INSTANCE.getExtensionRegistry())); + + declareVariable("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + + source = "msg.single_any"; + assertThat(runTest(input)).isInstanceOf(NestedMessage.class); + + source = "msg.single_bool_wrapper"; + assertThat(runTest(input)).isInstanceOf(Boolean.class); + + source = "msg.single_bytes_wrapper"; + assertThat(runTest(input)).isInstanceOf(String.class); + + source = "msg.single_double_wrapper"; + assertThat(runTest(input)).isInstanceOf(Double.class); + + source = "msg.single_float_wrapper"; + assertThat(runTest(input)).isInstanceOf(Double.class); + + source = "msg.single_int32_wrapper"; + assertThat(runTest(input)).isInstanceOf(Long.class); + + source = "msg.single_int64_wrapper"; + assertThat(runTest(input)).isInstanceOf(Long.class); + + source = "msg.single_string_wrapper"; + assertThat(runTest(input)).isInstanceOf(String.class); + + source = "msg.single_uint32_wrapper"; + assertThat(runTest(input)) + .isInstanceOf(BASE_CEL_OPTIONS.enableUnsignedLongs() ? UnsignedLong.class : Long.class); + + source = "msg.single_uint64_wrapper"; + assertThat(runTest(input)) + .isInstanceOf(BASE_CEL_OPTIONS.enableUnsignedLongs() ? UnsignedLong.class : Long.class); + + source = "msg.single_duration"; + assertThat(runTest(input)).isInstanceOf(java.time.Duration.class); + + source = "msg.single_timestamp"; + assertThat(runTest(input)).isInstanceOf(Instant.class); + + source = "msg.single_value"; + assertThat(runTest(input)).isInstanceOf(String.class); + + source = "msg.single_struct"; + assertThat(runTest(input)).isInstanceOf(Map.class); + + source = "msg.list_value"; + assertThat(runTest(input)).isInstanceOf(List.class); + } + + @Test + public void dynamicMessage_dynamicDescriptor() throws Exception { + setContainer(CelContainer.ofName("dev.cel.testing.testdata.serialized.proto3")); + + source = "TestAllTypes {}"; + assertThat(runTest()).isInstanceOf(DynamicMessage.class); + source = "TestAllTypes { single_int32: 1, single_int64: 2, single_string: 'hello'}"; + assertThat(runTest()).isInstanceOf(DynamicMessage.class); + source = + "TestAllTypes { single_int32: 1, single_int64: 2, single_string: 'hello'}.single_string"; + assertThat(runTest()).isInstanceOf(String.class); + + // Test wrappers + source = "TestAllTypes { single_int32_wrapper: 3 }.single_int32_wrapper"; + assertThat(runTest()).isInstanceOf(Long.class); + source = "TestAllTypes { single_int64_wrapper: 3 }.single_int64_wrapper"; + assertThat(runTest()).isInstanceOf(Long.class); + source = "TestAllTypes { single_bool_wrapper: true }.single_bool_wrapper"; + assertThat(runTest()).isInstanceOf(Boolean.class); + source = "TestAllTypes { single_bytes_wrapper: b'abc' }.single_bytes_wrapper"; + assertThat(runTest()).isInstanceOf(String.class); + source = "TestAllTypes { single_float_wrapper: 1.1 }.single_float_wrapper"; + assertThat(runTest()).isInstanceOf(Double.class); + source = "TestAllTypes { single_double_wrapper: 1.1 }.single_double_wrapper"; + assertThat(runTest()).isInstanceOf(Double.class); + source = "TestAllTypes { single_uint32_wrapper: 2u}.single_uint32_wrapper"; + assertThat(runTest()) + .isInstanceOf(BASE_CEL_OPTIONS.enableUnsignedLongs() ? UnsignedLong.class : Long.class); + source = "TestAllTypes { single_uint64_wrapper: 2u}.single_uint64_wrapper"; + assertThat(runTest()) + .isInstanceOf(BASE_CEL_OPTIONS.enableUnsignedLongs() ? UnsignedLong.class : Long.class); + source = "TestAllTypes { single_list_value: ['a', 1.5, true] }.single_list_value"; + assertThat(runTest()).isInstanceOf(List.class); + + // Test nested messages + source = + "TestAllTypes { standalone_message: TestAllTypes.NestedMessage { } }.standalone_message"; + assertThat(runTest()).isInstanceOf(DynamicMessage.class); + source = + "TestAllTypes { standalone_message: TestAllTypes.NestedMessage { bb: 5}" + + " }.standalone_message.bb"; + assertThat(runTest()).isInstanceOf(Long.class); + source = "TestAllTypes { standalone_enum: TestAllTypes.NestedEnum.BAR }.standalone_enum"; + assertThat(runTest()).isInstanceOf(Long.class); + source = "TestAllTypes { map_string_string: {'key': 'value'}}"; + assertThat(runTest()).isInstanceOf(DynamicMessage.class); + source = "TestAllTypes { map_string_string: {'key': 'value'}}.map_string_string"; + assertThat(runTest()).isInstanceOf(Map.class); + source = "TestAllTypes { map_string_string: {'key': 'value'}}.map_string_string['key']"; + assertThat(runTest()).isInstanceOf(String.class); + + // Test any unpacking + // With well-known type + Any anyDuration = Any.pack(ProtoTimeUtils.fromSecondsToDuration(100)); + declareVariable("dur", SimpleType.TIMESTAMP); + source = "TestAllTypes { single_any: dur }.single_any"; + assertThat(runTest(ImmutableMap.of("dur", anyDuration))).isInstanceOf(Duration.class); + // with custom message + clearAllDeclarations(); + Any anyTestMsg = Any.pack(TestAllTypes.newBuilder().setSingleString("hello").build()); + declareVariable( + "any_packed_test_msg", + StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + source = "TestAllTypes { single_any: any_packed_test_msg }.single_any"; + assertThat(runTest(ImmutableMap.of("any_packed_test_msg", anyTestMsg))) + .isInstanceOf(TestAllTypes.class); + + // Test JSON map behavior + declareVariable( + "test_msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + declareVariable( + "dynamic_msg", StructTypeReference.create(TEST_ALL_TYPE_DYNAMIC_DESCRIPTOR.getFullName())); + DynamicMessage.Builder dynamicMessageBuilder = + DynamicMessage.newBuilder(TEST_ALL_TYPE_DYNAMIC_DESCRIPTOR); + JsonFormat.parser().merge("{ 'map_string_string' : { 'foo' : 'bar' } }", dynamicMessageBuilder); + ImmutableMap input = + ImmutableMap.of("dynamic_msg", dynamicMessageBuilder.build()); + + source = "dynamic_msg"; + assertThat(runTest(input)).isInstanceOf(DynamicMessage.class); + source = "dynamic_msg.map_string_string"; + assertThat(runTest(input)).isInstanceOf(Map.class); + source = "dynamic_msg.map_string_string['foo']"; + assertThat(runTest(input)).isInstanceOf(String.class); + + // Test function dispatch + declareFunction( + "f_msg", + globalOverload( + "f_msg_generated", + ImmutableList.of( + StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())), + SimpleType.BOOL), + globalOverload( + "f_msg_dynamic", + ImmutableList.of( + StructTypeReference.create(TEST_ALL_TYPE_DYNAMIC_DESCRIPTOR.getFullName())), + SimpleType.BOOL)); + addFunctionBinding( + CelFunctionBinding.fromOverloads( + "f_msg", + CelFunctionBinding.from("f_msg_generated", TestAllTypes.class, unused -> true), + CelFunctionBinding.from("f_msg_dynamic", DynamicMessage.class, unused -> true))); + input = + ImmutableMap.of( + "dynamic_msg", dynamicMessageBuilder.build(), + "test_msg", TestAllTypes.newBuilder().setSingleInt64(10L).build()); + + source = "f_msg(dynamic_msg)"; + assertThat(runTest(input)).isInstanceOf(Boolean.class); + source = "f_msg(test_msg)"; + assertThat(runTest(input)).isInstanceOf(Boolean.class); + } + + @Immutable + private static final class RecordedValues { + @SuppressWarnings("Immutable") + private final Map recordedValues = new HashMap<>(); + + @CanIgnoreReturnValue + private Object record(String key, Object value) { + recordedValues.put(key, value); + return value; + } + + private ImmutableMap getRecordedValues() { + return ImmutableMap.copyOf(recordedValues); + } + } + + @Test + public void lateBoundFunctions() throws Exception { + RecordedValues recordedValues = new RecordedValues(); + CelLateFunctionBindings lateBindings = + CelLateFunctionBindings.from( + CelFunctionBinding.from( + "record_string_dyn", String.class, Object.class, recordedValues::record)); + declareFunction( + "record", + globalOverload( + "record_string_dyn", + ImmutableList.of(SimpleType.STRING, SimpleType.DYN), + SimpleType.DYN)); + source = "record('foo', 'bar')"; + assertThat(runTest(ImmutableMap.of(), lateBindings)).isEqualTo("bar"); + assertThat(recordedValues.getRecordedValues()).containsExactly("foo", "bar"); + } + + @Test + public void jsonFieldNames() throws Exception { + this.celOptions = celOptions.toBuilder().enableJsonFieldNames(true).build(); + this.celRuntime = newBaseRuntimeBuilder(celOptions).build(); + + TestAllTypes message = TestAllTypes.newBuilder().setSingleInt32(42).build(); + declareVariable("x", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())); + + source = "x.singleInt32 == 42"; + assertThat(runTest(ImmutableMap.of("x", message))).isEqualTo(true); + + source = "TestAllTypes{singleInt32: 42}.singleInt32 == 42"; + setContainer(CelContainer.ofName(TestAllTypes.getDescriptor().getFile().getPackage())); + assertThat(runTest()).isEqualTo(true); + + skipBaselineVerification(); + } + + /** + * Checks that the CheckedExpr produced by CelCompiler is equal to the one reproduced by the + * native CelAbstractSyntaxTree + */ + private static void assertAstRoundTrip(CelAbstractSyntaxTree ast) { + if (ast.isChecked()) { + CheckedExpr checkedExpr = CelProtoAbstractSyntaxTree.fromCelAst(ast).toCheckedExpr(); + CelProtoAbstractSyntaxTree protoAst = CelProtoAbstractSyntaxTree.fromCelAst(ast); + assertThat(checkedExpr).isEqualTo(protoAst.toCheckedExpr()); + } else { + ParsedExpr parsedExpr = CelProtoAbstractSyntaxTree.fromCelAst(ast).toParsedExpr(); + CelProtoAbstractSyntaxTree protoAst = CelProtoAbstractSyntaxTree.fromCelAst(ast); + assertThat(parsedExpr).isEqualTo(protoAst.toParsedExpr()); + } + } + + private static String readResourceContent(String path) throws IOException { + return Resources.toString(Resources.getResource(Ascii.toLowerCase(path)), UTF_8); + } + + @SuppressWarnings("unchecked") + private void printBinding(Object input, CelAttributePattern... patterns) { + if (input instanceof Map) { + Map inputMap = (Map) input; + if (inputMap.isEmpty() && patterns.length == 0) { + println("bindings: {}"); + return; + } + + boolean first = true; + StringBuilder sb = new StringBuilder().append("{"); + for (Map.Entry entry : inputMap.entrySet()) { + if (!first) { + sb.append(", "); + } + first = false; + sb.append(entry.getKey()); + sb.append("="); + Object value = entry.getValue(); + if (value instanceof CelByteString) { + sb.append(getHumanReadableString((CelByteString) value)); + } else { + sb.append(UnredactedDebugFormatForTest.unredactedToString(entry.getValue())); + } + } + if (patterns.length > 0) { + if (!inputMap.isEmpty()) { + sb.append(", "); + } + sb.append("unknown_attributes="); + sb.append(Arrays.toString(patterns)); + } + sb.append("}"); + println("bindings: " + sb); + } else { + if (patterns.length > 0) { + println("bindings: " + input + ", unknown_attributes=" + Arrays.toString(patterns)); + } else { + println("bindings: " + input); + } + } + } + + private static String getHumanReadableString(CelByteString byteString) { + // Very unfortunate we have to do this at all + StringBuilder sb = new StringBuilder(); + sb.append("["); + byte[] bytes = byteString.toByteArray(); + for (int i = 0; i < bytes.length; i++) { + byte b = bytes[i]; + sb.append(b); + if (i < bytes.length - 1) { + sb.append(", "); + } + } + sb.append("]"); + return sb.toString(); + } + + private static final class TestOnlyVariableResolver implements CelVariableResolver { + private final Map map; + + private static TestOnlyVariableResolver newInstance(Map map) { + return new TestOnlyVariableResolver(map); + } + + @Override + public Optional find(String name) { + return Optional.ofNullable(map.get(name)); + } + + @Override + public String toString() { + return UnredactedDebugFormatForTest.unredactedToString(map); + } + + private TestOnlyVariableResolver(Map map) { + this.map = map; + } + } + + private static CelVariableResolver extend(Map primary, Map secondary) { + return hierarchicalVariableResolver( + TestOnlyVariableResolver.newInstance(primary), + TestOnlyVariableResolver.newInstance(secondary)); + } + + private static CelVariableResolver extend(CelVariableResolver primary, Map secondary) { + return hierarchicalVariableResolver(primary, TestOnlyVariableResolver.newInstance(secondary)); + } + + private void addFunctionBinding(CelFunctionBinding... functionBindings) { + addFunctionBinding(Arrays.asList(functionBindings)); + } + + private void addFunctionBinding(Collection functionBindings) { + celRuntime = celRuntime.toRuntimeBuilder().addFunctionBindings(functionBindings).build(); + } + + private static Descriptor getDeserializedTestAllTypeDescriptor() { + try { + String fdsContent = readResourceContent("testdata/proto3/test_all_types.fds"); + FileDescriptorSet fds = TextFormat.parse(fdsContent, FileDescriptorSet.class); + ImmutableSet fileDescriptors = FileDescriptorSetConverter.convert(fds); + + return fileDescriptors.stream() + .flatMap(f -> f.getMessageTypes().stream()) + .filter( + x -> + x.getFullName().equals("dev.cel.testing.testdata.serialized.proto3.TestAllTypes")) + .findAny() + .orElseThrow( + () -> + new IllegalStateException( + "Could not find deserialized TestAllTypes descriptor.")); + } catch (IOException e) { + throw new RuntimeException("Error loading TestAllTypes descriptor", e); + } + } +} diff --git a/testing/src/main/java/dev/cel/testing/BaselineTestCase.java b/testing/src/main/java/dev/cel/testing/BaselineTestCase.java new file mode 100644 index 000000000..493106451 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/BaselineTestCase.java @@ -0,0 +1,189 @@ +// Copyright 2022 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.testing; + +import static java.nio.charset.StandardCharsets.UTF_8; + +import com.google.common.base.Strings; +import com.google.common.io.Files; +import com.google.common.io.Resources; +import java.io.BufferedWriter; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.IOException; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.PrintWriter; +import java.net.URL; +import java.nio.charset.Charset; +import junit.framework.AssertionFailedError; +import org.junit.Before; +import org.junit.Rule; +import org.junit.rules.TestName; +import org.junit.rules.TestWatcher; +import org.junit.runner.Description; + +/** Test fixture for baseline testing. */ +public abstract class BaselineTestCase { + + /** Exception to use for baseline test failure. */ + public static class BaselineComparisonError extends AssertionFailedError { + private final String testName; + private final String actual; + private final String actualFileLocation; + private final LineDiffer.Diff lineDiff; + private final String baselineFileName; + + /** + * Constructs a baseline comparison error. + * + * @param testName the test which failed. + * @param actual the actual result. + * @param lineDiff the diff between the expected and {@code actual}. + */ + public BaselineComparisonError( + String testName, + String baselineFileName, + String actual, + String actualFileLocation, + LineDiffer.Diff lineDiff) { + this.testName = testName; + this.actual = actual; + this.actualFileLocation = actualFileLocation; + this.lineDiff = lineDiff; + this.baselineFileName = baselineFileName; + } + + @Override + public String getMessage() { + String resultMessage = + String.format( + "Expected for '%s' differs from actual:%n%n\"******New baseline content" + + " is******%n%s%nExpected File: %s%nActual File: %s%nDiff:\n%s", + testName, actual, baselineFileName, actualFileLocation, lineDiff); + + return resultMessage; + } + } + + @Rule public TestName testName = new TestName(); + + private static final String DIRECTORY_TO_COPY_NEW_BASELINE; + + static { + if (!Strings.isNullOrEmpty(System.getenv("COPY_BASELINE_TO_DIR"))) { + DIRECTORY_TO_COPY_NEW_BASELINE = System.getenv("COPY_BASELINE_TO_DIR"); + } else { + DIRECTORY_TO_COPY_NEW_BASELINE = "/tmp"; + } + } + + private OutputStream output; + private PrintWriter writer; + private boolean isVerified; + + /** Returns a print writer to which test results are written. */ + protected PrintWriter testOutput() { + return writer; + } + + protected void println(String text) { + writer.println(text); + } + + /** + * A test watcher which calls baseline verification if the test succeeded. This is like @After, + * but verification is only done if there haven't been other errors. + */ + @Rule + public TestWatcher failerWatcher = + new TestWatcher() { + @Override + protected void succeeded(Description d) { + verify(); + } + }; + + /** Setups the test case. */ + @Before + public void before() throws Exception { + output = new ByteArrayOutputStream(); + writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(output, UTF_8))); + } + + /** Gets expected result or empty string if the files does not exist. */ + protected String getExpected() throws Exception { + URL resourceLocation = Resources.getResource(baselineFileName()); + return Resources.toString(resourceLocation, UTF_8); + } + + /** Gets the directory location of all test-related baseline files. */ + protected String testdataDir() { + return ""; + } + + /** Gets the relative name the baseline data file should have. Can be overridden. */ + protected String baselineFileName() { + String fileName = String.format("%s%s.baseline", testdataDir(), testName.getMethodName()); + // Scrub the parameterized test index from the baseline file name. + return fileName.replaceFirst("\\[.+].baseline$", ".baseline"); + } + + /** Verifies the recorded content against the baseline. */ + protected void verify() { + if (isVerified) { + return; + } + try { + isVerified = true; + writer.flush(); + output.flush(); + String actual = ((ByteArrayOutputStream) output).toString("UTF-8").trim(); + String expected = getExpected().trim(); + LineDiffer.Diff lineDiff = LineDiffer.diffLines(expected, actual); + if (!lineDiff.isEmpty()) { + String actualFileLocation = tryCreateNewBaseline(actual); + throw new BaselineComparisonError( + testName.getMethodName(), baselineFileName(), actual, actualFileLocation, lineDiff); + } + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + /** Disables verification of the baseline for the given test case. */ + protected void skipBaselineVerification() { + isVerified = true; + } + + /** + * Creates a baseline file that will need to be used to make the current test pass. + * + *

If the test is failing for a valid reason (e.g. developer changed some output text), then + * this file provides a convenient way for the developer to overwrite the old baseline and keep + * the test passing. + * + *

The created file is stored under /tmp or location specified by the environment variable + * DIRECTORY_TO_COPY_NEW_BASELINE. Information where the file is stored is returned as a string. + */ + private String tryCreateNewBaseline(String actual) throws IOException { + File file = + new File( + File.separator + DIRECTORY_TO_COPY_NEW_BASELINE + File.separator + baselineFileName()); + Files.createParentDirs(file); + Files.asCharSink(file, Charset.defaultCharset()).write(actual); + return file.toString(); + } +} diff --git a/testing/src/main/java/dev/cel/testing/CelAdorner.java b/testing/src/main/java/dev/cel/testing/CelAdorner.java new file mode 100644 index 000000000..6bfd47fe1 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/CelAdorner.java @@ -0,0 +1,28 @@ +// Copyright 2022 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.testing; + +import dev.cel.expr.Expr.CreateStruct.EntryOrBuilder; +import dev.cel.expr.ExprOrBuilder; + +/** + * CelAdorner returns debug metadata that will be tacked on to the string representation of an + * expression. + */ +public interface CelAdorner { + String adorn(ExprOrBuilder expr); + + String adorn(EntryOrBuilder entry); +} diff --git a/testing/src/main/java/dev/cel/testing/CelBaselineTestCase.java b/testing/src/main/java/dev/cel/testing/CelBaselineTestCase.java new file mode 100644 index 000000000..8c79e5931 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/CelBaselineTestCase.java @@ -0,0 +1,218 @@ +// Copyright 2023 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.testing; + +import static com.google.common.truth.Truth.assertWithMessage; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.Descriptors.FileDescriptor; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelContainer; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelVarDecl; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypeProvider; +import dev.cel.common.types.CelTypes; +import dev.cel.common.types.ProtoMessageTypeProvider; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerBuilder; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.extensions.CelExtensions; +import dev.cel.parser.CelStandardMacro; +import java.util.ArrayList; +import java.util.List; + +/** + * Base class for CEL tests which generate a string output that can be stored and used as a baseline + * to ensure consistent behavior on future test runs. + */ +public abstract class CelBaselineTestCase extends BaselineTestCase { + private final List varDecls = new ArrayList<>(); + private final List functionDecls = new ArrayList<>(); + + protected String source; + protected CelContainer container = CelContainer.ofName(""); + protected CelType expectedType; + protected CelCompiler celCompiler; + + protected static final int COMPREHENSION_MAX_ITERATIONS = 1_000; + protected static final CelOptions TEST_OPTIONS = + CelOptions.current() + .enableHeterogeneousNumericComparisons(true) + .enableHiddenAccumulatorVar(true) + .enableOptionalSyntax(true) + .comprehensionMaxIterations(1_000) + .build(); + + protected CelBaselineTestCase() {} + + protected CelAbstractSyntaxTree prepareTest(List descriptors) { + return prepareTest(new ProtoMessageTypeProvider(ImmutableSet.copyOf(descriptors))); + } + + protected CelAbstractSyntaxTree prepareTest(FileDescriptorSet descriptorSet) { + return prepareTest(new ProtoMessageTypeProvider(descriptorSet)); + } + + protected CelAbstractSyntaxTree prepareTest(CelTypeProvider typeProvider) { + prepareCompiler(typeProvider); + + CelAbstractSyntaxTree ast; + try { + ast = celCompiler.parse(source, testSourceDescription()).getAst(); + } catch (CelValidationException e) { + printTestValidationError(e); + return null; + } + + try { + return celCompiler.check(ast).getAst(); + } catch (CelValidationException e) { + printTestValidationError(e); + return null; + } + } + + private void validateTestSetup() { + assertWithMessage("The source field must be non-null").that(source).isNotNull(); + } + + protected void prepareCompiler(CelTypeProvider typeProvider) { + validateTestSetup(); + printTestSetup(); + + CelCompilerBuilder celCompilerBuilder = + CelCompilerFactory.standardCelCompilerBuilder() + .setOptions(TEST_OPTIONS) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addLibraries(CelExtensions.comprehensions()) + .setContainer(container) + .setTypeProvider(typeProvider); + + if (expectedType != null) { + celCompilerBuilder.setResultType(expectedType); + } + + varDecls.forEach(celCompilerBuilder::addVarDeclarations); + functionDecls.forEach(celCompilerBuilder::addFunctionDeclarations); + + celCompiler = celCompilerBuilder.build(); + } + + /** + * Declares a variable with a given {@code name} and {@code type}. + * + * @param name Variable name + */ + protected void declareVariable(String name, CelType type) { + varDecls.add(CelVarDecl.newVarDeclaration(name, type)); + } + + /** Clears all function and variable declarations. */ + protected void clearAllDeclarations() { + functionDecls.clear(); + varDecls.clear(); + } + + /** Returns the test source description. */ + protected String testSourceDescription() { + return "test_location"; + } + + protected void printTestSetup() { + // Print the source. + testOutput().printf("Source: %s%n", source); + for (CelVarDecl varDecl : varDecls) { + testOutput().println(formatVarDecl(varDecl)); + } + for (CelFunctionDecl functionDecl : functionDecls) { + testOutput().println(formatFunctionDecl(functionDecl)); + } + + testOutput().println("=====>"); + } + + protected String formatFunctionDecl(CelFunctionDecl decl) { + StringBuilder declStr = new StringBuilder(); + declStr.append(String.format("declare %s {%n", decl.name())); + for (CelOverloadDecl overload : decl.overloads()) { + declStr.append( + String.format( + " function %s %s%n", + overload.overloadId(), + CelTypes.formatFunction( + overload.resultType(), + ImmutableList.copyOf(overload.parameterTypes()), + overload.isInstanceFunction(), + /* typeParamToDyn= */ false))); + } + declStr.append("}"); + return declStr.toString(); + } + + protected String formatVarDecl(CelVarDecl decl) { + StringBuilder declStr = new StringBuilder(); + declStr.append(String.format("declare %s {%n", decl.name())); + declStr.append(String.format(" value %s%n", CelTypes.format(decl.type()))); + declStr.append("}"); + return declStr.toString(); + } + + /** + * Declares a function with one or more overloads + * + * @param functionName Function name + * @param overloads Function overloads in protobuf representation. + */ + protected void declareFunction(String functionName, CelOverloadDecl... overloads) { + this.functionDecls.add(newFunctionDeclaration(functionName, overloads)); + } + + protected void declareGlobalFunction(String name, List paramTypes, CelType resultType) { + declareFunction(name, globalOverload(name, paramTypes, resultType)); + } + + protected void declareMemberFunction(String name, List paramTypes, CelType resultType) { + declareFunction(name, memberOverload(name, paramTypes, resultType)); + } + + protected CelOverloadDecl memberOverload( + String overloadId, List paramTypes, CelType resultType) { + return overloadBuilder(overloadId, paramTypes, resultType).setIsInstanceFunction(true).build(); + } + + protected CelOverloadDecl globalOverload( + String overloadId, List paramTypes, CelType resultType) { + return overloadBuilder(overloadId, paramTypes, resultType).setIsInstanceFunction(false).build(); + } + + private CelOverloadDecl.Builder overloadBuilder( + String overloadId, List paramTypes, CelType resultType) { + return CelOverloadDecl.newBuilder() + .setOverloadId(overloadId) + .setResultType(resultType) + .addParameterTypes(paramTypes); + } + + protected void printTestValidationError(CelValidationException error) { + testOutput().println(error.getMessage()); + } +} diff --git a/testing/src/main/java/dev/cel/testing/CelDebug.java b/testing/src/main/java/dev/cel/testing/CelDebug.java new file mode 100644 index 000000000..410eecb42 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/CelDebug.java @@ -0,0 +1,386 @@ +// Copyright 2022 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.testing; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; + +import dev.cel.expr.ConstantOrBuilder; +import dev.cel.expr.Expr; +import dev.cel.expr.Expr.CreateStruct.EntryOrBuilder; +import dev.cel.expr.ExprOrBuilder; +import java.util.PrimitiveIterator; + +/** + * Utility class providing tools to print a parsed expression graph and adorn each expression + * element with additional metadata. + */ +public final class CelDebug { + + private static final CelAdorner UNADORNER = + new CelAdorner() { + @Override + public String adorn(ExprOrBuilder expr) { + return ""; + } + + @Override + public String adorn(EntryOrBuilder entry) { + return ""; + } + }; + + /** Returns the unadorned string representation of {@link dev.cel.expr.ExprOrBuilder}. */ + public static String toDebugString(ExprOrBuilder expr) { + return toAdornedDebugString(expr, UNADORNER); + } + + /** Returns the adorned string representation of {@link dev.cel.expr.ExprOrBuilder}. */ + public static String toAdornedDebugString(ExprOrBuilder expr, CelAdorner adorner) { + CelDebug debug = new CelDebug(checkNotNull(adorner)); + debug.appendExpr(checkNotNull(expr)); + return debug.toString(); + } + + private final CelAdorner adorner; + private final StringBuilder buffer; + private int indent; + private boolean lineStart; + + private CelDebug(CelAdorner adorner) { + this.adorner = adorner; + buffer = new StringBuilder(); + indent = 0; + lineStart = false; + } + + private void appendExpr(ExprOrBuilder expr) { + switch (expr.getExprKindCase()) { + case CONST_EXPR: + appendConst(expr.getConstExpr()); + break; + case IDENT_EXPR: + append(expr.getIdentExpr().getName()); + break; + case SELECT_EXPR: + appendSelect(expr.getSelectExpr()); + break; + case CALL_EXPR: + appendCall(expr.getCallExpr()); + break; + case LIST_EXPR: + appendList(expr.getListExpr()); + break; + case STRUCT_EXPR: + appendStruct(expr.getStructExpr()); + break; + case COMPREHENSION_EXPR: + appendComprehension(expr.getComprehensionExpr()); + break; + default: + // A macro expression argument from macro calls will just be an ID and the kind is NOT_SET. + // To catch this the default must adorn instead of return; + break; + } + adorn(expr); + } + + private void appendSelect(Expr.SelectOrBuilder selectExpr) { + appendExpr(selectExpr.getOperand()); + append('.'); + append(selectExpr.getField()); + if (selectExpr.getTestOnly()) { + append("~test-only~"); + } + } + + private void appendCall(Expr.CallOrBuilder callExpr) { + if (callExpr.hasTarget()) { + appendExpr(callExpr.getTarget()); + append('.'); + } + append(callExpr.getFunction()); + append('('); + if (callExpr.getArgsCount() > 0) { + addIndent(); + appendLine(); + for (int index = 0; index < callExpr.getArgsCount(); index++) { + if (index > 0) { + append(','); + appendLine(); + } + appendExpr(callExpr.getArgs(index)); + } + removeIndent(); + appendLine(); + } + append(')'); + } + + private void appendList(Expr.CreateListOrBuilder listExpr) { + append('['); + if (listExpr.getElementsCount() > 0) { + appendLine(); + addIndent(); + for (int index = 0; index < listExpr.getElementsCount(); index++) { + if (index > 0) { + append(','); + appendLine(); + } + if (listExpr.getOptionalIndicesList().contains(index)) { + append("?"); + } + appendExpr(listExpr.getElements(index)); + } + removeIndent(); + appendLine(); + } + append(']'); + } + + private void appendStruct(Expr.CreateStructOrBuilder structExpr) { + if (structExpr.getMessageName().isEmpty()) { + appendMap(structExpr); + } else { + appendObject(structExpr); + } + } + + private void appendObject(Expr.CreateStructOrBuilder structExpr) { + append(structExpr.getMessageName()); + append('{'); + if (structExpr.getEntriesCount() > 0) { + appendLine(); + addIndent(); + for (int index = 0; index < structExpr.getEntriesCount(); index++) { + if (index > 0) { + append(','); + appendLine(); + } + if (structExpr.getEntries(index).getOptionalEntry()) { + append("?"); + } + append(structExpr.getEntries(index).getFieldKey()); + append(':'); + appendExpr(structExpr.getEntries(index).getValue()); + adorn(structExpr.getEntries(index)); + } + removeIndent(); + appendLine(); + } + append('}'); + } + + private void appendMap(Expr.CreateStructOrBuilder structExpr) { + append('{'); + if (structExpr.getEntriesCount() > 0) { + appendLine(); + addIndent(); + for (int index = 0; index < structExpr.getEntriesCount(); index++) { + if (index > 0) { + append(','); + appendLine(); + } + if (structExpr.getEntries(index).getOptionalEntry()) { + append("?"); + } + appendExpr(structExpr.getEntries(index).getMapKey()); + append(':'); + appendExpr(structExpr.getEntries(index).getValue()); + adorn(structExpr.getEntries(index)); + } + removeIndent(); + appendLine(); + } + append('}'); + } + + private void appendComprehension(Expr.ComprehensionOrBuilder comprehensionExpr) { + append("__comprehension__("); + addIndent(); + appendLine(); + append("// Variable"); + appendLine(); + append(comprehensionExpr.getIterVar()); + if (!comprehensionExpr.getIterVar2().isEmpty()) { + append(','); + appendLine(); + append(comprehensionExpr.getIterVar2()); + } + append(','); + appendLine(); + append("// Target"); + appendLine(); + appendExpr(comprehensionExpr.getIterRange()); + append(','); + appendLine(); + append("// Accumulator"); + appendLine(); + append(comprehensionExpr.getAccuVar()); + append(','); + appendLine(); + append("// Init"); + appendLine(); + appendExpr(comprehensionExpr.getAccuInit()); + append(','); + appendLine(); + append("// LoopCondition"); + appendLine(); + appendExpr(comprehensionExpr.getLoopCondition()); + append(','); + appendLine(); + append("// LoopStep"); + appendLine(); + appendExpr(comprehensionExpr.getLoopStep()); + append(','); + appendLine(); + append("// Result"); + appendLine(); + appendExpr(comprehensionExpr.getResult()); + append(')'); + removeIndent(); + } + + private void appendConst(ConstantOrBuilder constExpr) { + switch (constExpr.getConstantKindCase()) { + case BOOL_VALUE: + append(constExpr.getBoolValue() ? "true" : "false"); + break; + case BYTES_VALUE: + append(String.format("b\"%s\"", constExpr.getBytesValue().toStringUtf8())); + break; + case DOUBLE_VALUE: + { + String value = String.format("%f", constExpr.getDoubleValue()); + while (value.endsWith("0") && value.charAt(value.length() - 2) != '.') { + value = value.substring(0, value.length() - 1); + } + append(value); + } + break; + case INT64_VALUE: + append(Long.toString(constExpr.getInt64Value())); + break; + case STRING_VALUE: + { + append('"'); + PrimitiveIterator.OfInt iterator = constExpr.getStringValue().chars().iterator(); + while (iterator.hasNext()) { + char codeUnit = (char) iterator.nextInt(); + switch (codeUnit) { + case '\007': // \a + append('\\'); + append('a'); + break; + case '\b': + append('\\'); + append('b'); + break; + case '\f': + append('\\'); + append('f'); + break; + case '\n': + append('\\'); + append('n'); + break; + case '\r': + append('\\'); + append('r'); + break; + case '\t': + append('\\'); + append('t'); + break; + case '\013': // \v + append('\\'); + append('v'); + break; + case '"': + append('\\'); + append('"'); + break; + default: + append(codeUnit); + break; + } + } + append('"'); + } + break; + case UINT64_VALUE: + append(Long.toUnsignedString(constExpr.getUint64Value())); + append('u'); + break; + case NULL_VALUE: + append("null"); + break; + default: + throw new IllegalArgumentException("Unknown constant type"); + } + } + + @SuppressWarnings("ReturnValueIgnored") + private void append(char c) { + appendIndent(); + buffer.append(c); + } + + @SuppressWarnings("ReturnValueIgnored") + private void append(String string) { + appendIndent(); + buffer.append(string); + } + + @SuppressWarnings("ReturnValueIgnored") + private void appendLine() { + buffer.append('\n'); + lineStart = true; + } + + @SuppressWarnings("ReturnValueIgnored") + private void appendIndent() { + if (lineStart) { + buffer.ensureCapacity(buffer.length() + (indent * 2)); + for (int index = 0; index < indent; index++) { + buffer.append(" "); + } + lineStart = false; + } + } + + private void addIndent() { + checkState(indent >= 0); + indent++; + } + + private void removeIndent() { + checkState(indent > 0); + indent--; + } + + private void adorn(ExprOrBuilder expr) { + append(adorner.adorn(expr)); + } + + private void adorn(EntryOrBuilder entry) { + append(adorner.adorn(entry)); + } + + @Override + public String toString() { + return buffer.toString(); + } +} diff --git a/testing/src/main/java/dev/cel/testing/CelRuntimeFlavor.java b/testing/src/main/java/dev/cel/testing/CelRuntimeFlavor.java new file mode 100644 index 000000000..66ce8d802 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/CelRuntimeFlavor.java @@ -0,0 +1,37 @@ +// 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.testing; + +import dev.cel.bundle.CelBuilder; +import dev.cel.bundle.CelFactory; + +/** Enumeration of supported CEL runtime environments for testing. */ +public enum CelRuntimeFlavor { + LEGACY { + @Override + public CelBuilder builder() { + return CelFactory.standardCelBuilder(); + } + }, + PLANNER { + @Override + public CelBuilder builder() { + return CelFactory.plannerCelBuilder(); + } + }; + + /** Returns a new {@link CelBuilder} instance for this runtime flavor. */ + public abstract CelBuilder builder(); +} diff --git a/testing/src/main/java/dev/cel/testing/LineDiffer.java b/testing/src/main/java/dev/cel/testing/LineDiffer.java new file mode 100644 index 000000000..ef31ba52c --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/LineDiffer.java @@ -0,0 +1,260 @@ +// Copyright 2022 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.testing; + +import static java.lang.Math.max; + +import com.google.auto.value.AutoValue; +import com.google.common.base.Splitter; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Iterables; +import com.google.errorprone.annotations.CheckReturnValue; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +/** Utility for generating a set of differences between two text files. */ +@CheckReturnValue +public final class LineDiffer { + + static final Diff EMPTY_DIFF = Diff.of(ImmutableList.of(), ImmutableList.of()); + private static final Splitter LINE_SPLITTER = Splitter.on('\n'); + + public static Diff diffLines(String firstText, String secondText) { + if (firstText.equals(secondText)) { + return EMPTY_DIFF; + } + + List firstLines = LINE_SPLITTER.splitToList(firstText); + List secondLines = LINE_SPLITTER.splitToList(secondText); + int firstLinesCount = firstLines.size(); + int secondLinesCount = secondLines.size(); + if (firstText.isEmpty()) { + return Diff.of( + ImmutableList.of(Snippet.of(1, secondLinesCount, secondLines)), ImmutableList.of()); + } + if (secondText.isEmpty()) { + return Diff.of( + ImmutableList.of(), ImmutableList.of(Snippet.of(1, firstLinesCount, firstLines))); + } + + // Compute a matrix of equivalent lines (ignoring spaces) into a matrix representing the longest + // common subsequences present in the input text. This method is O(n^2) and more efficient + // techniques exist, but the texts being compared are quite small so the performance should + // suffice. + int[][] longestCommonSubsequence = new int[firstLinesCount + 1][secondLinesCount + 1]; + for (int firstLine = 1; firstLine < firstLinesCount + 1; firstLine++) { + for (int secondLine = 1; secondLine < secondLinesCount + 1; secondLine++) { + if (equalsHashIgnoreSpaces( + firstLines.get(firstLine - 1), secondLines.get(secondLine - 1))) { + // Increments the common subsequence length. + longestCommonSubsequence[firstLine][secondLine] = + 1 + longestCommonSubsequence[firstLine - 1][secondLine - 1]; + } else { + // Records the longest common subsequence from either the first or second text. + longestCommonSubsequence[firstLine][secondLine] = + max( + longestCommonSubsequence[firstLine - 1][secondLine], + longestCommonSubsequence[firstLine][secondLine - 1]); + } + } + } + + int firstLine = firstLinesCount; + int secondLine = secondLinesCount; + ArrayList removals = new ArrayList<>(); + ArrayList additions = new ArrayList<>(); + while (firstLine != 0 || secondLine != 0) { + // This is an addition case where the second text contains more lines than the first. + if (firstLine == 0) { + if (!secondLines.isEmpty()) { + Snippet addition = Snippet.of(secondLine, secondLines.get(secondLine - 1)); + appendOrJoin(additions, addition); + } + secondLine--; + continue; + } + // This is a removal case where the second text contains fewer lines than the first. + if (secondLine == 0) { + if (!firstLines.isEmpty()) { + Snippet removal = Snippet.of(firstLine, firstLines.get(firstLine - 1)); + appendOrJoin(removals, removal); + } + firstLine--; + continue; + } + // The lines of text are equal and thus can be omitted from the results. + if (equalsIgnoreSpaces(firstLines.get(firstLine - 1), secondLines.get(secondLine - 1))) { + firstLine--; + secondLine--; + continue; + } + + // Follow the direction of the longest common subsequence. + int cmp = + Integer.compare( + longestCommonSubsequence[firstLine - 1][secondLine], + longestCommonSubsequence[firstLine][secondLine - 1]); + if (cmp <= 0) { + Snippet addition = Snippet.of(secondLine, secondLines.get(secondLine - 1)); + appendOrJoin(additions, addition); + secondLine--; + } else { + Snippet removal = Snippet.of(firstLine, firstLines.get(firstLine - 1)); + appendOrJoin(removals, removal); + firstLine--; + } + } + return Diff.of( + ImmutableList.copyOf(additions).reverse(), ImmutableList.copyOf(removals).reverse()); + } + + private static void appendOrJoin(ArrayList snippets, Snippet snippet) { + if (snippets.isEmpty()) { + snippets.add(snippet); + return; + } + + Snippet prev = Iterables.getLast(snippets); + if (snippet.isContiguous(prev)) { + snippets.set(snippets.size() - 1, snippet.join(prev)); + } else { + snippets.add(snippet); + } + } + + private static boolean equalsHashIgnoreSpaces(String first, String second) { + return first.trim().hashCode() == second.trim().hashCode(); + } + + private static boolean equalsIgnoreSpaces(String first, String second) { + return first.trim().equals(second.trim()); + } + + /** + * Snippet of text which includes the starting and ending lines where the snippet occurs in to the + * lines of text. + */ + @AutoValue + public abstract static class Snippet { + public abstract int startLine(); + + public abstract int endLine(); + + public abstract ImmutableList textLines(); + + boolean isContiguous(Snippet snippet) { + return endLine() + 1 == snippet.startLine(); + } + + boolean intersects(Snippet snippet) { + return (startLine() <= snippet.startLine() && snippet.startLine() <= endLine()) + || (startLine() <= snippet.endLine() && snippet.endLine() <= endLine()); + } + + Snippet join(Snippet snippet) { + return Snippet.of( + startLine(), + snippet.endLine(), + ImmutableList.builder().addAll(textLines()).addAll(snippet.textLines()).build()); + } + + String render(String direction) { + StringBuilder snippetString = new StringBuilder(); + for (String line : textLines()) { + snippetString.append(String.format("%s %s%n", direction, line)); + } + return snippetString.toString(); + } + + static Snippet of(int line, String text) { + return Snippet.of(line, line, ImmutableList.of(text)); + } + + static Snippet of(int startLine, int endLine, Collection textLines) { + return Snippet.of(startLine, endLine, ImmutableList.copyOf(textLines)); + } + + static Snippet of(int startLine, int endLine, ImmutableList textLines) { + return new AutoValue_LineDiffer_Snippet(startLine, endLine, textLines); + } + } + + /** + * Diff holds a collection of additions and removals representing the differing lines between two + * strings. + */ + @AutoValue + public abstract static class Diff { + + public abstract ImmutableList additions(); + + public abstract ImmutableList removals(); + + public boolean isEmpty() { + return additions().isEmpty() && removals().isEmpty(); + } + + static Diff of(ImmutableList additions, ImmutableList removals) { + return new AutoValue_LineDiffer_Diff(additions, removals); + } + + @Override + public final String toString() { + int removeIndex = 0; + StringBuilder diffString = new StringBuilder(); + for (int i = 0; i < additions().size(); i++) { + Snippet addition = additions().get(i); + Snippet removal = maybeNextSnippet(removals(), removeIndex); + if (removal == null) { + diffString.append(snippetHeader(addition)).append(addition.render(">")); + continue; + } + while (removal != null + && removal.startLine() < addition.startLine() + && !addition.intersects(removal)) { + diffString.append(snippetHeader(removal)).append(removal.render("<")); + removal = maybeNextSnippet(removals(), ++removeIndex); + } + if (removal != null && addition.intersects(removal)) { + diffString + .append(snippetHeader(addition)) + .append(addition.render(">")) + .append(removal.render("<")); + removeIndex++; + } else { + diffString.append(snippetHeader(addition)).append(addition.render(">")); + } + } + for (int i = removeIndex; i < removals().size(); i++) { + Snippet removal = removals().get(i); + diffString.append(snippetHeader(removal)).append(removal.render("<")); + } + return diffString.toString(); + } + + private static String snippetHeader(Snippet snippet) { + return snippet.startLine() == snippet.endLine() + ? String.format("===== Line %d =====\n", snippet.startLine()) + : String.format("===== Lines %d-%d =====\n", snippet.startLine(), snippet.endLine()); + } + + private static Snippet maybeNextSnippet(ImmutableList snippets, int index) { + return index < snippets.size() ? snippets.get(index) : null; + } + } + + private LineDiffer() {} +} diff --git a/testing/src/main/java/dev/cel/testing/compiled/BUILD.bazel b/testing/src/main/java/dev/cel/testing/compiled/BUILD.bazel new file mode 100644 index 000000000..5ef4d8878 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/compiled/BUILD.bazel @@ -0,0 +1,232 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:cel_android_rules.bzl", "cel_android_library") +load("//compiler/tools:compile_cel.bzl", "compile_cel") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//testing/compiled:__pkg__"], +) + +java_library( + name = "compiled_expr_utils", + srcs = ["CompiledExprUtils.java"], + tags = [ + ], + deps = [ + ":compiled_expr_resources", # unuseddeps: keep + "//common:cel_ast", + "//common:proto_ast", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +cel_android_library( + name = "compiled_expr_utils_android", + srcs = ["CompiledExprUtils.java"], + tags = [ + ], + deps = [ + ":compiled_expr_resources", # unuseddeps: keep + "//common:cel_ast_android", + "//common:proto_ast_android", + "@cel_spec//proto/cel/expr:checked_java_proto_lite", + "@maven_android//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "compiled_expr_resources", + # used_by_android + resources = [ + ":compiled_comprehension", + ":compiled_comprehension_exists", + ":compiled_custom_functions", + ":compiled_extended_env", + ":compiled_extensions", + ":compiled_hello_world", + ":compiled_list_literal", + ":compiled_one_plus_two", + ":compiled_primitive_variables", + ":compiled_proto2_deep_traversal", + ":compiled_proto2_select_map_fields", + ":compiled_proto2_select_primitives", + ":compiled_proto2_select_primitives_all_ored", + ":compiled_proto2_select_repeated_fields", + ":compiled_proto2_select_wrappers", + ":compiled_proto3_deep_traversal", + ":compiled_proto3_select_map_fields", + ":compiled_proto3_select_primitives", + ":compiled_proto3_select_primitives_all_ored", + ":compiled_proto3_select_repeated_fields", + ":compiled_proto3_select_wrappers", + ":compiled_proto_message", + ], +) + +compile_cel( + name = "compiled_hello_world", + expression = "'hello world'", +) + +compile_cel( + name = "compiled_one_plus_two", + expression = "1 + 2", +) + +compile_cel( + name = "compiled_list_literal", + expression = "['a', 1, 2u, 3.5]", +) + +compile_cel( + name = "compiled_comprehension", + expression = "[1,2,3].map(x, x + 1)", +) + +compile_cel( + name = "compiled_comprehension_exists", + expression = "[1,2,3].exists(x, x == 3)", +) + +compile_cel( + name = "compiled_proto_message", + expression = "cel.expr.conformance.proto3.TestAllTypes{single_int32: 1}", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) + +compile_cel( + name = "compiled_extensions", + environment = "//testing/environment:all_extensions", + expression = "cel.bind(x, 10, math.greatest([1,x])) < int(' 11 '.trim()) && optional.none().orValue(true) && [].flatten() == []", +) + +compile_cel( + name = "compiled_extended_env", + environment = "//testing/environment:extended_env", + expression = "msg.single_string_wrapper.isEmpty() == false", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) + +compile_cel( + name = "compiled_primitive_variables", + environment = "//testing/environment:primitive_variables", + expression = "bool_var && bytes_var == b'abc' && double_var == 1.0 && int_var == 42 && uint_var == 42u && str_var == 'foo'", +) + +compile_cel( + name = "compiled_custom_functions", + environment = "//testing/environment:custom_functions", + expression = "''.isEmpty() && [].isEmpty()", +) + +compile_cel( + name = "compiled_proto2_select_primitives_all_ored", + environment = "//testing/environment:proto2_message_variables", + expression = "proto2.single_int32 == 1 || proto2.single_int64 == 2 || proto2.single_uint32 == 3u || proto2.single_uint64 == 4u ||" + + "proto2.single_sint32 == 5 || proto2.single_sint64 == 6 || proto2.single_fixed32 == 7u || proto2.single_fixed64 == 8u ||" + + "proto2.single_sfixed32 == 9 || proto2.single_sfixed64 == 10 || proto2.single_float == 1.5 || proto2.single_double == 2.5 ||" + + "proto2.single_bool || proto2.single_string == 'hello world' || proto2.single_bytes == b\'abc\'", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto2_select_primitives", + environment = "//testing/environment:proto2_message_variables", + expression = "proto2.single_int32 == 1 && proto2.single_int64 == 2 && proto2.single_uint32 == 3u && proto2.single_uint64 == 4u &&" + + "proto2.single_sint32 == 5 && proto2.single_sint64 == 6 && proto2.single_fixed32 == 7u && proto2.single_fixed64 == 8u &&" + + "proto2.single_sfixed32 == 9 && proto2.single_sfixed64 == 10 && proto2.single_float == 1.5 && proto2.single_double == 2.5 &&" + + "proto2.single_bool && proto2.single_string == 'hello world' && proto2.single_bytes == b\'abc\'", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto2_select_wrappers", + environment = "//testing/environment:proto2_message_variables", + expression = "proto2.single_int32_wrapper == 1 && proto2.single_int64_wrapper == 2 && proto2.single_float_wrapper == 1.5 &&" + + "proto2.single_double_wrapper == 2.5 && proto2.single_uint32_wrapper == 3u && proto2.single_uint64_wrapper == 4u &&" + + "proto2.single_string_wrapper == 'hello world' && proto2.single_bool_wrapper && proto2.single_bytes_wrapper == b\'abc\'", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto3_select_primitives_all_ored", + environment = "//testing/environment:proto3_message_variables", + expression = "proto3.single_int32 == 1 || proto3.single_int64 == 2 || proto3.single_uint32 == 3u || proto3.single_uint64 == 4u ||" + + "proto3.single_sint32 == 5 || proto3.single_sint64 == 6 || proto3.single_fixed32 == 7u || proto3.single_fixed64 == 8u ||" + + "proto3.single_sfixed32 == 9 || proto3.single_sfixed64 == 10 || proto3.single_float == 1.5 || proto3.single_double == 2.5 ||" + + "proto3.single_bool || proto3.single_string == 'hello world' || proto3.single_bytes == b\'abc\'", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto3_select_primitives", + environment = "//testing/environment:proto3_message_variables", + expression = "proto3.single_int32 == 1 && proto3.single_int64 == 2 && proto3.single_uint32 == 3u && proto3.single_uint64 == 4u &&" + + "proto3.single_sint32 == 5 && proto3.single_sint64 == 6 && proto3.single_fixed32 == 7u && proto3.single_fixed64 == 8u &&" + + "proto3.single_sfixed32 == 9 && proto3.single_sfixed64 == 10 && proto3.single_float == 1.5 && proto3.single_double == 2.5 &&" + + "proto3.single_bool && proto3.single_string == 'hello world' && proto3.single_bytes == b\'abc\'", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto3_select_wrappers", + environment = "//testing/environment:proto3_message_variables", + expression = "proto3.single_int32_wrapper == 1 && proto3.single_int64_wrapper == 2 && proto3.single_float_wrapper == 1.5 &&" + + "proto3.single_double_wrapper == 2.5 && proto3.single_uint32_wrapper == 3u && proto3.single_uint64_wrapper == 4u &&" + + "proto3.single_string_wrapper == 'hello world' && proto3.single_bool_wrapper && proto3.single_bytes_wrapper == b\'abc\'", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto2_deep_traversal", + environment = "//testing/environment:proto2_message_variables", + expression = "proto2.oneof_type.payload.repeated_string", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto3_deep_traversal", + environment = "//testing/environment:proto3_message_variables", + expression = "proto3.oneof_type.payload.repeated_string", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto2_select_repeated_fields", + environment = "//testing/environment:proto2_message_variables", + expression = "[proto2.repeated_int32, proto2.repeated_int64, proto2.repeated_uint32, proto2.repeated_uint64, proto2.repeated_sint32, proto2.repeated_sint64, " + + "proto2.repeated_fixed32, proto2.repeated_fixed64, proto2.repeated_sfixed32, proto2.repeated_sfixed64, proto2.repeated_float, proto2.repeated_double, " + + "proto2.repeated_bool, proto2.repeated_string, proto2.repeated_bytes]", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto3_select_repeated_fields", + environment = "//testing/environment:proto3_message_variables", + expression = "[proto3.repeated_int32, proto3.repeated_int64, proto3.repeated_uint32, proto3.repeated_uint64, proto3.repeated_sint32, proto3.repeated_sint64, " + + "proto3.repeated_fixed32, proto3.repeated_fixed64, proto3.repeated_sfixed32, proto3.repeated_sfixed64, proto3.repeated_float, proto3.repeated_double, " + + "proto3.repeated_bool, proto3.repeated_string, proto3.repeated_bytes]", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto2_select_map_fields", + environment = "//testing/environment:proto2_message_variables", + expression = "[proto2.map_bool_bool, proto2.map_bool_string, proto2.map_bool_bytes, proto2.map_bool_int32, proto2.map_bool_int64, " + + "proto2.map_bool_uint32, proto2.map_bool_uint64, proto2.map_bool_float, proto2.map_bool_double, proto2.map_bool_enum, " + + "proto2.map_bool_duration, proto2.map_bool_timestamp]", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto"], +) + +compile_cel( + name = "compiled_proto3_select_map_fields", + environment = "//testing/environment:proto3_message_variables", + expression = "[proto3.map_bool_bool, proto3.map_bool_string, proto3.map_bool_bytes, proto3.map_bool_int32, proto3.map_bool_int64, " + + "proto3.map_bool_uint32, proto3.map_bool_uint64, proto3.map_bool_float, proto3.map_bool_double, proto3.map_bool_enum, " + + "proto3.map_bool_duration, proto3.map_bool_timestamp]", + proto_srcs = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) diff --git a/testing/src/main/java/dev/cel/testing/compiled/CompiledExprUtils.java b/testing/src/main/java/dev/cel/testing/compiled/CompiledExprUtils.java new file mode 100644 index 000000000..692170c13 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/compiled/CompiledExprUtils.java @@ -0,0 +1,45 @@ +// Copyright 2025 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.testing.compiled; + +import dev.cel.expr.CheckedExpr; +import com.google.common.io.Resources; +import com.google.protobuf.ExtensionRegistryLite; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import java.io.IOException; +import java.net.URL; + +/** + * CompiledExprUtils handles reading a CheckedExpr stored in a .binarypb format from the JAR's + * resources. + */ +public final class CompiledExprUtils { + + /** + * Reads a CheckedExpr stored in the running JAR's resources, then returns an adapted {@link + * CelAbstractSyntaxTree}. + */ + public static CelAbstractSyntaxTree readCheckedExpr(String compiledCelTarget) throws IOException { + String resourcePath = String.format("%s.binarypb", compiledCelTarget); + URL url = Resources.getResource(CompiledExprUtils.class, resourcePath); + byte[] checkedExprBytes = Resources.toByteArray(url); + CheckedExpr checkedExpr = + CheckedExpr.parseFrom(checkedExprBytes, ExtensionRegistryLite.getEmptyRegistry()); + return CelProtoAbstractSyntaxTree.fromCheckedExpr(checkedExpr).getAst(); + } + + private CompiledExprUtils() {} +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/Annotations.java b/testing/src/main/java/dev/cel/testing/testrunner/Annotations.java new file mode 100644 index 000000000..056fd424f --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/Annotations.java @@ -0,0 +1,37 @@ +// Copyright 2025 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.testing.testrunner; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** These annotations are intended only for CEL Test Runner code. */ +public final class Annotations { + + /** + * Annotates a method which is a test runner test suite supplier. + * + *

This annotation is used to identify the method that is responsible for declaring the test + * cases. + */ + @Retention(RetentionPolicy.RUNTIME) + @Target({ElementType.METHOD}) + @Documented + public @interface TestSuiteSupplier {} + + private Annotations() {} +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/BUILD.bazel b/testing/src/main/java/dev/cel/testing/testrunner/BUILD.bazel new file mode 100644 index 000000000..677884a8a --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/BUILD.bazel @@ -0,0 +1,266 @@ +load("@rules_java//java:java_library.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = [ + "//testing/testrunner:__pkg__", + ], +) + +java_library( + name = "test_executor", + srcs = ["TestExecutor.java"], + tags = [ + ], + deps = [ + ":annotations", + ":cel_coverage_index", + ":cel_test_suite", + ":cel_test_suite_exception", + ":cel_test_suite_text_proto_parser", + ":cel_test_suite_yaml_parser", + ":cel_user_test_template", + ":junit_xml_reporter", + "//testing/testrunner:class_loader_utils", + "@maven//:com_google_guava_guava", + "@maven//:io_github_classgraph_classgraph", + "@maven//:junit_junit", + ], +) + +java_library( + name = "junit_xml_reporter", + srcs = ["JUnitXmlReporter.java"], + tags = [ + ], + deps = [ + ":cel_coverage_index", + "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "cel_user_test_template", + srcs = ["CelUserTestTemplate.java"], + tags = [ + ], + deps = [ + ":cel_coverage_index", + ":cel_expression_source", + ":cel_test_context", + ":cel_test_suite", + ":test_runner_library", + "@maven//:junit_junit", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "cel_coverage_index", + srcs = ["CelCoverageIndex.java"], + tags = [ + ], + deps = [ + "//:auto_value", + "//common:cel_ast", + "//common/ast", + "//common/navigation", + "//common/types:type_providers", + "//parser:unparser_visitor", + "//runtime:evaluation_listener", + "@maven//:com_google_code_findbugs_annotations", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "test_runner_library", + srcs = ["TestRunnerLibrary.java"], + tags = [ + ], + deps = [ + ":cel_coverage_index", + ":cel_expression_source", + ":cel_test_context", + ":cel_test_suite", + ":registry_utils", + ":result_matcher", + "//bundle:cel", + "//bundle:environment", + "//bundle:environment_yaml_parser", + "//common:cel_ast", + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "//common:compiler_common", + "//common:options", + "//common:proto_ast", + "//policy", + "//policy:compiler_factory", + "//policy:parser", + "//policy:parser_factory", + "//policy:validation_exception", + "//runtime", + "//testing:expr_value_utils", + "@cel_spec//proto/cel/expr:expr_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "cel_test_suite", + srcs = ["CelTestSuite.java"], + tags = [ + ], + deps = [ + "//:auto_value", + "//common:source", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "cel_test_suite_yaml_parser", + srcs = ["CelTestSuiteYamlParser.java"], + tags = [ + ], + deps = [ + ":cel_test_suite", + ":cel_test_suite_exception", + "//common:compiler_common", + "//common/annotations", + "//common/formats:file_source", + "//common/formats:parser_context", + "//common/formats:yaml_helper", + "//common/formats:yaml_parser_context_impl", + "//common/internal", + "@maven//:com_google_guava_guava", + "@maven//:org_yaml_snakeyaml", + ], +) + +java_library( + name = "cel_test_suite_exception", + srcs = ["CelTestSuiteException.java"], + tags = [ + ], + deps = ["//common:cel_exception"], +) + +java_library( + name = "cel_test_context", + srcs = ["CelTestContext.java"], + tags = [ + ], + deps = [ + ":cel_expression_source", + ":default_result_matcher", + ":registry_utils", + ":result_matcher", + "//:auto_value", + "//bundle:cel", + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "//common:options", + "//policy:parser", + "//runtime", + "//testing:proto_descriptor_utils", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "registry_utils", + srcs = ["RegistryUtils.java"], + tags = [ + ], + deps = [ + "//common:cel_descriptors", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "result_matcher", + srcs = ["ResultMatcher.java"], + deps = [ + ":cel_test_suite", + "//:auto_value", + "//bundle:cel", + "//common/types:type_providers", + "//runtime", + "@cel_spec//proto/cel/expr:expr_java_proto", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "default_result_matcher", + srcs = ["DefaultResultMatcher.java"], + deps = [ + ":cel_test_suite", + ":registry_utils", + ":result_matcher", + "//:java_truth", + "//bundle:cel", + "//common:cel_ast", + "//common:cel_descriptors", + "//runtime", + "//testing:expr_value_utils", + "//testing:proto_descriptor_utils", + "@cel_spec//proto/cel/expr:expr_java_proto", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_truth_extensions_truth_proto_extension", + ], +) + +java_library( + name = "cel_test_suite_text_proto_parser", + srcs = ["CelTestSuiteTextProtoParser.java"], + tags = [ + ], + deps = [ + ":cel_test_suite", + ":cel_test_suite_exception", + ":registry_utils", + "//common:cel_descriptors", + "//common/annotations", + "//testing:proto_descriptor_utils", + "@cel_spec//proto/cel/expr:expr_java_proto", + "@cel_spec//proto/cel/expr/conformance/test:suite_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) + +java_library( + name = "annotations", + srcs = ["Annotations.java"], + tags = [ + ], +) + +java_library( + name = "cel_expression_source", + srcs = ["CelExpressionSource.java"], + tags = [ + ], + deps = [ + "//:auto_value", + ], +) + +filegroup( + name = "test_runner_binary", + srcs = [ + "TestRunnerBinary.java", + ], +) diff --git a/testing/src/main/java/dev/cel/testing/testrunner/CelCoverageIndex.java b/testing/src/main/java/dev/cel/testing/testrunner/CelCoverageIndex.java new file mode 100644 index 000000000..d99525934 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/CelCoverageIndex.java @@ -0,0 +1,429 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static java.nio.charset.StandardCharsets.UTF_8; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.io.Files; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import javax.annotation.concurrent.ThreadSafe; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.ExprKind; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.common.navigation.CelNavigableExpr; +import dev.cel.common.types.CelKind; +import dev.cel.parser.CelUnparserVisitor; +import dev.cel.runtime.CelEvaluationListener; +import java.io.File; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.net.URLEncoder; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicBoolean; + +import java.util.logging.Logger; + +/** + * A class for managing the coverage index for CEL tests. + * + *

This class is used to manage the coverage index for CEL tests. It provides a method for + * getting the coverage index for a given test case. + */ +final class CelCoverageIndex { + + private static final Logger logger = Logger.getLogger(CelCoverageIndex.class.getName()); + + private static final String DIGRAPH_HEADER = "digraph {\n"; + private static final String UNCOVERED_NODE_STYLE = "color=\"indianred2\", style=filled"; + private static final String PARTIALLY_COVERED_NODE_STYLE = "color=\"lightyellow\"," + + "style=filled"; + private static final String COMPLETELY_COVERED_NODE_STYLE = "color=\"lightgreen\"," + + "style=filled"; + + private CelAbstractSyntaxTree ast; + private final ConcurrentHashMap nodeCoverageStatsMap = + new ConcurrentHashMap<>(); + + public void init(CelAbstractSyntaxTree ast) { + // If the AST and node coverage stats map are already initialized, then we don't need to + // re-initialize them. + if (this.ast == null && nodeCoverageStatsMap.isEmpty()) { + this.ast = ast; + CelNavigableExpr.fromExpr(ast.getExpr()) + .allNodes() + .forEach( + celNavigableExpr -> { + NodeCoverageStats nodeCoverageStats = new NodeCoverageStats(); + nodeCoverageStats.isBooleanNode.set(isNodeTypeBoolean(celNavigableExpr.expr())); + nodeCoverageStatsMap.put(celNavigableExpr.id(), nodeCoverageStats); + }); + } + } + + /** + * Returns the evaluation listener for the CEL test suite. + * + *

This listener is used to track the coverage of the CEL test suite. + */ + public CelEvaluationListener newEvaluationListener() { + return new EvaluationListener(nodeCoverageStatsMap); + } + + /** A class for managing the coverage report for a CEL test suite. */ + @AutoValue + public abstract static class CoverageReport { + public abstract String celExpression(); + + public abstract long nodes(); + + public abstract long coveredNodes(); + + public abstract long branches(); + + public abstract long coveredBooleanOutcomes(); + + public abstract ImmutableList unencounteredNodes(); + + public abstract ImmutableList unencounteredBranches(); + + public abstract String dotGraph(); + + // Currently only supported inside google3. + public abstract String graphUrl(); + + public static Builder builder() { + return new AutoValue_CelCoverageIndex_CoverageReport.Builder() + .setNodes(0L) + .setCoveredNodes(0L) + .setBranches(0L) + .setCelExpression("") + .setDotGraph("") + .setGraphUrl("") + .setCoveredBooleanOutcomes(0L); + } + + /** Builder for {@link CoverageReport}. */ + @AutoValue.Builder + public abstract static class Builder { + public abstract Builder setCelExpression(String value); + + public abstract long nodes(); + + public abstract Builder setNodes(long value); + + public abstract long coveredNodes(); + + public abstract Builder setCoveredNodes(long value); + + public abstract long branches(); + + public abstract Builder setBranches(long value); + + public abstract long coveredBooleanOutcomes(); + + public abstract Builder setCoveredBooleanOutcomes(long value); + + public abstract Builder setDotGraph(String value); + + public abstract Builder setGraphUrl(String value); + + public abstract ImmutableList.Builder unencounteredNodesBuilder(); + + public abstract ImmutableList.Builder unencounteredBranchesBuilder(); + + @CanIgnoreReturnValue + public final Builder addUnencounteredNodes(String value) { + unencounteredNodesBuilder().add(value); + return this; + } + + @CanIgnoreReturnValue + public final Builder addUnencounteredBranches(String value) { + unencounteredBranchesBuilder().add(value); + return this; + } + + public abstract CoverageReport build(); + } + } + + /** + * Generates a coverage report for the CEL test suite. + * + *

Note: If the generated graph URL results in a `Request Entity Too Large` error, download the + * `coverage_graph.txt` file from the test artifacts and upload its contents to Graphviz to render the coverage graph. + */ + public CoverageReport generateCoverageReport() { + CoverageReport.Builder reportBuilder = + CoverageReport.builder().setCelExpression(new CelUnparserVisitor(ast).unparse()); + StringBuilder dotGraphBuilder = new StringBuilder(DIGRAPH_HEADER); + traverseAndCalculateCoverage( + CelNavigableAst.fromAst(ast).getRoot(), + nodeCoverageStatsMap, + true, + "", + reportBuilder, + dotGraphBuilder); + dotGraphBuilder.append("}"); + String dotGraph = dotGraphBuilder.toString(); + + CoverageReport report = reportBuilder.setDotGraph(dotGraph).build(); + logger.info("CEL Expression: " + report.celExpression()); + logger.info("Nodes: " + report.nodes()); + logger.info("Covered Nodes: " + report.coveredNodes()); + logger.info("Branches: " + report.branches()); + logger.info("Covered Boolean Outcomes: " + report.coveredBooleanOutcomes()); + logger.info("Unencountered Nodes: \n" + String.join("\n", report.unencounteredNodes())); + logger.info("Unencountered Branches: \n" + String.join("\n", + report.unencounteredBranches())); + logger.info("Dot Graph: " + report.dotGraph()); + + writeDotGraphToArtifact(dotGraph); + return report; + } + + /** A class for managing the coverage stats for a CEL node. */ + @ThreadSafe + private static final class NodeCoverageStats { + final AtomicBoolean isBooleanNode = new AtomicBoolean(false); + final AtomicBoolean covered = new AtomicBoolean(false); + final AtomicBoolean hasTrueBranch = new AtomicBoolean(false); + final AtomicBoolean hasFalseBranch = new AtomicBoolean(false); + } + + private Boolean isNodeTypeBoolean(CelExpr celExpr) { + return ast.getTypeMap().containsKey(celExpr.id()) + && ast.getTypeMap().get(celExpr.id()).kind().equals(CelKind.BOOL); + } + + private void traverseAndCalculateCoverage( + CelNavigableExpr node, + Map statsMap, + boolean logUnencountered, + String precedingTabs, + CoverageReport.Builder reportBuilder, + StringBuilder dotGraphBuilder) { + long nodeId = node.id(); + NodeCoverageStats stats = statsMap.getOrDefault(nodeId, new NodeCoverageStats()); + reportBuilder.setNodes(reportBuilder.nodes() + 1); + + boolean isInterestingBooleanNode = isInterestingBooleanNode(node, stats); + + String exprText = new CelUnparserVisitor(ast).unparse(node.expr()); + String nodeCoverageStyle = UNCOVERED_NODE_STYLE; + if (stats.covered.get()) { + if (isInterestingBooleanNode) { + if (stats.hasTrueBranch.get() && stats.hasFalseBranch.get()) { + nodeCoverageStyle = COMPLETELY_COVERED_NODE_STYLE; + } else { + nodeCoverageStyle = PARTIALLY_COVERED_NODE_STYLE; + } + } else { + nodeCoverageStyle = COMPLETELY_COVERED_NODE_STYLE; + } + } + String escapedExprText = escapeSpecialCharacters(exprText); + dotGraphBuilder.append( + String.format( + "%d [shape=record, %s, label=\"{<1> exprID: %d | <2> %s} | <3> %s\"];\n", + nodeId, nodeCoverageStyle, nodeId, kindToString(node), escapedExprText)); + + // Update coverage for the current node and determine if we should continue logging + // unencountered. + logUnencountered = + updateNodeCoverage( + nodeId, stats, isInterestingBooleanNode, exprText, logUnencountered, reportBuilder); + + if (isInterestingBooleanNode) { + precedingTabs = + updateBooleanBranchCoverage( + nodeId, stats, exprText, precedingTabs, logUnencountered, reportBuilder); + } + + for (CelNavigableExpr child : node.children().collect(toImmutableList())) { + dotGraphBuilder.append(String.format("%d -> %d;\n", nodeId, child.id())); + traverseAndCalculateCoverage( + child, statsMap, logUnencountered, precedingTabs, reportBuilder, dotGraphBuilder); + } + } + + private boolean isInterestingBooleanNode(CelNavigableExpr node, NodeCoverageStats stats) { + return stats.isBooleanNode.get() + && !node.expr().getKind().equals(ExprKind.Kind.CONSTANT) + && !(node.expr().getKind().equals(ExprKind.Kind.CALL) + && node.expr().call().function().equals("cel.@block")); + } + + /** + * Updates the coverage report based on whether the current node was covered. Returns true if + * logging of unencountered nodes should continue for children, false otherwise. + */ + private boolean updateNodeCoverage( + long nodeId, + NodeCoverageStats stats, + boolean isInterestingBooleanNode, + String exprText, + boolean logUnencountered, + CoverageReport.Builder reportBuilder) { + if (stats.covered.get()) { + reportBuilder.setCoveredNodes(reportBuilder.coveredNodes() + 1); + } else { + if (logUnencountered) { + if (isInterestingBooleanNode) { + reportBuilder.addUnencounteredNodes( + String.format("Expression ID %d ('%s')", nodeId, exprText)); + } + // Once an unencountered node is found, we don't log further unencountered nodes in its + // subtree to avoid noise. + return false; + } + } + return logUnencountered; + } + + /** + * Updates the coverage report for boolean nodes, including branch coverage. Returns the + * potentially modified `precedingTabs` string. + */ + private String updateBooleanBranchCoverage( + long nodeId, + NodeCoverageStats stats, + String exprText, + String precedingTabs, + boolean logUnencountered, + CoverageReport.Builder reportBuilder) { + reportBuilder.setBranches(reportBuilder.branches() + 2); + if (stats.hasTrueBranch.get()) { + reportBuilder.setCoveredBooleanOutcomes(reportBuilder.coveredBooleanOutcomes() + 1); + } else if (logUnencountered) { + reportBuilder.addUnencounteredBranches( + String.format( + "%sExpression ID %d ('%s'): lacks 'true' coverage", precedingTabs, nodeId, exprText)); + precedingTabs += "\t\t"; + } + if (stats.hasFalseBranch.get()) { + reportBuilder.setCoveredBooleanOutcomes(reportBuilder.coveredBooleanOutcomes() + 1); + } else if (logUnencountered) { + reportBuilder.addUnencounteredBranches( + String.format( + "%sExpression ID %d ('%s'): lacks 'false' coverage", + precedingTabs, nodeId, exprText)); + precedingTabs += "\t\t"; + } + return precedingTabs; + } + + @ThreadSafe + private static final class EvaluationListener implements CelEvaluationListener { + + private final ConcurrentHashMap nodeCoverageStatsMap; + + EvaluationListener(ConcurrentHashMap nodeCoverageStatsMap) { + this.nodeCoverageStatsMap = nodeCoverageStatsMap; + } + + @Override + public void callback(CelExpr celExpr, Object evaluationResult) { + NodeCoverageStats nodeCoverageStats = nodeCoverageStatsMap.get(celExpr.id()); + nodeCoverageStats.covered.set(true); + if (nodeCoverageStats.isBooleanNode.get()) { + if (evaluationResult instanceof Boolean) { + if ((Boolean) evaluationResult) { + nodeCoverageStats.hasTrueBranch.set(true); + } else { + nodeCoverageStats.hasFalseBranch.set(true); + } + } + } + } + } + + private String kindToString(CelNavigableExpr node) { + if (node.parent().isPresent() + && node.parent().get().expr().getKind().equals(ExprKind.Kind.COMPREHENSION)) { + CelExpr.CelComprehension comp = node.parent().get().expr().comprehension(); + if (node.id() == comp.iterRange().id()) { + return "IterRange"; + } + if (node.id() == comp.accuInit().id()) { + return "AccuInit"; + } + if (node.id() == comp.loopCondition().id()) { + return "LoopCondition"; + } + if (node.id() == comp.loopStep().id()) { + return "LoopStep"; + } + if (node.id() == comp.result().id()) { + return "Result"; + } + } + + switch (node.getKind()) { + case CALL: + return "Call Node"; + case COMPREHENSION: + return "Comprehension Node"; + case IDENT: + return "Ident Node"; + case LIST: + return "List Node"; + case CONSTANT: + return "Literal Node"; + case MAP: + return "Map Node"; + case SELECT: + return "Select Node"; + case STRUCT: + return "Struct Node"; + default: + return "Unspecified Node"; + } + } + + private static String escapeSpecialCharacters(String exprText) { + return exprText + .replace("\\\"", "\"") + .replace("\"", "\\\"") + .replace("\n", "\\n") + .replace("||", " \\| \\| ") + .replace("<", "\\<") + .replace(">", "\\>") + .replace("{", "\\{") + .replace("}", "\\}"); + } + + private void writeDotGraphToArtifact(String dotGraph) { + String testOutputsDir = System.getenv("TEST_UNDECLARED_OUTPUTS_DIR"); + if (testOutputsDir == null) { + // Only for non-bazel/blaze users, we write to a subdirectory under the cwd. + testOutputsDir = "cel_artifacts"; + } + File outputDir = new File(testOutputsDir, "cel_test_coverage"); + if (!outputDir.exists()) { + outputDir.mkdirs(); + } + try { + Files.asCharSink(new File(outputDir, "coverage_graph.txt"), UTF_8).write(dotGraph); + } catch (IOException e) { + throw new IllegalStateException(e); + } + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/CelExpressionSource.java b/testing/src/main/java/dev/cel/testing/testrunner/CelExpressionSource.java new file mode 100644 index 000000000..23075ac41 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/CelExpressionSource.java @@ -0,0 +1,75 @@ +// Copyright 2025 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.testing.testrunner; + +import com.google.auto.value.AutoValue; + +/** + * CelExpressionSource is an encapsulation around cel_expr file format argument accepted in + * cel_java_test/cel_test bzl macro. It either holds a {@link CheckedExpr} in binarypb/textproto + * format, a serialized {@link CelPolicy} file in yaml/celpolicy format or a raw cel expression in + * cel file format or string format. + */ +@AutoValue +public abstract class CelExpressionSource { + + /** Returns the value of the expression source. This can be a file path or a raw expression. */ + public abstract String value(); + + /** Returns the type of the expression source. */ + public abstract ExpressionSourceType type(); + + /** + * Creates a {@link CelExpressionSource} from a file path. The type of the expression source is + * inferred from the file extension. + */ + public static CelExpressionSource fromSource(String value) { + return new AutoValue_CelExpressionSource(value, ExpressionSourceType.fromSource(value)); + } + + /** Creates a {@link CelExpressionSource} from a raw CEL expression string. */ + public static CelExpressionSource fromRawExpr(String value) { + return new AutoValue_CelExpressionSource(value, ExpressionSourceType.RAW_EXPR); + } + + /** + * ExpressionSourceType is an enumeration of the supported expression file types. + * + *

This enumeration is used to determine the type of the expression file based on the file + * extension. + */ + public enum ExpressionSourceType { + BINARYPB, + TEXTPROTO, + POLICY, + CEL, + RAW_EXPR; + + private static ExpressionSourceType fromSource(String filePath) { + if (filePath.endsWith(".binarypb")) { + return BINARYPB; + } + if (filePath.endsWith(".textproto")) { + return TEXTPROTO; + } + if (filePath.endsWith(".yaml") || filePath.endsWith(".celpolicy")) { + return POLICY; + } + if (filePath.endsWith(".cel")) { + return CEL; + } + throw new IllegalArgumentException("Unsupported expression file type: " + filePath); + } + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/CelTestContext.java b/testing/src/main/java/dev/cel/testing/testrunner/CelTestContext.java new file mode 100644 index 000000000..6ef988a44 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/CelTestContext.java @@ -0,0 +1,228 @@ +// Copyright 2025 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.testing.testrunner; + +import com.google.auto.value.AutoValue; +import com.google.auto.value.extension.memoized.Memoized; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FileDescriptor; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.TypeRegistry; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import dev.cel.common.CelOptions; +import dev.cel.policy.CelPolicyParser; +import dev.cel.runtime.CelLateFunctionBindings; +import dev.cel.testing.utils.ProtoDescriptorUtils; +import java.io.IOException; +import java.util.Arrays; +import java.util.Map; +import java.util.Optional; + +/** + * The context class for a CEL test, holding configurations needed to create environments and + * evaluate CEL expressions and policies. + */ +@AutoValue +public abstract class CelTestContext { + + private static final Cel DEFAULT_CEL = CelFactory.standardCelBuilder().build(); + + /** + * The CEL environment for the CEL test. + * + *

The CEL environment is created by extending the provided base CEL environment with the + * config file if provided. + */ + public abstract Cel cel(); + + /** + * The CEL policy parser for the CEL test. + * + *

A custom parser to be used for parsing CEL policies in scenarios where custom policy tags + * are used. If not provided, the default CEL policy parser will be used. + */ + public abstract Optional celPolicyParser(); + + /** + * The CEL options for the CEL test. + * + *

The CEL options are used to configure the {@link Cel} environment. + */ + public abstract CelOptions celOptions(); + + /** + * The late function bindings for the CEL test. + * + *

These bindings are used to provide functions which are to be consumed during the eval phase + * directly. + */ + public abstract Optional celLateFunctionBindings(); + + /** Interface for transforming bindings before evaluation. */ + @FunctionalInterface + public interface BindingTransformer { + ImmutableMap transform(ImmutableMap bindings) throws Exception; + } + + /** + * The binding transformer for the CEL test. + * + *

This transformer is used to transform the bindings before evaluation. + */ + public abstract Optional bindingTransformer(); + + /** + * The variable bindings for the CEL test. + * + *

These bindings are used to provide values for variables for which it is difficult to provide + * a value in the test suite file for example, using proto extensions or fetching the value from + * some other source. + */ + public abstract ImmutableMap variableBindings(); + + /** + * The result matcher for the CEL test. + * + *

This matcher is used to perform assertions on the result of a CEL test case. + */ + public abstract ResultMatcher resultMatcher(); + + /** + * The CEL expression to be tested. Could be a expression string or a policy/cel file path. This + * should only be used when invoking the runner library directly. + */ + public abstract Optional celExpression(); + + /** + * The config file for the CEL test. + * + *

The config file is used to provide a custom environment for the CEL test. + */ + public abstract Optional configFile(); + + /** + * The file descriptor set path for the CEL test. + * + *

The file descriptor set path is used to provide proto descriptors for the CEL test. + */ + public abstract Optional fileDescriptorSetPath(); + + abstract ImmutableSet fileTypes(); + + @Memoized + public Optional celDescriptors() { + if (fileDescriptorSetPath().isPresent()) { + try { + return Optional.of( + ProtoDescriptorUtils.getDescriptorsFromFile(fileDescriptorSetPath().get())); + } catch (IOException e) { + throw new IllegalStateException( + "Failed to load descriptors from path: " + fileDescriptorSetPath().get(), e); + } + } + return Optional.empty(); + } + + /** Returns a unified set of {@link CelDescriptors} combined from all descriptor sources. */ + @Memoized + public Optional mergedDescriptors() { + if (fileTypes().isEmpty() && !fileDescriptorSetPath().isPresent()) { + return Optional.empty(); + } + ImmutableSet.Builder allFiles = + ImmutableSet.builder().addAll(fileTypes()); + celDescriptors().ifPresent(d -> allFiles.addAll(d.fileDescriptors())); + return Optional.of(CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(allFiles.build())); + } + + @Memoized + public Optional typeRegistry() { + return mergedDescriptors().map(RegistryUtils::getTypeRegistry); + } + + public abstract Optional extensionRegistry(); + + /** Returns a builder for {@link CelTestContext} with the current instance's values. */ + public abstract Builder toBuilder(); + + /** Returns a new builder for {@link CelTestContext}. */ + public static CelTestContext.Builder newBuilder() { + return new AutoValue_CelTestContext.Builder() + .setCel(DEFAULT_CEL) + .setCelOptions(CelOptions.DEFAULT) + .setVariableBindings(ImmutableMap.of()) + .setResultMatcher(new DefaultResultMatcher()); + } + + /** Builder for {@link CelTestContext}. */ + @AutoValue.Builder + public abstract static class Builder { + public abstract Builder setCel(Cel cel); + + public abstract Builder setCelPolicyParser(CelPolicyParser celPolicyParser); + + public abstract Builder setCelOptions(CelOptions celOptions); + + public abstract Builder setCelLateFunctionBindings( + CelLateFunctionBindings celLateFunctionBindings); + + public abstract Builder setBindingTransformer(BindingTransformer bindingTransformer); + + public abstract Builder setVariableBindings(Map variableBindings); + + public abstract Builder setResultMatcher(ResultMatcher resultMatcher); + + public abstract Builder setCelExpression(CelExpressionSource celExpression); + + public abstract Builder setConfigFile(String configFile); + + public abstract Builder setFileDescriptorSetPath(String fileDescriptorSetPath); + + abstract ImmutableSet.Builder fileTypesBuilder(); + + @CanIgnoreReturnValue + public Builder addMessageTypes(Descriptor... descriptors) { + return addMessageTypes(Arrays.asList(descriptors)); + } + + @CanIgnoreReturnValue + public Builder addMessageTypes(Iterable descriptors) { + for (Descriptor descriptor : descriptors) { + addFileTypes(descriptor.getFile()); + } + return this; + } + + @CanIgnoreReturnValue + public Builder addFileTypes(FileDescriptor... fileDescriptors) { + return addFileTypes(Arrays.asList(fileDescriptors)); + } + + @CanIgnoreReturnValue + public Builder addFileTypes(Iterable fileDescriptors) { + fileTypesBuilder().addAll(fileDescriptors); + return this; + } + + public abstract Builder setExtensionRegistry(ExtensionRegistry extensionRegistry); + + public abstract CelTestContext build(); + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuite.java b/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuite.java new file mode 100644 index 000000000..a8869a8fb --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuite.java @@ -0,0 +1,245 @@ +// Copyright 2025 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.testing.testrunner; + +import com.google.auto.value.AutoOneOf; +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.protobuf.Any; +import dev.cel.common.Source; +import java.util.Optional; +import java.util.Set; + +/** Class representing a CEL test suite which is generated post parsing the test suite file. */ +@AutoValue +public abstract class CelTestSuite { + + public abstract String name(); + + /** Test suite source in textual format (ex: textproto, YAML). */ + public abstract Optional source(); + + public abstract String description(); + + public abstract ImmutableSet sections(); + + /** Builder for {@link CelTestSuite}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setName(String name); + + public abstract Builder setDescription(String description); + + public abstract Builder setSections(Set section); + + public abstract Builder setSections(CelTestSection... sections); + + public abstract Builder setSource(Source source); + + @CheckReturnValue + public abstract CelTestSuite build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder() { + return new AutoValue_CelTestSuite.Builder(); + } + + /** + * Class representing a CEL test section within a test suite following the schema in {@link + * dev.cel.expr.conformance.test.TestSuite}. + */ + @AutoValue + public abstract static class CelTestSection { + + public abstract String name(); + + public abstract String description(); + + public abstract ImmutableSet tests(); + + /** Builder for {@link CelTestSection}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setName(String name); + + public abstract Builder setTests(Set tests); + + public abstract Builder setTests(CelTestCase... tests); + + public abstract Builder setDescription(String description); + + @CheckReturnValue + public abstract CelTestSection build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder() { + return new AutoValue_CelTestSuite_CelTestSection.Builder().setDescription(""); + } + + /** Class representing a CEL test case within a test section. */ + @AutoValue + public abstract static class CelTestCase { + + public abstract String name(); + + public abstract String description(); + + public abstract Input input(); + + public abstract Output output(); + + /** This class represents the input of a CEL test case. */ + @AutoOneOf(Input.Kind.class) + public abstract static class Input { + /** Kind of input for a CEL test case. */ + public enum Kind { + BINDINGS, + CONTEXT_EXPR, + CONTEXT_MESSAGE, + NO_INPUT + } + + public abstract Input.Kind kind(); + + public abstract ImmutableMap bindings(); + + public abstract String contextExpr(); + + public abstract Any contextMessage(); + + public abstract void noInput(); + + public static Input ofBindings(ImmutableMap bindings) { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Input.bindings(bindings); + } + + public static Input ofContextExpr(String contextExpr) { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Input.contextExpr(contextExpr); + } + + public static Input ofContextMessage(Any contextMessage) { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Input.contextMessage( + contextMessage); + } + + public static Input ofNoInput() { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Input.noInput(); + } + + /** This class represents a binding for a CEL test case. */ + @AutoOneOf(Binding.Kind.class) + public abstract static class Binding { + + /** Kind of binding for a CEL test case. */ + public enum Kind { + VALUE, + EXPR + } + + public abstract Binding.Kind kind(); + + public abstract Object value(); + + public abstract String expr(); + + public static Binding ofValue(Object value) { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Input_Binding.value(value); + } + + public static Binding ofExpr(String expr) { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Input_Binding.expr(expr); + } + } + } + + /** This class represents the result of a CEL test case. */ + @AutoOneOf(Output.Kind.class) + public abstract static class Output { + /** Kind of result for a CEL test case. */ + public enum Kind { + RESULT_VALUE, + RESULT_EXPR, + EVAL_ERROR, + UNKNOWN_SET, + NO_OUTPUT + } + + public abstract Output.Kind kind(); + + public abstract Object resultValue(); + + public abstract String resultExpr(); + + public abstract void noOutput(); + + public abstract ImmutableList evalError(); + + public abstract ImmutableList unknownSet(); + + public static Output ofResultValue(Object resultValue) { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Output.resultValue(resultValue); + } + + public static Output ofResultExpr(String resultExpr) { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Output.resultExpr(resultExpr); + } + + public static Output ofEvalError(ImmutableList errors) { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Output.evalError(errors); + } + + public static Output ofUnknownSet(ImmutableList unknownSet) { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Output.unknownSet(unknownSet); + } + + public static Output ofNoOutput() { + return AutoOneOf_CelTestSuite_CelTestSection_CelTestCase_Output.noOutput(); + } + } + + /** Builder for {@link CelTestCase}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setName(String name); + + public abstract Builder setDescription(String description); + + public abstract Builder setInput(Input input); + + public abstract Builder setOutput(Output output); + + @CheckReturnValue + public abstract CelTestCase build(); + } + + public abstract Builder toBuilder(); + + public static Builder newBuilder() { + return new AutoValue_CelTestSuite_CelTestSection_CelTestCase.Builder() + .setInput(Input.ofNoInput()) // Default input to no input. + .setDescription(""); + } + } + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuiteException.java b/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuiteException.java new file mode 100644 index 000000000..3b3449df4 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuiteException.java @@ -0,0 +1,29 @@ +// Copyright 2025 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.testing.testrunner; + +import dev.cel.common.CelException; + +/** Checked exception thrown when a CEL test suite is misconfigured. */ +public final class CelTestSuiteException extends CelException { + + CelTestSuiteException(String message) { + super(message); + } + + CelTestSuiteException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuiteTextProtoParser.java b/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuiteTextProtoParser.java new file mode 100644 index 000000000..9c0ab4720 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuiteTextProtoParser.java @@ -0,0 +1,188 @@ +// Copyright 2025 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.testing.testrunner; + +import dev.cel.expr.Status; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.TextFormat; +import com.google.protobuf.TextFormat.ParseException; +import com.google.protobuf.TypeRegistry; +import dev.cel.common.CelDescriptors; +import dev.cel.common.annotations.Internal; +import dev.cel.expr.conformance.test.InputValue; +import dev.cel.expr.conformance.test.TestCase; +import dev.cel.expr.conformance.test.TestSection; +import dev.cel.expr.conformance.test.TestSuite; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase.Input.Binding; +import dev.cel.testing.utils.ProtoDescriptorUtils; +import java.io.IOException; +import java.util.Map; + +/** + * CelTestSuiteTextProtoParser intakes a textproto document that describes the structure of a CEL + * test suite, parses it then creates a {@link CelTestSuite}. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class CelTestSuiteTextProtoParser { + + /** Creates a new instance of {@link CelTestSuiteTextProtoParser}. */ + public static CelTestSuiteTextProtoParser newInstance() { + return new CelTestSuiteTextProtoParser(); + } + + public CelTestSuite parse(String textProto) throws IOException, CelTestSuiteException { + return parse( + textProto, TypeRegistry.getEmptyTypeRegistry(), ExtensionRegistry.getEmptyRegistry()); + } + + public CelTestSuite parse(String textProto, TypeRegistry customTypeRegistry) + throws IOException, CelTestSuiteException { + return parse(textProto, customTypeRegistry, ExtensionRegistry.getEmptyRegistry()); + } + + public CelTestSuite parse( + String textProto, TypeRegistry customTypeRegistry, ExtensionRegistry customExtensionRegistry) + throws IOException, CelTestSuiteException { + TestSuite testSuite = parseTestSuite(textProto, customTypeRegistry, customExtensionRegistry); + return parseCelTestSuite(testSuite); + } + + private TestSuite parseTestSuite( + String textProto, TypeRegistry customTypeRegistry, ExtensionRegistry customExtensionRegistry) + throws IOException { + String fileDescriptorSetPath = System.getProperty("file_descriptor_set_path"); + TypeRegistry typeRegistry = customTypeRegistry; + ExtensionRegistry extensionRegistry = customExtensionRegistry; + if (fileDescriptorSetPath != null) { + CelDescriptors descriptors = + ProtoDescriptorUtils.getDescriptorsFromFile(fileDescriptorSetPath); + extensionRegistry = RegistryUtils.getExtensionRegistry(descriptors); + typeRegistry = RegistryUtils.getTypeRegistry(descriptors); + } + TextFormat.Parser parser = TextFormat.Parser.newBuilder().setTypeRegistry(typeRegistry).build(); + TestSuite.Builder builder = TestSuite.newBuilder(); + try { + parser.merge(textProto, extensionRegistry, builder); + } catch (ParseException e) { + throw new IllegalArgumentException("Failed to parse test suite", e); + } + return builder.build(); + } + + @VisibleForTesting + static CelTestSuite parseCelTestSuite(TestSuite testSuite) throws CelTestSuiteException { + CelTestSuite.Builder builder = + CelTestSuite.newBuilder() + .setName(testSuite.getName()) + .setDescription(testSuite.getDescription()); + ImmutableSet.Builder sectionSetBuilder = ImmutableSet.builder(); + + for (TestSection section : testSuite.getSectionsList()) { + CelTestSection.Builder sectionBuilder = + CelTestSection.newBuilder() + .setName(section.getName()) + .setDescription(section.getDescription()); + ImmutableSet.Builder testCaseSetBuilder = ImmutableSet.builder(); + + for (TestCase testCase : section.getTestsList()) { + CelTestCase.Builder testCaseBuilder = + CelTestCase.newBuilder() + .setName(testCase.getName()) + .setDescription(testCase.getDescription()); + addInputs(testCaseBuilder, testCase); + addOutputs(testCaseBuilder, testCase); + testCaseSetBuilder.add(testCaseBuilder.build()); + } + + sectionBuilder.setTests(testCaseSetBuilder.build()); + sectionSetBuilder.add(sectionBuilder.build()); + } + return builder.setSections(sectionSetBuilder.build()).build(); + } + + private static void addInputs(CelTestCase.Builder testCaseBuilder, TestCase testCase) + throws CelTestSuiteException { + if (testCase.getInputCount() > 0 && testCase.hasInputContext()) { + throw new CelTestSuiteException( + String.format( + "Test case: %s cannot have both input map and input context.", testCase.getName())); + } else if (testCase.getInputCount() > 0) { + testCaseBuilder.setInput(parseInputMap(testCase)); + } else if (testCase.hasInputContext()) { + testCaseBuilder.setInput(parseInputContext(testCase)); + } else { + testCaseBuilder.setInput(CelTestCase.Input.ofNoInput()); + } + } + + private static CelTestCase.Input parseInputMap(TestCase testCase) { + ImmutableMap.Builder inputMapBuilder = ImmutableMap.builder(); + for (Map.Entry entry : testCase.getInputMap().entrySet()) { + InputValue inputValue = entry.getValue(); + if (inputValue.hasValue()) { + inputMapBuilder.put(entry.getKey(), Binding.ofValue(inputValue.getValue())); + } else if (inputValue.hasExpr()) { + inputMapBuilder.put(entry.getKey(), Binding.ofExpr(inputValue.getExpr())); + } + } + return CelTestCase.Input.ofBindings(inputMapBuilder.buildOrThrow()); + } + + private static CelTestCase.Input parseInputContext(TestCase testCase) { + if (testCase.getInputContext().hasContextMessage()) { + return CelTestCase.Input.ofContextMessage(testCase.getInputContext().getContextMessage()); + } else if (testCase.getInputContext().hasContextExpr()) { + return CelTestCase.Input.ofContextExpr(testCase.getInputContext().getContextExpr()); + } + return CelTestCase.Input.ofNoInput(); + } + + private static void addOutputs(CelTestCase.Builder testCaseBuilder, TestCase testCase) { + if (testCase.hasOutput()) { + switch (testCase.getOutput().getResultKindCase()) { + case RESULT_VALUE: + testCaseBuilder.setOutput( + CelTestCase.Output.ofResultValue(testCase.getOutput().getResultValue())); + break; + case RESULT_EXPR: + testCaseBuilder.setOutput( + CelTestCase.Output.ofResultExpr(testCase.getOutput().getResultExpr())); + break; + case EVAL_ERROR: + testCaseBuilder.setOutput(CelTestCase.Output.ofEvalError(parseEvalError(testCase))); + break; + default: + break; + } + } + } + + private static ImmutableList parseEvalError(TestCase testCase) { + ImmutableList.Builder evalErrorSetBuilder = ImmutableList.builder(); + for (Status error : testCase.getOutput().getEvalError().getErrorsList()) { + evalErrorSetBuilder.add(error.getMessage()); + } + return evalErrorSetBuilder.build(); + } + + private CelTestSuiteTextProtoParser() {} +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuiteYamlParser.java b/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuiteYamlParser.java new file mode 100644 index 000000000..2340bf229 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/CelTestSuiteYamlParser.java @@ -0,0 +1,383 @@ +// Copyright 2025 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.testing.testrunner; + +import static dev.cel.common.formats.YamlHelper.YamlNodeType.nodeType; +import static dev.cel.common.formats.YamlHelper.assertYamlType; +import static dev.cel.common.formats.YamlHelper.newBoolean; +import static dev.cel.common.formats.YamlHelper.newDouble; +import static dev.cel.common.formats.YamlHelper.newInteger; +import static dev.cel.common.formats.YamlHelper.newString; +import static dev.cel.common.formats.YamlHelper.parseYamlSource; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import dev.cel.common.CelIssue; +import dev.cel.common.annotations.Internal; +import dev.cel.common.formats.CelFileSource; +import dev.cel.common.formats.ParserContext; +import dev.cel.common.formats.YamlHelper.YamlNodeType; +import dev.cel.common.formats.YamlParserContextImpl; +import dev.cel.common.internal.CelCodePointArray; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase.Input.Binding; +import java.util.Optional; +import org.yaml.snakeyaml.nodes.MappingNode; +import org.yaml.snakeyaml.nodes.Node; +import org.yaml.snakeyaml.nodes.NodeTuple; +import org.yaml.snakeyaml.nodes.ScalarNode; +import org.yaml.snakeyaml.nodes.SequenceNode; + +/** + * CelTestSuiteYamlParser intakes a YAML document that describes the structure of a CEL test suite, + * parses it then creates a {@link CelTestSuite}. + * + *

CEL Library Internals. Do Not Use. + */ +@Internal +public final class CelTestSuiteYamlParser { + + /** Creates a new instance of {@link CelTestSuiteYamlParser}. */ + public static CelTestSuiteYamlParser newInstance() { + return new CelTestSuiteYamlParser(); + } + + public CelTestSuite parse(String celTestSuiteYamlContent) throws CelTestSuiteException { + return parseYaml(celTestSuiteYamlContent, ""); + } + + private CelTestSuite parseYaml(String celTestSuiteYamlContent, String description) + throws CelTestSuiteException { + Node node; + try { + node = + parseYamlSource(celTestSuiteYamlContent) + .orElseThrow( + () -> + new CelTestSuiteException( + String.format( + "YAML document empty or malformed: %s", celTestSuiteYamlContent))); + } catch (RuntimeException e) { + throw new CelTestSuiteException("YAML document is malformed: " + e.getMessage(), e); + } + + CelFileSource testSuiteSource = + CelFileSource.newBuilder(CelCodePointArray.fromString(celTestSuiteYamlContent)) + .setDescription(description) + .build(); + ParserContext ctx = YamlParserContextImpl.newInstance(testSuiteSource); + CelTestSuite.Builder builder = parseTestSuite(ctx, node); + testSuiteSource = testSuiteSource.toBuilder().setPositionsMap(ctx.getIdToOffsetMap()).build(); + + if (!ctx.getIssues().isEmpty()) { + throw new CelTestSuiteException(CelIssue.toDisplayString(ctx.getIssues(), testSuiteSource)); + } + + return builder.setSource(testSuiteSource).build(); + } + + private CelTestSuite.Builder parseTestSuite(ParserContext ctx, Node node) { + CelTestSuite.Builder builder = CelTestSuite.newBuilder().setName("").setDescription(""); + long id = ctx.collectMetadata(node); + if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) { + ctx.reportError(id, "Unknown test suite type: " + node.getTag()); + return builder; + } + + MappingNode rootNode = (MappingNode) node; + for (NodeTuple nodeTuple : rootNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) { + continue; + } + + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "name": + builder.setName(newString(ctx, valueNode)); + break; + case "description": + builder.setDescription(newString(ctx, valueNode)); + break; + case "section": + case "sections": + builder.setSections(parseSections(ctx, valueNode)); + break; + default: + ctx.reportError(keyId, "Unknown test suite tag: " + fieldName); + break; + } + } + return builder; + } + + private ImmutableSet parseSections(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + ImmutableSet.Builder celTestSectionSetBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + ctx.reportError(valueId, "Sections is not a list: " + node.getTag()); + return celTestSectionSetBuilder.build(); + } + + SequenceNode sectionListNode = (SequenceNode) node; + for (Node elementNode : sectionListNode.getValue()) { + celTestSectionSetBuilder.add(parseSection(ctx, elementNode)); + } + return celTestSectionSetBuilder.build(); + } + + private CelTestSection parseSection(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.MAP)) { + ctx.reportError(valueId, "Unknown section type: " + node.getTag()); + return CelTestSection.newBuilder().build(); + } + + CelTestSection.Builder celTestSectionBuilder = CelTestSection.newBuilder(); + MappingNode sectionNode = (MappingNode) node; + for (NodeTuple nodeTuple : sectionNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "name": + celTestSectionBuilder.setName(newString(ctx, valueNode)); + break; + case "description": + celTestSectionBuilder.setDescription(newString(ctx, valueNode)); + break; + case "tests": + celTestSectionBuilder.setTests(parseTests(ctx, valueNode)); + break; + default: + ctx.reportError(keyId, "Unknown test section tag: " + fieldName); + break; + } + } + return celTestSectionBuilder.build(); + } + + private ImmutableSet parseTests(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + ImmutableSet.Builder celTestCaseSetBuilder = ImmutableSet.builder(); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) { + ctx.reportError(valueId, "Tests is not a list: " + node.getTag()); + return celTestCaseSetBuilder.build(); + } + + SequenceNode testCasesListNode = (SequenceNode) node; + for (Node elementNode : testCasesListNode.getValue()) { + celTestCaseSetBuilder.add(parseTestCase(ctx, elementNode)); + } + return celTestCaseSetBuilder.build(); + } + + private CelTestCase parseTestCase(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + CelTestCase.Builder celTestCaseBuilder = CelTestCase.newBuilder(); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.MAP)) { + ctx.reportError(valueId, "Testcase is not a map: " + node.getTag()); + return celTestCaseBuilder.build(); + } + MappingNode testCaseNode = (MappingNode) node; + for (NodeTuple nodeTuple : testCaseNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "name": + celTestCaseBuilder.setName(newString(ctx, valueNode)); + break; + case "description": + celTestCaseBuilder.setDescription(newString(ctx, valueNode)); + break; + case "input": + celTestCaseBuilder.setInput(parseInput(ctx, valueNode)); + break; + case "context_expr": + celTestCaseBuilder.setInput(parseContextExpr(ctx, valueNode)); + break; + case "output": + celTestCaseBuilder.setOutput(parseOutput(ctx, valueNode)); + break; + default: + ctx.reportError(keyId, "Unknown test case tag: " + fieldName); + break; + } + } + return celTestCaseBuilder.build(); + } + + private CelTestCase.Input parseInput(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.MAP)) { + ctx.reportError(valueId, "Input is not a map: " + node.getTag()); + return CelTestCase.Input.ofNoInput(); + } + MappingNode inputNode = (MappingNode) node; + ImmutableMap.Builder bindingsBuilder = ImmutableMap.builder(); + for (NodeTuple nodeTuple : inputNode.getValue()) { + Node valueNode = nodeTuple.getValueNode(); + Optional binding = parseBindingValueNode(ctx, valueNode); + binding.ifPresent( + b -> bindingsBuilder.put(((ScalarNode) nodeTuple.getKeyNode()).getValue(), b)); + } + return CelTestCase.Input.ofBindings(bindingsBuilder.buildOrThrow()); + } + + private Optional parseBindingValueNode(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.MAP)) { + ctx.reportError(valueId, "Input binding node is not a map: " + node.getTag()); + return Optional.empty(); + } + MappingNode bindingValueNode = (MappingNode) node; + + if (bindingValueNode.getValue().size() != 1) { + ctx.reportError(valueId, "Input binding node must have exactly one value: " + node.getTag()); + return Optional.empty(); + } + + for (NodeTuple nodeTuple : bindingValueNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "value": + return Optional.of(Binding.ofValue(parseNodeValue(ctx, valueNode))); + case "expr": + return Optional.of(Binding.ofExpr(newString(ctx, valueNode))); + default: + ctx.reportError(keyId, "Unknown input binding value tag: " + fieldName); + break; + } + } + return Optional.empty(); + } + + // TODO: Create a CelTestSuiteNodeValue class to represent the value of a test suite + // node. + private Object parseNodeValue(ParserContext ctx, Node node) { + Object value = null; + Optional yamlNodeType = nodeType(node.getTag().getValue()); + if (yamlNodeType.isPresent()) { + switch (yamlNodeType.get()) { + case STRING: + case TEXT: + value = newString(ctx, node); + break; + case BOOLEAN: + value = newBoolean(ctx, node); + break; + case INTEGER: + value = newInteger(ctx, node); + break; + case DOUBLE: + value = newDouble(ctx, node); + break; + case MAP: + value = parseMap(ctx, node); + break; + case LIST: + value = parseList(ctx, node); + break; + } + } + return value; + } + + private ImmutableMap parseMap(ParserContext ctx, Node node) { + ImmutableMap.Builder mapBuilder = ImmutableMap.builder(); + MappingNode mapNode = (MappingNode) node; + mapNode + .getValue() + .forEach( + nodeTuple -> { + Node keyNode = nodeTuple.getKeyNode(); + Node valueNode = nodeTuple.getValueNode(); + mapBuilder.put(parseNodeValue(ctx, keyNode), parseNodeValue(ctx, valueNode)); + }); + return mapBuilder.buildOrThrow(); + } + + private ImmutableList parseList(ParserContext ctx, Node node) { + ImmutableList.Builder listBuilder = ImmutableList.builder(); + SequenceNode listNode = (SequenceNode) node; + listNode.getValue().forEach(childNode -> listBuilder.add(parseNodeValue(ctx, childNode))); + return listBuilder.build(); + } + + private ImmutableList parseUnknown(ParserContext ctx, Node node) { + ImmutableList unknown = parseList(ctx, node); + ImmutableList.Builder unknownBuilder = ImmutableList.builder(); + for (Object object : unknown) { + if (object instanceof Integer) { + unknownBuilder.add(Long.valueOf((Integer) object)); + } else { + ctx.reportError( + ctx.collectMetadata(node), + "Only integer ids are supported in unknown list. Found: " + + object.getClass().getName()); + } + } + return unknownBuilder.build(); + } + + private CelTestCase.Input parseContextExpr(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.STRING)) { + ctx.reportError(valueId, "Input context is not a string: " + node.getTag()); + return CelTestCase.Input.ofNoInput(); + } + return CelTestCase.Input.ofContextExpr(newString(ctx, node)); + } + + private CelTestCase.Output parseOutput(ParserContext ctx, Node node) { + long valueId = ctx.collectMetadata(node); + if (!assertYamlType(ctx, valueId, node, YamlNodeType.MAP)) { + ctx.reportError(valueId, "Output is not a map: " + node.getTag()); + return CelTestCase.Output.ofNoOutput(); + } + MappingNode outputNode = (MappingNode) node; + for (NodeTuple nodeTuple : outputNode.getValue()) { + Node keyNode = nodeTuple.getKeyNode(); + long keyId = ctx.collectMetadata(keyNode); + Node valueNode = nodeTuple.getValueNode(); + String fieldName = ((ScalarNode) keyNode).getValue(); + switch (fieldName) { + case "value": + return CelTestCase.Output.ofResultValue(parseNodeValue(ctx, valueNode)); + case "expr": + return CelTestCase.Output.ofResultExpr(newString(ctx, valueNode)); + case "error_set": + return CelTestCase.Output.ofEvalError(parseList(ctx, valueNode)); + case "unknown": + return CelTestCase.Output.ofUnknownSet(parseUnknown(ctx, valueNode)); + default: + ctx.reportError(keyId, "Unknown output tag: " + fieldName); + break; + } + } + return CelTestCase.Output.ofNoOutput(); + } + + private CelTestSuiteYamlParser() {} +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/CelUserTestTemplate.java b/testing/src/main/java/dev/cel/testing/testrunner/CelUserTestTemplate.java new file mode 100644 index 000000000..02180ffb7 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/CelUserTestTemplate.java @@ -0,0 +1,83 @@ +// Copyright 2025 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.testing.testrunner; + +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase; +import org.jspecify.annotations.Nullable; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; + +/** + * Template to be extended by user's test class in order to be parameterized based on individual + * test cases. + */ +@RunWith(Parameterized.class) +public abstract class CelUserTestTemplate { + + @Parameter(0) + public CelTestCase testCase; + + @Parameter(1) + public @Nullable CelCoverageIndex celCoverageIndex; + + private final CelTestContext celTestContext; + + public CelUserTestTemplate(CelTestContext celTestContext) { + this.celTestContext = celTestContext; + } + + @Test + public void test() throws Exception { + if (celCoverageIndex != null) { + TestRunnerLibrary.runTest(testCase, updateCelTestContext(celTestContext), celCoverageIndex); + } else { + TestRunnerLibrary.runTest(testCase, updateCelTestContext(celTestContext)); + } + } + + /** + * Updates the CEL test context based on the system properties. + * + *

This method is used to update the CEL test context based on the system properties. It checks + * if the runner library is triggered via blaze macro or via JUnit and assigns values accordingly. + * + * @param celTestContext The CEL test context to update. + * @return The updated CEL test context. + */ + private CelTestContext updateCelTestContext(CelTestContext celTestContext) { + String celExpr = System.getProperty("cel_expr"); + String configPath = System.getProperty("config_path"); + String fileDescriptorSetPath = System.getProperty("file_descriptor_set_path"); + String isRawExpr = System.getProperty("is_raw_expr"); + + CelTestContext.Builder celTestContextBuilder = celTestContext.toBuilder(); + if (celExpr != null) { + if (isRawExpr.equals("True")) { + celTestContextBuilder.setCelExpression(CelExpressionSource.fromRawExpr(celExpr)); + } else { + celTestContextBuilder.setCelExpression(CelExpressionSource.fromSource(celExpr)); + } + } + if (configPath != null) { + celTestContextBuilder.setConfigFile(configPath); + } + if (fileDescriptorSetPath != null) { + celTestContextBuilder.setFileDescriptorSetPath(fileDescriptorSetPath); + } + return celTestContextBuilder.build(); + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/DefaultResultMatcher.java b/testing/src/main/java/dev/cel/testing/testrunner/DefaultResultMatcher.java new file mode 100644 index 000000000..279d591a2 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/DefaultResultMatcher.java @@ -0,0 +1,114 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat; +import static com.google.protobuf.LegacyUnredactedTextFormat.legacyUnredactedStringValueOf; +import static dev.cel.testing.utils.ExprValueUtils.toExprValue; + +import dev.cel.expr.ExprValue; +import dev.cel.expr.MapValue; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelDescriptors; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime.Program; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase.Output; +import dev.cel.testing.testrunner.ResultMatcher.ResultMatcherParams; +import dev.cel.testing.testrunner.ResultMatcher.ResultMatcherParams.ComputedOutput; +import dev.cel.testing.utils.ProtoDescriptorUtils; +import java.io.IOException; + +final class DefaultResultMatcher implements ResultMatcher { + + @Override + public void match(ResultMatcherParams params, Cel cel) throws Exception { + Output result = params.expectedOutput().get(); + switch (result.kind()) { + case RESULT_EXPR: + if (params.computedOutput().kind().equals(ComputedOutput.Kind.ERROR)) { + throw new AssertionError( + "Error: " + params.computedOutput().error().getMessage(), + params.computedOutput().error()); + } + if (params.computedOutput().kind().equals(ComputedOutput.Kind.UNKNOWN_SET)) { + throw new AssertionError( + "Expected value but got UnknownSet: " + params.computedOutput().unknownSet()); + } + CelAbstractSyntaxTree exprAst = cel.compile(result.resultExpr()).getAst(); + Program exprProgram = cel.createProgram(exprAst); + Object evaluationResult = null; + try { + evaluationResult = exprProgram.eval(); + } catch (CelEvaluationException e) { + throw new IllegalArgumentException( + "Failed to evaluate result_expr: " + e.getMessage(), e); + } + ExprValue expectedExprValue = toExprValue(evaluationResult, exprAst.getResultType()); + assertThat(params.computedOutput().exprValue()).isEqualTo(expectedExprValue); + break; + case RESULT_VALUE: + if (params.computedOutput().kind().equals(ComputedOutput.Kind.ERROR)) { + throw new AssertionError( + "Error: " + params.computedOutput().error().getMessage(), + params.computedOutput().error()); + } + if (params.computedOutput().kind().equals(ComputedOutput.Kind.UNKNOWN_SET)) { + throw new AssertionError( + "Expected value but got UnknownSet: " + params.computedOutput().unknownSet()); + } + assertExprValue( + params.computedOutput().exprValue(), + toExprValue(result.resultValue(), params.resultType())); + break; + case EVAL_ERROR: + if (params.computedOutput().kind().equals(ComputedOutput.Kind.EXPR_VALUE)) { + throw new AssertionError( + "Evaluation was successful but no value was provided. Computed output: " + + legacyUnredactedStringValueOf(params.computedOutput().exprValue())); + } + assertThat(params.computedOutput().error().toString()) + .contains(result.evalError().get(0).toString()); + break; + case UNKNOWN_SET: + assertThat(params.computedOutput().unknownSet()) + .containsExactlyElementsIn(result.unknownSet()); + break; + default: + throw new IllegalArgumentException("Unexpected output type: " + result.kind()); + } + } + + private static void assertExprValue(ExprValue exprValue, ExprValue expectedExprValue) + throws IOException { + String fileDescriptorSetPath = System.getProperty("file_descriptor_set_path"); + if (fileDescriptorSetPath != null) { + CelDescriptors descriptors = + ProtoDescriptorUtils.getDescriptorsFromFile(fileDescriptorSetPath); + assertThat(exprValue) + .ignoringRepeatedFieldOrderOfFieldDescriptors( + MapValue.getDescriptor().findFieldByName("entries")) + .unpackingAnyUsing( + RegistryUtils.getTypeRegistry(descriptors), + RegistryUtils.getExtensionRegistry(descriptors)) + .isEqualTo(expectedExprValue); + } else { + assertThat(exprValue) + .ignoringRepeatedFieldOrderOfFieldDescriptors( + MapValue.getDescriptor().findFieldByName("entries")) + .isEqualTo(expectedExprValue); + } + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/JUnitXmlReporter.java b/testing/src/main/java/dev/cel/testing/testrunner/JUnitXmlReporter.java new file mode 100644 index 000000000..7be21e1e3 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/JUnitXmlReporter.java @@ -0,0 +1,291 @@ +// Copyright 2025 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.testing.testrunner; + +import static java.nio.charset.StandardCharsets.UTF_8; + +import com.google.common.base.Throwables; +import com.google.common.collect.Lists; +import java.io.BufferedWriter; +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.util.List; +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.stream.StreamResult; +import org.jspecify.annotations.Nullable; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Text; + +/** Reporter class to generate an xml report in junit format. */ +final class JUnitXmlReporter { + private String outputFileName = null; + private File outputFile = null; + private TestContext testContext = null; + // NOMUTANTS -- To be fixed in b/394771693 and when more failure tests are added. + private int numFailed = 0; + + private final List allTests = Lists.newArrayList(); + + /** Creates an instance that will write to {@code outputFileName}. */ + JUnitXmlReporter(String outputFileName) { + this.outputFileName = outputFileName; + } + + /** Called for each test case */ + void onTestStart(TestResult result) {} + + /** Called on test success */ + void onTestSuccess(TestResult tr) { + allTests.add(tr); + } + + /** Called when the test fails */ + void onTestFailure(TestResult tr) { + allTests.add(tr); + numFailed++; + } + + /** Called in the beginning of test suite. */ + void onStart(TestContext context) { + outputFile = new File(outputFileName); + testContext = context; + } + + void onFinish() { + generateReport(/* coverageReport= */ null); + } + + /** Called after all tests are run */ + void onFinish(CelCoverageIndex.@Nullable CoverageReport coverageReport) { + generateReport(coverageReport); + } + + /** Returns the number of failed tests */ + int getNumFailed() { + return numFailed; + } + + /** + * Generates junit equivalent xml report that sponge/fusion can understand. Called after all tests + * are run + */ + void generateReport(CelCoverageIndex.@Nullable CoverageReport coverageReport) { + try { + DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance(); + DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder(); + Document doc = docBuilder.newDocument(); + + Element rootElement = doc.createElement(XmlConstants.TESTSUITE); + rootElement.setAttribute(XmlConstants.ATTR_NAME, testContext.getSuiteName()); + + rootElement.setAttribute(XmlConstants.ATTR_TESTS, "" + allTests.size()); + rootElement.setAttribute(XmlConstants.ATTR_FAILURES, "" + numFailed); + rootElement.setAttribute(XmlConstants.ATTR_ERRORS, "0"); + + long elapsedTimeMillis = testContext.getEndTime() - testContext.getStartTime(); + + rootElement.setAttribute(XmlConstants.ATTR_TIME, "" + (elapsedTimeMillis / 1000.0)); + + String prevClassName = null; + String currentClassName = null; + Element prevSuite = null; + Element currentSuite = null; + int testsInSuite = 0; + int failedTests = 0; + // NOMUTANTS -- Need not to be fixed. + long startTime = 0; + // NOMUTANTS -- Need not to be fixed. + long endTime = 0; + + // go through each test result + for (TestResult tr : allTests) { + prevClassName = currentClassName; + currentClassName = tr.getTestClassName(); + + // as all results are in single array this will create + // testsuite element as in junit. + if (!currentClassName.equals(prevClassName)) { + prevSuite = currentSuite; + currentSuite = doc.createElement(XmlConstants.TESTSUITE); + rootElement.appendChild(currentSuite); + addCoverageAttributes(currentSuite, coverageReport); + currentSuite.setAttribute(XmlConstants.ATTR_NAME, tr.getTestClassName()); + if (prevSuite != null) { + prevSuite.setAttribute(XmlConstants.ATTR_TESTS, "" + testsInSuite); + prevSuite.setAttribute(XmlConstants.ATTR_FAILURES, "" + failedTests); + prevSuite.setAttribute(XmlConstants.ATTR_ERRORS, "0"); + prevSuite.setAttribute(XmlConstants.ATTR_TIME, "" + (endTime - startTime) / 1000.0); + testsInSuite = 0; + failedTests = 0; + } + startTime = tr.getStartMillis(); + } + endTime = tr.getEndMillis(); + + Element testCaseElement = doc.createElement(XmlConstants.TESTCASE); + elapsedTimeMillis = tr.getEndMillis() - tr.getStartMillis(); + testCaseElement.setAttribute(XmlConstants.ATTR_NAME, tr.getName()); + testCaseElement.setAttribute(XmlConstants.ATTR_CLASSNAME, tr.getTestClassName()); + testCaseElement.setAttribute( + XmlConstants.ATTR_TIME, "" + ((double) elapsedTimeMillis) / 1000); + + // for failure add fail message + if (tr.getStatus() == TestResult.FAILURE) { + failedTests++; + Element nested = doc.createElement(XmlConstants.FAILURE); + testCaseElement.appendChild(nested); + Throwable t = tr.getThrowable(); + if (t != null) { + nested.setAttribute(XmlConstants.ATTR_TYPE, t.getClass().getName()); + String message = t.getMessage(); + if ((message != null) && (message.length() > 0)) { + nested.setAttribute(XmlConstants.ATTR_MESSAGE, message); + } + Text trace = doc.createTextNode(Throwables.getStackTraceAsString(t)); + nested.appendChild(trace); + } + } + currentSuite.appendChild(testCaseElement); + testsInSuite++; + } + + currentSuite.setAttribute(XmlConstants.ATTR_TESTS, "" + testsInSuite); + currentSuite.setAttribute(XmlConstants.ATTR_FAILURES, "" + failedTests); + currentSuite.setAttribute(XmlConstants.ATTR_ERRORS, "0"); + currentSuite.setAttribute(XmlConstants.ATTR_TIME, "" + (endTime - startTime) / 1000.0); + + // Writes to a file + try (BufferedWriter fw = Files.newBufferedWriter(outputFile.toPath(), UTF_8)) { + Transformer transformer = TransformerFactory.newInstance().newTransformer(); + transformer.transform(new DOMSource(rootElement), new StreamResult(fw)); + } catch (TransformerException te) { + te.printStackTrace(); + System.err.println("Error while writing out JUnitXML because of " + te); + } catch (IOException ioe) { + ioe.printStackTrace(); + System.err.println("failed to create JUnitXML because of " + ioe); + } + + } catch (ParserConfigurationException pce) { + pce.printStackTrace(); + System.err.println("failed to create JUnitXML because of " + pce); + } + } + + private void addCoverageAttributes( + Element currentSuite, CelCoverageIndex.@Nullable CoverageReport coverageReport) { + if (coverageReport == null) { + return; + } + if (coverageReport.nodes() == 0) { + currentSuite.setAttribute(XmlConstants.ATTR_CEL_COVERAGE, "No coverage stats found"); + } else { + // CEL expression + currentSuite.setAttribute(XmlConstants.ATTR_CEL_EXPR, coverageReport.celExpression()); + // Node coverage + double nodeCoverage = + (double) coverageReport.coveredNodes() / (double) coverageReport.nodes() * 100.0; + String nodeCoverageString = + String.format( + "%.2f%% (%d out of %d nodes covered)", + nodeCoverage, coverageReport.coveredNodes(), coverageReport.nodes()); + currentSuite.setAttribute(XmlConstants.ATTR_AST_NODE_COVERAGE, nodeCoverageString); + if (!coverageReport.unencounteredNodes().isEmpty()) { + currentSuite.setAttribute( + XmlConstants.ATTR_INTERESTING_UNENCOUNTERED_NODES, + String.join("\n", coverageReport.unencounteredNodes())); + } + // Branch coverage + double branchCoverage = 0.0; + if (coverageReport.branches() > 0) { + branchCoverage = + (double) coverageReport.coveredBooleanOutcomes() + / (double) coverageReport.branches() + * 100.0; + } + String branchCoverageString = + String.format( + "%.2f%% (%d out of %d branch outcomes covered)", + branchCoverage, coverageReport.coveredBooleanOutcomes(), coverageReport.branches()); + currentSuite.setAttribute(XmlConstants.ATTR_AST_BRANCH_COVERAGE, branchCoverageString); + if (!coverageReport.unencounteredBranches().isEmpty()) { + currentSuite.setAttribute( + XmlConstants.ATTR_INTERESTING_UNENCOUNTERED_BRANCH_PATHS, + String.join("\n", coverageReport.unencounteredBranches())); + } + currentSuite.setAttribute( + XmlConstants.ATTR_CEL_TEST_COVERAGE_GRAPH_URL, coverageReport.graphUrl()); + } + } + + /** Description of a test suite execution. */ + static interface TestContext { + String getSuiteName(); + + long getEndTime(); + + long getStartTime(); + } + + /** Description of a single test result. */ + static interface TestResult { + String getTestClassName(); + + String getName(); + + long getStartMillis(); + + long getEndMillis(); + + Throwable getThrowable(); + + int getStatus(); + + public static int FAILURE = 0; + public static int SUCCESS = 1; + } + + /** Elements and attributes for JUnit-style XML doc. */ + private static final class XmlConstants { + static final String TESTSUITE = "testsuite"; + static final String TESTCASE = "testcase"; + static final String FAILURE = "failure"; + static final String ATTR_NAME = "name"; + static final String ATTR_TIME = "time"; + static final String ATTR_ERRORS = "errors"; + static final String ATTR_FAILURES = "failures"; + static final String ATTR_TESTS = "tests"; + static final String ATTR_TYPE = "type"; + static final String ATTR_MESSAGE = "message"; + static final String ATTR_CLASSNAME = "classname"; + // Coverage attributes. + static final String ATTR_CEL_EXPR = "Cel_Expr"; + static final String ATTR_CEL_COVERAGE = "Cel_Coverage"; + static final String ATTR_AST_NODE_COVERAGE = "Ast_Node_Coverage"; + static final String ATTR_INTERESTING_UNENCOUNTERED_NODES = "Interesting_Unencountered_Nodes"; + static final String ATTR_AST_BRANCH_COVERAGE = "Ast_Branch_Coverage"; + static final String ATTR_INTERESTING_UNENCOUNTERED_BRANCH_PATHS = + "Interesting_Unencountered_Branch_Paths"; + static final String ATTR_CEL_TEST_COVERAGE_GRAPH_URL = "Cel_Test_Coverage_Graph_URL"; + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/RegistryUtils.java b/testing/src/main/java/dev/cel/testing/testrunner/RegistryUtils.java new file mode 100644 index 000000000..a10904abb --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/RegistryUtils.java @@ -0,0 +1,52 @@ +// Copyright 2025 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.testing.testrunner; + + + +import com.google.protobuf.Descriptors.FieldDescriptor; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.Message; +import com.google.protobuf.TypeRegistry; +import dev.cel.common.CelDescriptors; + +/** Utility class for creating registries from a file descriptor set. */ +public final class RegistryUtils { + + /** Returns the {@link TypeRegistry} for the given file descriptor set. */ + public static TypeRegistry getTypeRegistry(CelDescriptors descriptors) { + return TypeRegistry.newBuilder().add(descriptors.messageTypeDescriptors()).build(); + } + + /** Returns the {@link ExtensionRegistry} for the given file descriptor set. */ + public static ExtensionRegistry getExtensionRegistry(CelDescriptors descriptors) { + ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance(); + + descriptors + .extensionDescriptors() + .forEach( + (descriptorName, descriptor) -> { + if (descriptor.getType().equals(FieldDescriptor.Type.MESSAGE)) { + Message output = DynamicMessage.getDefaultInstance(descriptor.getMessageType()); + extensionRegistry.add(descriptor, output); + } else { + extensionRegistry.add(descriptor); + } + }); + return extensionRegistry; + } + + private RegistryUtils() {} +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/ResultMatcher.java b/testing/src/main/java/dev/cel/testing/testrunner/ResultMatcher.java new file mode 100644 index 000000000..927cc3987 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/ResultMatcher.java @@ -0,0 +1,89 @@ +// Copyright 2025 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.testing.testrunner; + +import dev.cel.expr.ExprValue; +import com.google.auto.value.AutoOneOf; +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import dev.cel.bundle.Cel; +import dev.cel.common.types.CelType; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase.Output; +import java.util.Optional; + +/** Custom result matcher for performing assertions on the result of a CEL test case. */ +public interface ResultMatcher { + + /** Parameters for the result matcher. */ + @AutoValue + public abstract class ResultMatcherParams { + public abstract Optional expectedOutput(); + + public abstract ComputedOutput computedOutput(); + + /** Computed output of the CEL test case. */ + @AutoOneOf(ComputedOutput.Kind.class) + public abstract static class ComputedOutput { + /** Kind of the computed output. */ + public enum Kind { + EXPR_VALUE, + ERROR, + UNKNOWN_SET, + } + + public abstract Kind kind(); + + public abstract ExprValue exprValue(); + + public abstract CelEvaluationException error(); + + public abstract ImmutableList unknownSet(); + + public static ComputedOutput ofExprValue(ExprValue exprValue) { + return AutoOneOf_ResultMatcher_ResultMatcherParams_ComputedOutput.exprValue(exprValue); + } + + public static ComputedOutput ofError(CelEvaluationException error) { + return AutoOneOf_ResultMatcher_ResultMatcherParams_ComputedOutput.error(error); + } + + public static ComputedOutput ofUnknownSet(ImmutableList unknownSet) { + return AutoOneOf_ResultMatcher_ResultMatcherParams_ComputedOutput.unknownSet(unknownSet); + } + } + + public abstract CelType resultType(); + + public abstract Builder toBuilder(); + + public static Builder newBuilder() { + return new AutoValue_ResultMatcher_ResultMatcherParams.Builder(); + } + + /** Builder for {@link ResultMatcherParams}. */ + @AutoValue.Builder + public abstract static class Builder { + public abstract Builder setExpectedOutput(Optional result); + + public abstract Builder setResultType(CelType resultType); + + public abstract Builder setComputedOutput(ComputedOutput computedOutput); + + public abstract ResultMatcherParams build(); + } + } + + void match(ResultMatcherParams params, Cel cel) throws Exception; +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/TestExecutor.java b/testing/src/main/java/dev/cel/testing/testrunner/TestExecutor.java new file mode 100644 index 000000000..181d99c6f --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/TestExecutor.java @@ -0,0 +1,302 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.collect.MoreCollectors.onlyElement; +import static dev.cel.testing.utils.ClassLoaderUtils.loadClassesWithMethodAnnotation; +import static dev.cel.testing.utils.ClassLoaderUtils.loadSubclasses; +import static java.nio.charset.StandardCharsets.UTF_8; +import static java.time.ZoneId.systemDefault; + +import com.google.common.io.Files; +import dev.cel.testing.testrunner.Annotations.TestSuiteSupplier; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase; +import io.github.classgraph.ClassInfoList; +import java.io.File; +import java.io.IOException; +import java.lang.reflect.Method; +import java.time.Instant; +import java.time.LocalDate; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.Arrays; +import org.junit.runner.Description; +import org.junit.runner.JUnitCore; +import org.junit.runner.Request; +import org.junit.runner.Result; +import org.junit.runner.Runner; +import org.junit.runner.manipulation.Filter; +import org.junit.runners.model.TestClass; +import org.junit.runners.parameterized.BlockJUnit4ClassRunnerWithParametersFactory; +import org.junit.runners.parameterized.ParametersRunnerFactory; +import org.junit.runners.parameterized.TestWithParameters; + +/** Test executor for running tests using custom runner. */ +public final class TestExecutor { + + private TestExecutor() {} + + private static final Class CEL_TESTSUITE_ANNOTATION_CLASS = TestSuiteSupplier.class; + + private static CelTestSuite readTestSuite(String testSuitePath) + throws IOException, CelTestSuiteException { + switch (testSuitePath.substring(testSuitePath.lastIndexOf(".") + 1)) { + case "textproto": + return CelTestSuiteTextProtoParser.newInstance() + .parse(Files.asCharSource(new File(testSuitePath), UTF_8).read()); + case "yaml": + return CelTestSuiteYamlParser.newInstance() + .parse(Files.asCharSource(new File(testSuitePath), UTF_8).read()); + default: + throw new IllegalArgumentException( + "Unsupported test suite file type: " + testSuitePath); + } + } + + private static class TestContext implements JUnitXmlReporter.TestContext { + + final LocalDate startDate; + LocalDate endDate; + + TestContext() { + startDate = Instant.now().atZone(systemDefault()).toLocalDate(); + } + + @Override + public long getEndTime() { + return endDate.atStartOfDay().toInstant(ZoneOffset.UTC).toEpochMilli(); + } + + @Override + public long getStartTime() { + return startDate.atStartOfDay().toInstant(ZoneOffset.UTC).toEpochMilli(); + } + + @Override + public String getSuiteName() { + return "test_suite"; + } + + void done() { + endDate = Instant.now().atZone(systemDefault()).toLocalDate(); + } + } + + private static class TestResult implements JUnitXmlReporter.TestResult { + + long endMillis; + + long startMillis; + + int status; + + final String testName; + + Throwable throwable; + + final String testClassName; + + TestResult(String testName, String testClassName) { + this.testName = testName; + this.startMillis = Instant.now().toEpochMilli(); + this.testClassName = testClassName; + } + + @Override + public String getTestClassName() { + return testClassName; + } + + @Override + public long getEndMillis() { + return endMillis; + } + + @Override + public String getName() { + return testName; + } + + @Override + public long getStartMillis() { + return startMillis; + } + + @Override + public int getStatus() { + return status; + } + + @Override + public Throwable getThrowable() { + return throwable; + } + + private void setEndMillis(long endMillis) { + this.endMillis = endMillis; + } + + private void setStatus(int status) { + this.status = status; + } + + private void setThrowable(Throwable throwable) { + this.throwable = throwable; + } + + private void setStartMillis(long startMillis) { + this.startMillis = startMillis; + } + } + + /** Runs test cases for a given test class and test suite. */ + public static void runTests() throws Exception { + String testSuitePath = System.getProperty("test_suite_path"); + + CelTestSuite testSuite; + testSuite = readCustomTestSuite(); + + if (testSuitePath != null) { + if (testSuite != null) { + throw new IllegalArgumentException( + "Both test_suite_path and TestSuiteSupplier are set. Only one of them can be set."); + } else { + testSuite = readTestSuite(testSuitePath); + } + } else if (testSuite == null) { + throw new IllegalArgumentException("Neither test_suite_path nor TestSuiteSupplier is set."); + } + + Class testClass = getUserTestClass(); + String envXmlFile = System.getenv("XML_OUTPUT_FILE"); + JUnitXmlReporter testReporter = new JUnitXmlReporter(envXmlFile); + TestContext testContext = new TestContext(); + testReporter.onStart(testContext); + + boolean allTestsPassed = true; + CelCoverageIndex celCoverageIndex = null; + // If coverage is enabled, the celCoverageIndex parameter will be added in the test class. + // This will be used to run the test case multiple times with different inputs and collect + // the coverage data. + String isCoverageEnabled = System.getProperty("is_coverage_enabled"); + if (isCoverageEnabled != null && Boolean.parseBoolean(isCoverageEnabled)) { + celCoverageIndex = new CelCoverageIndex(); + } + + for (CelTestSection testSection : testSuite.sections()) { + for (CelTestCase testCase : testSection.tests()) { + String testName = testSection.name() + "." + testCase.name(); + ArrayList parameter = new ArrayList<>(Arrays.asList(testCase, celCoverageIndex)); + TestWithParameters test = + new TestWithParameters(testName, new TestClass(testClass), parameter); + + TestResult testResult = new TestResult(testName, testClass.getName()); + testReporter.onTestStart(testResult); + testResult.setStartMillis(Instant.now().toEpochMilli()); + + ParametersRunnerFactory factory = new BlockJUnit4ClassRunnerWithParametersFactory(); + Runner runner = factory.createRunnerForTestWithParameters(test); + + JUnitCore junitCore = new JUnitCore(); + Request request = + Request.runner(runner) + .filterWith( + new Filter() { + @Override + public boolean shouldRun(Description description) { + return true; + } + + @Override + public String describe() { + return "Filter to run only test method"; + } + }); + Result result = junitCore.run(request); + testResult.setEndMillis(Instant.now().toEpochMilli()); + + if (result.wasSuccessful()) { + testResult.setStatus(JUnitXmlReporter.TestResult.SUCCESS); + testReporter.onTestSuccess(testResult); + } else { + allTestsPassed = false; + testResult.setStatus(JUnitXmlReporter.TestResult.FAILURE); + testResult.setThrowable(result.getFailures().get(0).getException()); + testReporter.onTestFailure(testResult); + System.err.println("Test failed: " + testName); + result.getFailures().forEach(failure -> failure.getException().printStackTrace()); + } + } + } + + testContext.done(); + if (celCoverageIndex != null) { + CelCoverageIndex.CoverageReport report = celCoverageIndex.generateCoverageReport(); + testReporter.onFinish(report); + } else { + testReporter.onFinish(); + } + if (!allTestsPassed) { + throw new RuntimeException(testReporter.getNumFailed() + " tests failed"); + } + } + + private static CelTestSuite readCustomTestSuite() throws Exception { + ClassInfoList classInfoList = + loadClassesWithMethodAnnotation(CEL_TESTSUITE_ANNOTATION_CLASS.getName()); + if (classInfoList.isEmpty()) { + return null; + } + if (classInfoList.size() > 1) { + throw new IllegalArgumentException( + "Expected 1 class for TestSuiteSupplier, but got " + + classInfoList.size() + + " classes: " + + classInfoList); + } + Class customFunctionClass = classInfoList.loadClasses().get(0); + Method method = getMethodWithAnnotation(customFunctionClass); + return (CelTestSuite) method.invoke(customFunctionClass.getDeclaredConstructor().newInstance()); + } + + private static Method getMethodWithAnnotation(Class clazz) { + Method testSuiteSupplierMethod = + Arrays.asList(clazz.getDeclaredMethods()).stream() + .filter(method -> method.isAnnotationPresent(TestSuiteSupplier.class)) + .collect(onlyElement()); + + if (!testSuiteSupplierMethod.getReturnType().equals(CelTestSuite.class)) { + throw new IllegalArgumentException( + String.format( + "Method: %s annotated with @TestSuiteSupplier must return CelTestSuite, but got %s", + testSuiteSupplierMethod.getName(), testSuiteSupplierMethod.getReturnType())); + } + return testSuiteSupplierMethod; + } + + private static Class getUserTestClass() { + ClassInfoList subClassInfoList = loadSubclasses(CelUserTestTemplate.class); + if (subClassInfoList.size() != 1) { + throw new IllegalArgumentException( + "Expected 1 subclass for CelUserTestTemplate, but got " + + subClassInfoList.size() + + " subclasses: " + + subClassInfoList); + } + + return subClassInfoList.loadClasses().get(0); + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/TestRunnerBinary.java b/testing/src/main/java/dev/cel/testing/testrunner/TestRunnerBinary.java new file mode 100644 index 000000000..220609ae8 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/TestRunnerBinary.java @@ -0,0 +1,26 @@ +// Copyright 2025 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.testing.testrunner; + +/** Main class for the CEL test runner. */ +public final class TestRunnerBinary { + + private TestRunnerBinary() {} + + public static void main(String[] args) throws Exception { + // NOMUTANTS -- To be fixed in b/394771693. Since no assertions result in false positive. + TestExecutor.runTests(); + } +} diff --git a/testing/src/main/java/dev/cel/testing/testrunner/TestRunnerLibrary.java b/testing/src/main/java/dev/cel/testing/testrunner/TestRunnerLibrary.java new file mode 100644 index 000000000..1d3e49fbe --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/testrunner/TestRunnerLibrary.java @@ -0,0 +1,447 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.io.Files.asCharSource; +import static dev.cel.testing.utils.ExprValueUtils.fromValue; +import static dev.cel.testing.utils.ExprValueUtils.toExprValue; +import static java.nio.charset.StandardCharsets.UTF_8; +import static java.nio.file.Files.readAllBytes; + +import dev.cel.expr.CheckedExpr; +import dev.cel.expr.ExprValue; +import dev.cel.expr.Value; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Any; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.Message; +import com.google.protobuf.TextFormat; +import com.google.protobuf.TypeRegistry; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelEnvironment; +import dev.cel.bundle.CelEnvironment.ExtensionConfig; +import dev.cel.bundle.CelEnvironmentYamlParser; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import dev.cel.common.CelOptions; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.common.CelValidationException; +import dev.cel.policy.CelPolicy; +import dev.cel.policy.CelPolicyCompilerFactory; +import dev.cel.policy.CelPolicyParser; +import dev.cel.policy.CelPolicyParserFactory; +import dev.cel.policy.CelPolicyValidationException; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelRuntime.Program; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase.Input.Binding; +import dev.cel.testing.testrunner.ResultMatcher.ResultMatcherParams; +import java.io.File; +import java.io.IOException; +import java.nio.file.Paths; +import java.util.Map; +import java.util.Optional; +import java.util.logging.Logger; +import org.jspecify.annotations.Nullable; + +/** Runner library for creating the environment and running the assertions. */ +public final class TestRunnerLibrary { + TestRunnerLibrary() {} + + private static final Logger logger = Logger.getLogger(TestRunnerLibrary.class.getName()); + + /** + * Run the assertions for a given raw/checked expression test case. + * + * @param testCase The test case to run. + * @param celTestContext The test context containing the {@link Cel} bundle and other + * configurations. + */ + public static void runTest(CelTestCase testCase, CelTestContext celTestContext) throws Exception { + if (celTestContext.celExpression().isPresent()) { + evaluateTestCase(testCase, celTestContext); + } else { + throw new IllegalArgumentException("No cel expression provided."); + } + } + + /** + * Run the assertions for a given raw/checked expression test case with coverage enabled. + * + *

This method is used for generating coverage data. It will be used to run the test case + * multiple times with different inputs and collect the coverage data. + * + * @param testCase The test case to run. + * @param celTestContext The test context containing the {@link Cel} bundle and other + * configurations. + * @param celCoverageIndex The coverage index to use for the test case. + */ + public static void runTest( + CelTestCase testCase, + CelTestContext celTestContext, + @Nullable CelCoverageIndex celCoverageIndex) + throws Exception { + if (celTestContext.celExpression().isPresent()) { + evaluateTestCase(testCase, celTestContext, celCoverageIndex); + } else { + throw new IllegalArgumentException("No cel expression provided."); + } + } + + /** Runs the test with the provided AST. */ + public static void runTest( + CelAbstractSyntaxTree ast, CelTestCase testCase, CelTestContext celTestContext) + throws Exception { + evaluate(ast, testCase, celTestContext, /* celCoverageIndex= */ null); + } + + @VisibleForTesting + static void evaluateTestCase(CelTestCase testCase, CelTestContext celTestContext) + throws Exception { + evaluateTestCase(testCase, celTestContext, /* celCoverageIndex= */ null); + } + + static void evaluateTestCase( + CelTestCase testCase, + CelTestContext celTestContext, + @Nullable CelCoverageIndex celCoverageIndex) + throws Exception { + celTestContext = extendCelTestContext(celTestContext); + CelAbstractSyntaxTree ast; + CelExpressionSource celExpressionSource = celTestContext.celExpression().get(); + switch (celExpressionSource.type()) { + case POLICY: + ast = + compilePolicy( + celTestContext.cel(), + celTestContext.celPolicyParser().get(), + readFile(celExpressionSource.value())); + break; + case TEXTPROTO: + case BINARYPB: + ast = readAstFromCheckedExpression(celExpressionSource); + break; + case CEL: + ast = celTestContext.cel().compile(readFile(celExpressionSource.value())).getAst(); + break; + case RAW_EXPR: + ast = celTestContext.cel().compile(celExpressionSource.value()).getAst(); + break; + default: + throw new IllegalArgumentException( + "Unsupported expression type: " + celExpressionSource.type()); + } + if (celCoverageIndex != null) { + celCoverageIndex.init(ast); + } + evaluate(ast, testCase, celTestContext, celCoverageIndex); + } + + private static CelAbstractSyntaxTree readAstFromCheckedExpression( + CelExpressionSource celExpressionSource) throws IOException { + switch (celExpressionSource.type()) { + case BINARYPB: + byte[] bytes = readAllBytes(Paths.get(celExpressionSource.value())); + CheckedExpr checkedExpr = + CheckedExpr.parseFrom(bytes, ExtensionRegistry.getEmptyRegistry()); + return CelProtoAbstractSyntaxTree.fromCheckedExpr(checkedExpr).getAst(); + case TEXTPROTO: + String content = readFile(celExpressionSource.value()); + CheckedExpr.Builder builder = CheckedExpr.newBuilder(); + TextFormat.merge(content, builder); + return CelProtoAbstractSyntaxTree.fromCheckedExpr(builder.build()).getAst(); + default: + throw new IllegalArgumentException( + "Unsupported expression type: " + celExpressionSource.type()); + } + } + + private static CelTestContext extendCelTestContext(CelTestContext celTestContext) + throws Exception { + CelOptions celOptions = celTestContext.celOptions(); + CelTestContext.Builder celTestContextBuilder = + celTestContext.toBuilder().setCel(extendCel(celTestContext, celOptions)); + if (celTestContext + .celExpression() + .get() + .type() + .equals(CelExpressionSource.ExpressionSourceType.POLICY)) { + celTestContextBuilder.setCelPolicyParser( + celTestContext + .celPolicyParser() + .orElse(CelPolicyParserFactory.newYamlParserBuilder().build())); + } + + return celTestContextBuilder.build(); + } + + private static Cel extendCel(CelTestContext celTestContext, CelOptions celOptions) + throws Exception { + Cel extendedCel = celTestContext.cel(); + + // Add the file descriptor set to the cel object if provided. + // + // Note: This needs to be added first because the config file may contain type information + // regarding proto messages that need to be added to the cel object. + CelDescriptors descriptors = celTestContext.celDescriptors().orElse(null); + if (descriptors != null) { + extendedCel = + extendedCel + .toCelBuilder() + .addMessageTypes(descriptors.messageTypeDescriptors()) + .setExtensionRegistry(RegistryUtils.getExtensionRegistry(descriptors)) + .build(); + } + + if (!celTestContext.fileTypes().isEmpty()) { + extendedCel = + extendedCel + .toCelBuilder() + .addMessageTypes( + CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(celTestContext.fileTypes()) + .messageTypeDescriptors()) + .build(); + } + + CelEnvironment environment = CelEnvironment.newBuilder().build(); + + // Extend the cel object with the config file if provided. + if (celTestContext.configFile().isPresent()) { + String configContent = readFile(celTestContext.configFile().get()); + environment = CelEnvironmentYamlParser.newInstance().parse(configContent); + } + + // Policy compiler requires optional support. Add the optional library by default to the + // environment. + return environment.toBuilder() + .addExtensions(ExtensionConfig.of("optional")) + .build() + .extend(extendedCel, celOptions); + } + + private static String readFile(String path) throws IOException { + return asCharSource(new File(path), UTF_8).read(); + } + + private static CelAbstractSyntaxTree compilePolicy( + Cel cel, CelPolicyParser celPolicyParser, String policyContent) + throws CelPolicyValidationException { + CelPolicy celPolicy = celPolicyParser.parse(policyContent); + return CelPolicyCompilerFactory.newPolicyCompiler(cel).build().compile(celPolicy); + } + + private static void evaluate( + CelAbstractSyntaxTree ast, + CelTestCase testCase, + CelTestContext celTestContext, + @Nullable CelCoverageIndex celCoverageIndex) + throws Exception { + Cel cel = celTestContext.cel(); + Program program = cel.createProgram(ast); + ExprValue exprValue = null; + CelEvaluationException error = null; + Object evaluationResult = null; + try { + evaluationResult = getEvaluationResult(testCase, celTestContext, program, celCoverageIndex); + exprValue = toExprValue(evaluationResult, ast.getResultType()); + } catch (CelEvaluationException e) { + String errorMessage = + String.format( + "Evaluation failed for test case: %s. Error: %s", testCase.name(), e.getMessage()); + error = new CelEvaluationException(errorMessage, e); + logger.severe(e.toString()); + } + + // Perform the assertion on the result of the evaluation. + ResultMatcherParams.Builder paramsBuilder = + ResultMatcherParams.newBuilder() + .setExpectedOutput(Optional.ofNullable(testCase.output())) + .setResultType(ast.getResultType()); + + if (error != null) { + paramsBuilder.setComputedOutput(ResultMatcherParams.ComputedOutput.ofError(error)); + } else { + switch (exprValue.getKindCase()) { + case VALUE: + paramsBuilder.setComputedOutput( + ResultMatcherParams.ComputedOutput.ofExprValue(exprValue)); + break; + case UNKNOWN: + paramsBuilder.setComputedOutput( + ResultMatcherParams.ComputedOutput.ofUnknownSet( + ImmutableList.copyOf(exprValue.getUnknown().getExprsList()))); + break; + default: + throw new IllegalArgumentException( + String.format("Unexpected result type: %s", exprValue.getKindCase())); + } + } + + celTestContext.resultMatcher().match(paramsBuilder.build(), cel); + } + + private static Object getEvaluationResult( + CelTestCase testCase, + CelTestContext celTestContext, + Program program, + @Nullable CelCoverageIndex celCoverageIndex) + throws CelEvaluationException, IOException, CelValidationException { + if (celTestContext.celLateFunctionBindings().isPresent()) { + return program.eval( + getBindings(testCase, celTestContext), celTestContext.celLateFunctionBindings().get()); + } + switch (testCase.input().kind()) { + case CONTEXT_MESSAGE: + return getEvaluationResultWithMessage( + unpackAny(testCase.input().contextMessage(), celTestContext), + program, + celCoverageIndex); + case CONTEXT_EXPR: + return getEvaluationResultWithMessage( + getEvaluatedContextExpr(testCase, celTestContext), program, celCoverageIndex); + case BINDINGS: + ImmutableMap bindings = getBindings(testCase, celTestContext); + if (celTestContext.bindingTransformer().isPresent()) { + try { + bindings = celTestContext.bindingTransformer().get().transform(bindings); + } catch (Exception e) { + throw new CelEvaluationException("Binding transformation failed: " + e.getMessage(), e); + } + } + return getEvaluationResultWithBindings(bindings, program, celCoverageIndex); + case NO_INPUT: + ImmutableMap.Builder newBindings = ImmutableMap.builder(); + for (Map.Entry entry : celTestContext.variableBindings().entrySet()) { + if (entry.getValue() instanceof Any) { + newBindings.put(entry.getKey(), unpackAny((Any) entry.getValue(), celTestContext)); + } else { + newBindings.put(entry); + } + } + return getEvaluationResultWithBindings( + newBindings.buildOrThrow(), program, celCoverageIndex); + } + throw new IllegalArgumentException("Unexpected input type: " + testCase.input().kind()); + } + + private static Object getEvaluationResultWithBindings( + Map bindings, Program program, @Nullable CelCoverageIndex celCoverageIndex) + throws CelEvaluationException { + if (celCoverageIndex != null) { + return program.trace(bindings, celCoverageIndex.newEvaluationListener()); + } + return program.eval(bindings); + } + + private static Object getEvaluationResultWithMessage( + Message message, Program program, @Nullable CelCoverageIndex celCoverageIndex) + throws CelEvaluationException { + if (celCoverageIndex != null) { + return program.trace(message, celCoverageIndex.newEvaluationListener()); + } + return program.eval(message); + } + + private static Message unpackAny(Any any, CelTestContext celTestContext) throws IOException { + TypeRegistry typeRegistry = + celTestContext + .typeRegistry() + .orElseThrow( + () -> + new IllegalArgumentException( + "Proto descriptors or type registry are required for unpacking Any" + + " messages.")); + + Descriptor descriptor = typeRegistry.getDescriptorForTypeUrl(any.getTypeUrl()); + if (descriptor == null) { + throw new IllegalArgumentException("Descriptor not found for type URL: " + any.getTypeUrl()); + } + + ExtensionRegistry extensionRegistry = + celTestContext + .extensionRegistry() + .orElseGet( + () -> + celTestContext + .mergedDescriptors() + .map(RegistryUtils::getExtensionRegistry) + .orElseGet(ExtensionRegistry::getEmptyRegistry)); + + return DynamicMessage.getDefaultInstance(descriptor) + .getParserForType() + .parseFrom(any.getValue(), extensionRegistry); + } + + private static Message getEvaluatedContextExpr( + CelTestCase testCase, CelTestContext celTestContext) + throws CelEvaluationException, CelValidationException { + try { + return (Message) evaluateInput(celTestContext.cel(), testCase.input().contextExpr()); + } catch (ClassCastException e) { + throw new IllegalArgumentException("Context expression must evaluate to a proto message.", e); + } + } + + private static ImmutableMap getBindings( + CelTestCase testCase, CelTestContext celTestContext) + throws IOException, CelEvaluationException, CelValidationException { + Cel cel = celTestContext.cel(); + ImmutableMap.Builder inputBuilder = ImmutableMap.builder(); + for (Map.Entry entry : testCase.input().bindings().entrySet()) { + if (entry.getValue().kind().equals(Binding.Kind.EXPR)) { + inputBuilder.put(entry.getKey(), evaluateInput(cel, entry.getValue().expr())); + } else { + inputBuilder.put( + entry.getKey(), getValueFromBinding(entry.getValue().value(), celTestContext)); + } + } + return inputBuilder.buildOrThrow(); + } + + private static Object evaluateInput(Cel cel, String expr) + throws CelEvaluationException, CelValidationException { + CelAbstractSyntaxTree exprInputAst = cel.compile(expr).getAst(); + return cel.createProgram(exprInputAst).eval(); + } + + private static Object getValueFromBinding(Object value, CelTestContext celTestContext) + throws IOException { + if (value instanceof Value) { + if (celTestContext.typeRegistry().isPresent() + || celTestContext.extensionRegistry().isPresent()) { + if (celTestContext.typeRegistry().isPresent()) { + ExtensionRegistry extensionRegistry = + celTestContext.extensionRegistry().orElse(ExtensionRegistry.getEmptyRegistry()); + return fromValue((Value) value, celTestContext.typeRegistry().get(), extensionRegistry); + } else if (celTestContext.extensionRegistry().isPresent()) { + return fromValue( + (Value) value, + TypeRegistry.newBuilder().build(), + celTestContext.extensionRegistry().get()); + } else if (celTestContext.fileDescriptorSetPath().isPresent()) { + return fromValue((Value) value, celTestContext.fileDescriptorSetPath().get()); + } + } + return fromValue( + (Value) value, TypeRegistry.newBuilder().build(), ExtensionRegistry.getEmptyRegistry()); + } + return value; + } +} diff --git a/testing/src/main/java/dev/cel/testing/utils/BUILD.bazel b/testing/src/main/java/dev/cel/testing/utils/BUILD.bazel new file mode 100644 index 000000000..eea56752d --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/utils/BUILD.bazel @@ -0,0 +1,54 @@ +load("@rules_java//java:java_library.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = [ + "//testing:__pkg__", + "//testing/testrunner:__pkg__", + ], +) + +java_library( + name = "expr_value_utils", + srcs = ["ExprValueUtils.java"], + tags = [ + ], + deps = [ + "//common:cel_descriptors", + "//common/internal:proto_time_utils", + "//common/types", + "//common/types:type_providers", + "//common/values", + "//common/values:cel_byte_string", + "//runtime:unknown_attributes", + "//testing:proto_descriptor_utils", + "//testing/testrunner:registry_utils", + "@cel_spec//proto/cel/expr:expr_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +java_library( + name = "class_loader_utils", + srcs = ["ClassLoaderUtils.java"], + tags = [ + ], + deps = [ + "@maven//:com_google_guava_guava", + "@maven//:io_github_classgraph_classgraph", + ], +) + +java_library( + name = "proto_descriptor_utils", + srcs = ["ProtoDescriptorUtils.java"], + deps = [ + "//common:cel_descriptor_util", + "//common:cel_descriptors", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + ], +) diff --git a/testing/src/main/java/dev/cel/testing/utils/ClassLoaderUtils.java b/testing/src/main/java/dev/cel/testing/utils/ClassLoaderUtils.java new file mode 100644 index 000000000..31f45d48f --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/utils/ClassLoaderUtils.java @@ -0,0 +1,52 @@ +// Copyright 2025 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.testing.utils; + +import com.google.common.base.Supplier; +import com.google.common.base.Suppliers; +import io.github.classgraph.ClassGraph; +import io.github.classgraph.ClassInfo; +import io.github.classgraph.ClassInfoList; +import io.github.classgraph.ScanResult; + +/** Utility class for loading classes using {@link ClassGraph}. */ +public final class ClassLoaderUtils { + + // Using `enableAllInfo()` to scan all class files upfront. This avoids repeated parsing + // of class files by individual methods, improving efficiency. + private static final Supplier CLASS_SCAN_RESULT = + Suppliers.memoize(() -> new ClassGraph().enableAllInfo().scan()); + + /** + * Loads all subclasses of the given class from the JVM. + * + * @param clazz The class to load subclasses for. + * @return A list of {@link ClassInfo} objects representing the subclasses. + */ + public static ClassInfoList loadSubclasses(Class clazz) { + return CLASS_SCAN_RESULT.get().getSubclasses(clazz.getName()); + } + + /** + * Loads all classes with the given method annotation from the JVM. + * + * @param annotationName The name of the annotation to load classes with. + * @return A list of {@link ClassInfo} objects representing the classes with the annotation. + */ + public static ClassInfoList loadClassesWithMethodAnnotation(String annotationName) { + return CLASS_SCAN_RESULT.get().getClassesWithMethodAnnotation(annotationName); + } + + private ClassLoaderUtils() {} +} diff --git a/testing/src/main/java/dev/cel/testing/utils/ExprValueUtils.java b/testing/src/main/java/dev/cel/testing/utils/ExprValueUtils.java new file mode 100644 index 000000000..10ab52786 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/utils/ExprValueUtils.java @@ -0,0 +1,300 @@ +// Copyright 2025 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.testing.utils; + +import dev.cel.expr.ExprValue; +import dev.cel.expr.ListValue; +import dev.cel.expr.MapValue; +import dev.cel.expr.UnknownSet; +import dev.cel.expr.Value; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.primitives.UnsignedLong; +import com.google.protobuf.Any; +import com.google.protobuf.ByteString; +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.DynamicMessage; +import com.google.protobuf.ExtensionRegistry; +import com.google.protobuf.Message; +import com.google.protobuf.NullValue; +import com.google.protobuf.TypeRegistry; +import dev.cel.common.CelDescriptors; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.types.CelType; +import dev.cel.common.types.ListType; +import dev.cel.common.types.MapType; +import dev.cel.common.types.OptionalType; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeType; +import dev.cel.common.values.CelByteString; +import dev.cel.runtime.CelUnknownSet; +import dev.cel.testing.testrunner.RegistryUtils; +import java.io.IOException; +import java.time.Duration; +import java.time.Instant; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** Utility class for ExprValue and Value type conversions during test execution. */ +@SuppressWarnings({"UnnecessarilyFullyQualified"}) +public final class ExprValueUtils { + + private ExprValueUtils() {} + + /** + * Converts a {@link Value} to a Java native object using the given file descriptor set to parse + * `Any` messages. + * + * @param value The {@link Value} to convert. + * @return The converted Java object. + * @throws IOException If there's an error during conversion. + */ + public static Object fromValue(Value value, CelDescriptors descriptors) throws IOException { + TypeRegistry typeRegistry = RegistryUtils.getTypeRegistry(descriptors); + ExtensionRegistry extensionRegistry = RegistryUtils.getExtensionRegistry(descriptors); + return fromValue(value, typeRegistry, extensionRegistry); + } + + public static Object fromValue(Value value, String fileDescriptorSetPath) throws IOException { + return fromValue(value, ProtoDescriptorUtils.getDescriptorsFromFile(fileDescriptorSetPath)); + } + + /** + * Converts a {@link Value} to a Java native object using custom registries. + * + * @param value The {@link Value} to convert. + * @param typeRegistry The type registry to use for object resolution. + * @param extensionRegistry The extension registry to use for object resolution. + * @return The converted Java object. + * @throws IOException If there's an error during conversion. + */ + public static Object fromValue( + Value value, TypeRegistry typeRegistry, ExtensionRegistry extensionRegistry) + throws IOException { + if (value.getKindCase().equals(Value.KindCase.OBJECT_VALUE)) { + Descriptor descriptor = + typeRegistry.getDescriptorForTypeUrl(value.getObjectValue().getTypeUrl()); + if (descriptor == null) { + throw new IOException( + "Unknown type, descriptor was not found in registry: " + + value.getObjectValue().getTypeUrl()); + } + Message prototype = DynamicMessage.getDefaultInstance(descriptor); + return prototype + .getParserForType() + .parseFrom(value.getObjectValue().getValue(), extensionRegistry); + } + return toNativeObject(value, typeRegistry, extensionRegistry); + } + + private static Object toNativeObject( + Value value, TypeRegistry typeRegistry, ExtensionRegistry extensionRegistry) + throws IOException { + switch (value.getKindCase()) { + case NULL_VALUE: + return dev.cel.common.values.NullValue.NULL_VALUE; + case BOOL_VALUE: + return value.getBoolValue(); + case INT64_VALUE: + return value.getInt64Value(); + case UINT64_VALUE: + return UnsignedLong.fromLongBits(value.getUint64Value()); + case DOUBLE_VALUE: + return value.getDoubleValue(); + case STRING_VALUE: + return value.getStringValue(); + case BYTES_VALUE: + ByteString byteString = value.getBytesValue(); + return CelByteString.of(byteString.toByteArray()); + case ENUM_VALUE: + return value.getEnumValue(); + case MAP_VALUE: + { + MapValue map = value.getMapValue(); + ImmutableMap.Builder builder = + ImmutableMap.builderWithExpectedSize(map.getEntriesCount()); + for (MapValue.Entry entry : map.getEntriesList()) { + builder.put( + fromValue(entry.getKey(), typeRegistry, extensionRegistry), + fromValue(entry.getValue(), typeRegistry, extensionRegistry)); + } + return builder.buildOrThrow(); + } + case LIST_VALUE: + { + ListValue list = value.getListValue(); + ImmutableList.Builder builder = + ImmutableList.builderWithExpectedSize(list.getValuesCount()); + for (Value element : list.getValuesList()) { + builder.add(fromValue(element, typeRegistry, extensionRegistry)); + } + return builder.build(); + } + case TYPE_VALUE: + return value.getTypeValue(); + default: + throw new IllegalArgumentException( + String.format("Unexpected binding value kind: %s", value.getKindCase())); + } + } + + /** + * Converts a Java object to an {@link ExprValue}. + * + * @param object The Java object to convert. + * @param type The {@link CelType} of the object. + * @return The converted {@link ExprValue}. + * @throws Exception If there's an error during conversion. + */ + public static ExprValue toExprValue(Object object, CelType type) throws Exception { + if (object instanceof ExprValue) { + return (ExprValue) object; + } + if (object instanceof CelUnknownSet) { + return ExprValue.newBuilder().setUnknown(toUnknownSet((CelUnknownSet) object)).build(); + } + return ExprValue.newBuilder().setValue(toValue(object, type)).build(); + } + + public static UnknownSet toUnknownSet(CelUnknownSet unknownSet) { + return UnknownSet.newBuilder().addAllExprs(unknownSet.unknownExprIds()).build(); + } + + /** + * Converts a Java object to an {@link Value}. + * + * @param object The Java object to convert. + * @param type The {@link CelType} of the object. + * @return The converted {@link Value}. + * @throws Exception If there's an error during conversion. + */ + @SuppressWarnings("unchecked") + public static Value toValue(Object object, CelType type) throws Exception { + if (!(object instanceof Optional) && type instanceof OptionalType) { + return toValue(object, type.parameters().get(0)); + } + if (object == null || object.equals(NullValue.NULL_VALUE)) { + object = dev.cel.common.values.NullValue.NULL_VALUE; + } + if (object instanceof dev.cel.expr.Value) { + object = + Value.parseFrom( + ((dev.cel.expr.Value) object).toByteArray(), + ExtensionRegistry.getEmptyRegistry()); + } + if (object instanceof Value) { + return (Value) object; + } + if (object instanceof dev.cel.common.values.NullValue) { + return Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build(); + } + if (object instanceof Boolean) { + return Value.newBuilder().setBoolValue((Boolean) object).build(); + } + if (object instanceof UnsignedLong) { + switch (type.kind()) { + case UINT: + case DYN: + case ANY: + return Value.newBuilder().setUint64Value(((UnsignedLong) object).longValue()).build(); + default: + throw new IllegalArgumentException(String.format("Unexpected result type: %s", type)); + } + } + if (object instanceof Long) { + switch (type.kind()) { + case INT: + case DYN: + case ANY: + return Value.newBuilder().setInt64Value((Long) object).build(); + case UINT: + return Value.newBuilder().setUint64Value((Long) object).build(); + default: + throw new IllegalArgumentException(String.format("Unexpected result type: %s", type)); + } + } + if (object instanceof Double) { + return Value.newBuilder().setDoubleValue((Double) object).build(); + } + if (object instanceof String) { + switch (type.kind()) { + case TYPE: + return Value.newBuilder().setTypeValue((String) object).build(); + case STRING: + case DYN: + case ANY: + return Value.newBuilder().setStringValue((String) object).build(); + default: + throw new IllegalArgumentException(String.format("Unexpected result type: %s", type)); + } + } + if (object instanceof CelByteString) { + return Value.newBuilder() + .setBytesValue(ByteString.copyFrom(((CelByteString) object).toByteArray())) + .build(); + } + if (object instanceof List) { + CelType elemType = type instanceof ListType ? ((ListType) type).elemType() : SimpleType.DYN; + ListValue.Builder builder = ListValue.newBuilder(); + for (Object element : ((List) object)) { + builder.addValues(toValue(element, elemType)); + } + return Value.newBuilder().setListValue(builder.build()).build(); + } + if (object instanceof Map) { + CelType keyType = type instanceof MapType ? ((MapType) type).keyType() : SimpleType.DYN; + CelType valueType = type instanceof MapType ? ((MapType) type).valueType() : SimpleType.DYN; + MapValue.Builder builder = MapValue.newBuilder(); + for (Map.Entry entry : ((Map) object).entrySet()) { + builder.addEntries( + MapValue.Entry.newBuilder() + .setKey(toValue(entry.getKey(), keyType)) + .setValue(toValue(entry.getValue(), valueType)) + .build()); + } + return Value.newBuilder().setMapValue(builder.build()).build(); + } + + if (object instanceof Instant) { + return Value.newBuilder() + .setObjectValue(Any.pack(ProtoTimeUtils.toProtoTimestamp((Instant) object))) + .build(); + } + + if (object instanceof Duration) { + return Value.newBuilder() + .setObjectValue(Any.pack(ProtoTimeUtils.toProtoDuration((Duration) object))) + .build(); + } + + if (object instanceof Message) { + return Value.newBuilder().setObjectValue(Any.pack((Message) object)).build(); + } + if (object instanceof TypeType) { + return Value.newBuilder().setTypeValue(((TypeType) object).containingTypeName()).build(); + } + + if (object instanceof Optional) { + // TODO: Remove this once the ExprValue Native representation is added. + if (!((Optional) object).isPresent()) { + return Value.getDefaultInstance(); + } + return toValue(((Optional) object).get(), type.parameters().get(0)); + } + + throw new IllegalArgumentException( + String.format("Unexpected result type: %s", object.getClass())); + } +} diff --git a/testing/src/main/java/dev/cel/testing/utils/ProtoDescriptorUtils.java b/testing/src/main/java/dev/cel/testing/utils/ProtoDescriptorUtils.java new file mode 100644 index 000000000..880c03e12 --- /dev/null +++ b/testing/src/main/java/dev/cel/testing/utils/ProtoDescriptorUtils.java @@ -0,0 +1,49 @@ +// 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.testing.utils; + +import com.google.common.io.Files; +import com.google.protobuf.DescriptorProtos.FileDescriptorSet; +import com.google.protobuf.ExtensionRegistry; +import dev.cel.common.CelDescriptorUtil; +import dev.cel.common.CelDescriptors; +import java.io.File; +import java.io.IOException; + +/** Utility class for working with proto descriptors. */ +public final class ProtoDescriptorUtils { + + /** + * Returns all the descriptors from the file descriptor set file. + * + * @return The {@link CelDescriptors} object containing all the descriptors. + */ + public static CelDescriptors getDescriptorsFromFile(String fileDescriptorSetPath) + throws IOException { + FileDescriptorSet fileDescriptorSet = getFileDescriptorSet(fileDescriptorSetPath); + return CelDescriptorUtil.getAllDescriptorsFromFileDescriptor( + CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fileDescriptorSet)); + } + + private static FileDescriptorSet getFileDescriptorSet(String fileDescriptorSetPath) + throws IOException { + // We can pass an empty extension registry here because extensions are recovered later when + // creating the extension registry in {@link #createExtensionRegistry}. + return FileDescriptorSet.parseFrom( + Files.toByteArray(new File(fileDescriptorSetPath)), ExtensionRegistry.newInstance()); + } + + private ProtoDescriptorUtils() {} +} diff --git a/testing/src/test/java/dev/cel/testing/BUILD.bazel b/testing/src/test/java/dev/cel/testing/BUILD.bazel new file mode 100644 index 000000000..8fe831bb2 --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/BUILD.bazel @@ -0,0 +1,27 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package(default_applicable_licenses = [ + "//:license", +]) + +java_library( + name = "tests", + testonly = True, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//testing:line_differ", + "@maven//:com_google_guava_guava", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/testing/src/test/java/dev/cel/testing/LineDifferTest.java b/testing/src/test/java/dev/cel/testing/LineDifferTest.java new file mode 100644 index 000000000..b6b36cc6d --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/LineDifferTest.java @@ -0,0 +1,185 @@ +// Copyright 2022 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.testing; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.testing.LineDiffer.diffLines; + +import com.google.common.collect.ImmutableList; +import dev.cel.testing.LineDiffer.Diff; +import dev.cel.testing.LineDiffer.Snippet; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class LineDifferTest { + + @Test + public void emptyStringsDiff_emptyResult() { + assertThat(diffLines("", "").isEmpty()).isTrue(); + } + + @Test + public void nonEmptyAndEmptyStringsDiff_removalDiff() { + Diff actual = diffLines("hello\nworld", ""); + assertThat(actual.isEmpty()).isFalse(); + assertThat(actual) + .isEqualTo( + Diff.of( + ImmutableList.of(), + ImmutableList.of(Snippet.of(1, 2, ImmutableList.of("hello", "world"))))); + + String expectedText = "===== Lines 1-2 =====\n" + "< hello\n" + "< world\n"; + assertThat(actual.toString()).isEqualTo(expectedText); + } + + @Test + public void emptyAndNonEmptyStringsDiff_additionDiff() { + Diff actual = diffLines("", "hello\nworld"); + assertThat(actual.isEmpty()).isFalse(); + assertThat(actual) + .isEqualTo( + Diff.of( + ImmutableList.of(Snippet.of(1, 2, ImmutableList.of("hello", "world"))), + ImmutableList.of())); + + String expectedText = "===== Lines 1-2 =====\n" + "> hello\n" + "> world\n"; + assertThat(actual.toString()).isEqualTo(expectedText); + } + + @Test + public void addRemoveMiddleDiffEqualSize_complexDiff() { + assertThat(diffLines("hello\ndear\nworld", "hello\ngrand\nworld")) + .isEqualTo( + Diff.of( + ImmutableList.of(Snippet.of(2, "grand")), ImmutableList.of(Snippet.of(2, "dear")))); + } + + @Test + public void addRemoveMiddleDiffUnequalSize_complexDiff() { + assertThat(diffLines("hello\ndear\ngrand\nnow\ncow", "hello\ngrand\nworld")) + .isEqualTo( + Diff.of( + ImmutableList.of(Snippet.of(3, "world")), + ImmutableList.of( + Snippet.of(2, "dear"), Snippet.of(4, "now").join(Snippet.of(5, "cow"))))); + } + + @Test + public void addTrailingText_additionDiff() { + assertThat(diffLines("hello\ndear\ngrand", "hello\ndear\ngrand\nnow\ncow")) + .isEqualTo( + Diff.of( + ImmutableList.of(Snippet.of(4, "now").join(Snippet.of(5, "cow"))), + ImmutableList.of())); + } + + @Test + public void removeTrailingText_removalDiff() { + assertThat(diffLines("hello\ndear\ngrand\nnow\ncow", "hello\ndear\ngrand")) + .isEqualTo( + Diff.of( + ImmutableList.of(), + ImmutableList.of(Snippet.of(4, "now").join(Snippet.of(5, "cow"))))); + } + + @Test + public void leadingText_additionDiff() { + assertThat(diffLines("dear", "hello\ndear")) + .isEqualTo(Diff.of(ImmutableList.of(Snippet.of(1, "hello")), ImmutableList.of())); + } + + @Test + public void leadingAndTrailingText_complexDiff() { + Diff actual = diffLines("hello\ndear", "dear\nword"); + assertThat(actual) + .isEqualTo( + Diff.of( + ImmutableList.of(Snippet.of(2, "word")), ImmutableList.of(Snippet.of(1, "hello")))); + + String expectedText = + "===== Line 1 =====\n" + "< hello\n" + "===== Line 2 =====\n" + "> word\n"; + assertThat(actual.toString()).isEqualTo(expectedText); + } + + @Test + public void leadingAndTrailingText_complexDiff_reverse() { + Diff actual = diffLines("dear\nword", "hello\ndear"); + assertThat(actual) + .isEqualTo( + Diff.of( + ImmutableList.of(Snippet.of(1, "hello")), ImmutableList.of(Snippet.of(2, "word")))); + + String expectedText = + "===== Line 1 =====\n" + "> hello\n" + "===== Line 2 =====\n" + "< word\n"; + assertThat(actual.toString()).isEqualTo(expectedText); + } + + @Test + public void multipartDiff() { + String first = "Here\nis\na\nman\nand\nhis\ndog\nat\nhome\ntonight"; + String second = "There\nis\na\ncat\nand\nit's\nstaying\nat\na neighbor's"; + assertThat(diffLines(first, second)) + .isEqualTo( + Diff.of( + ImmutableList.of( + Snippet.of(1, "There"), + Snippet.of(4, "cat"), + Snippet.of(6, 7, ImmutableList.of("it's", "staying")), + Snippet.of(9, "a neighbor's")), + ImmutableList.of( + Snippet.of(1, "Here"), + Snippet.of(4, "man"), + Snippet.of(6, 7, ImmutableList.of("his", "dog")), + Snippet.of(9, 10, ImmutableList.of("home", "tonight"))))); + } + + @Test + public void multipartDiff_reverse() { + String first = "Here\nis\na\nman\nand\nhis\ndog\nat\nhome\ntonight"; + String second = "There\nis\na\ncat\nand\nit's\nstaying\nat\na neighbor's\nold\nhome\ntonight"; + Diff actual = diffLines(second, first); + assertThat(actual) + .isEqualTo( + Diff.of( + ImmutableList.of( + Snippet.of(1, "Here"), + Snippet.of(4, "man"), + Snippet.of(6, 7, ImmutableList.of("his", "dog"))), + ImmutableList.of( + Snippet.of(1, "There"), + Snippet.of(4, "cat"), + Snippet.of(6, 7, ImmutableList.of("it's", "staying")), + Snippet.of(9, 10, ImmutableList.of("a neighbor's", "old"))))); + + assertThat(actual.toString()) + .isEqualTo( + "===== Line 1 =====\n" + + "> Here\n" + + "< There\n" + + "===== Line 4 =====\n" + + "> man\n" + + "< cat\n" + + "===== Lines 6-7 =====\n" + + "> his\n" + + "> dog\n" + + "< it's\n" + + "< staying\n" + + "===== Lines 9-10 =====\n" + + "< a neighbor's\n" + + "< old\n"); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/BUILD.bazel b/testing/src/test/java/dev/cel/testing/testrunner/BUILD.bazel new file mode 100644 index 000000000..9141832cb --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/BUILD.bazel @@ -0,0 +1,291 @@ +load("@rules_java//java:java_library.bzl", "java_library") +load("@rules_java//java:java_test.bzl", "java_test") +load("@rules_proto//proto:defs.bzl", "proto_descriptor_set") +load("//testing/testrunner:cel_java_test.bzl", "cel_java_test") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = 1, +) + +# Since the user test class is triggered by the cel_test rule, we should not add it to the +# junit4_test_suite. +# This is just a sample test class for the cel_test rule. +java_library( + name = "user_test", + srcs = ["UserTest.java"], + deps = [ + "//bundle:cel", + "//common/types", + "//testing/testrunner:cel_test_context", + "//testing/testrunner:cel_user_test_template", + "@maven//:junit_junit", + ], +) + +# This is just a sample test class for the cel_test rule. +java_library( + name = "env_config_user_test", + srcs = ["EnvConfigUserTest.java"], + deps = [ + "//bundle:cel", + "//testing/testrunner:cel_test_context", + "//testing/testrunner:cel_user_test_template", + "@maven//:junit_junit", + ], +) + +java_library( + name = "late_function_binding_user_test", + srcs = ["LateFunctionBindingUserTest.java"], + deps = [ + "//runtime", + "//runtime:function_binding", + "//testing/testrunner:cel_test_context", + "//testing/testrunner:cel_user_test_template", + "@maven//:junit_junit", + ], +) + +java_library( + name = "custom_variable_binding_user_test", + srcs = ["CustomVariableBindingUserTest.java"], + deps = [ + "//bundle:cel", + "//testing/testrunner:cel_test_context", + "//testing/testrunner:cel_user_test_template", + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:junit_junit", + ], +) + +java_library( + name = "context_pb_user_test", + srcs = ["ContextPbUserTest.java"], + deps = [ + "//bundle:cel", + "//checker:proto_type_mask", + "//testing/testrunner:cel_test_context", + "//testing/testrunner:cel_user_test_template", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + "@maven//:junit_junit", + ], +) + +java_test( + name = "junit_xml_reporter_test", + srcs = ["JUnitXmlReporterTest.java"], + test_class = "dev.cel.testing.testrunner.JUnitXmlReporterTest", + deps = [ + "//:java_truth", + "//testing/testrunner:cel_coverage_index", + "//testing/testrunner:junit_xml_reporter", + "@maven//:junit_junit", + "@maven//:org_mockito_mockito_core", + ], +) + +java_test( + name = "cel_coverage_index_test", + srcs = ["CelCoverageIndexTest.java"], + test_class = "dev.cel.testing.testrunner.CelCoverageIndexTest", + deps = [ + "//:java_truth", + "//bundle:cel", + "//common:cel_ast", + "//common:options", + "//common/types", + "//compiler:compiler_builder", + "//extensions", + "//parser:macro", + "//runtime", + "//runtime:evaluation_listener", + "//testing/testrunner:cel_coverage_index", + "@maven//:com_google_guava_guava", + "@maven//:junit_junit", + ], +) + +java_test( + name = "default_result_matcher_test", + srcs = ["DefaultResultMatcherTest.java"], + test_class = "dev.cel.testing.testrunner.DefaultResultMatcherTest", + deps = [ + "//:java_truth", + "//bundle:cel", + "//common/types", + "//runtime", + "//testing/testrunner:cel_test_suite", + "//testing/testrunner:default_result_matcher", + "//testing/testrunner:result_matcher", + "@cel_spec//proto/cel/expr:expr_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "cel_test_suite_yaml_parser_test", + srcs = ["CelTestSuiteYamlParserTest.java"], + test_class = "dev.cel.testing.testrunner.CelTestSuiteYamlParserTest", + deps = [ + "//:java_truth", + "//testing/testrunner:cel_test_suite", + "//testing/testrunner:cel_test_suite_exception", + "//testing/testrunner:cel_test_suite_yaml_parser", + "@maven//:com_google_guava_guava", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + ], +) + +java_test( + name = "cel_test_suite_textproto_parser_test", + srcs = ["CelTestSuiteTextprotoParserTest.java"], + test_class = "dev.cel.testing.testrunner.CelTestSuiteTextprotoParserTest", + deps = [ + "//:java_truth", + "//testing/testrunner:cel_test_suite_exception", + "//testing/testrunner:cel_test_suite_text_proto_parser", + "@cel_spec//proto/cel/expr/conformance/test:suite_java_proto", + "@maven//:junit_junit", + ], +) + +cel_java_test( + name = "custom_variable_binding_test_runner_sample", + cel_expr = "custom_variable_bindings/policy.yaml", + config = "custom_variable_bindings/config.yaml", + test_data_path = "//testing/src/test/resources/policy", + test_src = ":custom_variable_binding_user_test", + test_suite = "custom_variable_bindings/tests.yaml", + deps = [ + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + ], +) + +cel_java_test( + name = "test_runner_yaml_sample_with_eval_error", + cel_expr = "nested_rule/eval_error_policy.yaml", + config = "nested_rule/eval_error_config.yaml", + proto_deps = [ + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto", + ], + test_data_path = "//testing/src/test/resources/policy", + test_src = ":env_config_user_test", + test_suite = "nested_rule/eval_error_tests.yaml", +) + +cel_java_test( + name = "test_runner_sample_with_expr_value_output", + cel_expr = "expr_value_output/policy.yaml", + test_data_path = "//testing/src/test/resources/policy", + test_src = ":user_test", + test_suite = "expr_value_output/tests.textproto", +) + +cel_java_test( + name = "test_runner_sample_with_eval_error", + cel_expr = "nested_rule/eval_error_policy.yaml", + config = "nested_rule/eval_error_config.yaml", + proto_deps = [ + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto", + ], + test_data_path = "//testing/src/test/resources/policy", + test_src = ":env_config_user_test", + test_suite = "nested_rule/eval_error_tests.textproto", + deps = [ + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + ], +) + +cel_java_test( + name = "raw_expression_test", + cel_expr = "2 + 2 == 4", + is_raw_expr = True, + test_data_path = "//testing/src/test/resources/expressions", + test_src = ":user_test", + test_suite = "simple_test_case/tests.textproto", +) + +cel_java_test( + name = "extension_as_input_test", + cel_expr = "2 + 2 == 4", + is_raw_expr = True, + proto_deps = [ + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto", + ], + test_data_path = "//testing/src/test/resources/policy", + test_src = ":user_test", + test_suite = "protoextension_value_as_input/tests.textproto", + deps = [ + "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + ], +) + +java_library( + name = "custom_test_suite", + srcs = ["CustomTestSuite.java"], + deps = [ + "//testing/testrunner:annotations", + "//testing/testrunner:cel_test_suite", + "@maven//:com_google_guava_guava", + ], +) + +cel_java_test( + name = "custom_test_suite_test", + cel_expr = "2 + 2 == 4", + is_raw_expr = True, + test_src = ":user_test", + deps = [ + ":custom_test_suite", + ], +) + +cel_java_test( + name = "expression_cel_file_test", + cel_expr = "simple_test_case/simple_expression.cel", + test_data_path = "//testing/src/test/resources/expressions", + test_src = ":user_test", + test_suite = "simple_test_case/tests.textproto", +) + +java_library( + name = "coverage_test", + srcs = ["CoverageTest.java"], + deps = [ + "//bundle:cel", + "//common/types", + "//testing/testrunner:cel_test_context", + "//testing/testrunner:cel_user_test_template", + "@maven//:junit_junit", + ], +) + +cel_java_test( + name = "cel_coverage_test", + cel_expr = "coverage_test_case/simple_expression.cel", + enable_coverage = True, + test_data_path = "//testing/src/test/resources/expressions", + test_src = ":coverage_test", + test_suite = "coverage_test_case/tests.textproto", +) + +cel_java_test( + name = "cel_partial_coverage_test", + cel_expr = "coverage_test_case/simple_expression.cel", + enable_coverage = True, + test_data_path = "//testing/src/test/resources/expressions", + test_src = ":coverage_test", + test_suite = "coverage_test_case/partial_coverage_tests.textproto", +) diff --git a/testing/src/test/java/dev/cel/testing/testrunner/CelCoverageIndexTest.java b/testing/src/test/java/dev/cel/testing/testrunner/CelCoverageIndexTest.java new file mode 100644 index 000000000..4c6a6cf26 --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/CelCoverageIndexTest.java @@ -0,0 +1,181 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; + +import com.google.common.collect.ImmutableMap; +import com.google.common.io.Files; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelOptions; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.extensions.CelExtensions; +import dev.cel.parser.CelStandardMacro; +import dev.cel.runtime.CelEvaluationListener; +import dev.cel.runtime.CelRuntime; +import dev.cel.testing.testrunner.CelCoverageIndex.CoverageReport; +import java.io.File; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelCoverageIndexTest { + + @Test + public void getCoverageReport_fullCoverage() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addVar("x", SimpleType.INT) + .addVar("y", SimpleType.INT) + .build(); + CelAbstractSyntaxTree ast = cel.compile("x > 1 && y > 1").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + CelCoverageIndex coverageIndex = new CelCoverageIndex(); + coverageIndex.init(ast); + CelEvaluationListener listener = coverageIndex.newEvaluationListener(); + + program.trace(ImmutableMap.of("x", 2L, "y", 2L), listener); + + CoverageReport report = coverageIndex.generateCoverageReport(); + assertThat(report.nodes()).isGreaterThan(0); + assertThat(report.coveredNodes()).isEqualTo(report.nodes()); + assertThat(report.branches()).isEqualTo(6); + assertThat(report.coveredBooleanOutcomes()) + .isEqualTo(3); // x>1 -> true, y>1 -> true, && -> true + assertThat(report.unencounteredNodes()).isEmpty(); + assertThat(report.unencounteredBranches()) + .containsExactly( + "Expression ID 4 ('x > 1 && y > 1'): lacks 'false' coverage", + "\t\tExpression ID 2 ('x > 1'): lacks 'false' coverage", + "\t\tExpression ID 6 ('y > 1'): lacks 'false' coverage"); + } + + @Test + public void getCoverageReport_partialCoverage_shortCircuit() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addVar("x", SimpleType.INT) + .addVar("y", SimpleType.INT) + .build(); + CelAbstractSyntaxTree ast = cel.compile("x > 1 && y > 1").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + CelCoverageIndex coverageIndex = new CelCoverageIndex(); + coverageIndex.init(ast); + CelEvaluationListener listener = coverageIndex.newEvaluationListener(); + + program.trace(ImmutableMap.of("x", 0L, "y", 2L), listener); + + CoverageReport report = coverageIndex.generateCoverageReport(); + assertThat(report.celExpression()).isEqualTo("x > 1 && y > 1"); + assertThat(report.nodes()).isGreaterThan(0); + assertThat(report.coveredNodes()).isLessThan(report.nodes()); + assertThat(report.branches()).isEqualTo(6); + assertThat(report.coveredBooleanOutcomes()).isEqualTo(2); // x>1 -> false, && -> false + assertThat(report.unencounteredNodes()).containsExactly("Expression ID 6 ('y > 1')"); + // y > 1 is unencountered, so logUnencountered becomes false, and branch coverage for y > 1 + // isn't logged to unencounteredBranches. + assertThat(report.unencounteredBranches()) + .containsExactly( + "Expression ID 4 ('x > 1 && y > 1'): lacks 'true' coverage", + "\t\tExpression ID 2 ('x > 1'): lacks 'true' coverage"); + } + + @Test + public void getCoverageReport_comprehension_generatesDotGraph() throws Exception { + Cel cel = CelFactory.standardCelBuilder().build(); + CelCompiler compiler = + cel.toCompilerBuilder() + .setOptions(CelOptions.newBuilder().populateMacroCalls(true).build()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addLibraries(CelExtensions.comprehensions()) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[1, 2, 3].all(i, i % 2 != 0)").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + CelCoverageIndex coverageIndex = new CelCoverageIndex(); + coverageIndex.init(ast); + CelEvaluationListener listener = coverageIndex.newEvaluationListener(); + + program.trace(ImmutableMap.of(), listener); + + CoverageReport report = coverageIndex.generateCoverageReport(); + assertThat(report.dotGraph()) + .contains("label=\"{<1> exprID: 1 | <2> IterRange} | <3> [1, 2, 3]\""); + assertThat(report.dotGraph()).contains("label=\"{<1> exprID: 12 | <2> AccuInit} | <3> true\""); + assertThat(report.dotGraph()).doesNotContain("red"); // No unencountered nodes. + assertThat(report.dotGraph()) + .contains( + "label=\"{<1> exprID: 14 | <2> LoopCondition} | <3>" + + " @not_strictly_false(@result)\""); + assertThat(report.dotGraph()) + .contains("label=\"{<1> exprID: 16 | <2> LoopStep} | <3> @result && i % 2 != 0\""); + assertThat(report.dotGraph()).contains("label=\"{<1> exprID: 17 | <2> Result} | <3> @result\""); + } + + @Test + public void getCoverageReport_fullCoverage_writesToUndeclaredOutputs() throws Exception { + // Setup for a more complex graph to write. + Cel cel = CelFactory.standardCelBuilder().build(); + CelCompiler compiler = + cel.toCompilerBuilder() + .setOptions(CelOptions.newBuilder().populateMacroCalls(true).build()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addLibraries(CelExtensions.comprehensions()) + .build(); + CelAbstractSyntaxTree ast = compiler.compile("[1, 2, 3].all(i, i % 2 != 0)").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + CelCoverageIndex coverageIndex = new CelCoverageIndex(); + coverageIndex.init(ast); + CelEvaluationListener listener = coverageIndex.newEvaluationListener(); + program.trace(ImmutableMap.of(), listener); + + CoverageReport report = coverageIndex.generateCoverageReport(); + + String undeclaredOutputsDir = System.getenv("TEST_UNDECLARED_OUTPUTS_DIR"); + assertThat(undeclaredOutputsDir).isNotNull(); + + File outputFile = new File(undeclaredOutputsDir, "cel_test_coverage/coverage_graph.txt"); + + String fileContent = Files.asCharSource(outputFile, UTF_8).read(); + assertThat(fileContent).isEqualTo(report.dotGraph()); + } + + @Test + public void getCoverageReport_fullCoverage_multipleEvaluations() throws Exception { + Cel cel = CelFactory.standardCelBuilder().addVar("x", SimpleType.INT).build(); + CelAbstractSyntaxTree ast = cel.compile("x > 1").getAst(); + CelRuntime.Program program = cel.createProgram(ast); + CelCoverageIndex coverageIndex = new CelCoverageIndex(); + coverageIndex.init(ast); + CelEvaluationListener listener = coverageIndex.newEvaluationListener(); + + program.trace(ImmutableMap.of("x", 2L), listener); + coverageIndex.init(ast); // Re-initialize the coverage index. + program.trace(ImmutableMap.of("x", 0L), listener); + + CoverageReport report = coverageIndex.generateCoverageReport(); + assertThat(report.nodes()).isGreaterThan(0); + assertThat(report.coveredNodes()).isEqualTo(report.nodes()); + assertThat(report.branches()).isEqualTo(2); + // Despite re-initializing the coverage index now, the report should still + // be fully covered. Else, only the second evaluation would've been covered. + assertThat(report.coveredBooleanOutcomes()).isEqualTo(2); + assertThat(report.unencounteredNodes()).isEmpty(); + assertThat(report.unencounteredBranches()).isEmpty(); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/CelTestSuiteTextprotoParserTest.java b/testing/src/test/java/dev/cel/testing/testrunner/CelTestSuiteTextprotoParserTest.java new file mode 100644 index 000000000..4603cc845 --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/CelTestSuiteTextprotoParserTest.java @@ -0,0 +1,60 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.expr.conformance.test.InputContext; +import dev.cel.expr.conformance.test.InputValue; +import dev.cel.expr.conformance.test.TestCase; +import dev.cel.expr.conformance.test.TestSection; +import dev.cel.expr.conformance.test.TestSuite; +import java.io.IOException; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class CelTestSuiteTextprotoParserTest { + + @Test + public void parseTestSuite_illegalInput_failure() throws IOException { + TestSuite testSuite = + TestSuite.newBuilder() + .setName("some_test_suite") + .setDescription("Some test suite") + .addSections( + TestSection.newBuilder() + .setName("section_name") + .addTests( + TestCase.newBuilder() + .setName("test_case_name") + .setDescription("Some test case") + .putInput("test_key", InputValue.getDefaultInstance()) + .setInputContext(InputContext.getDefaultInstance()) + .build()) + .build()) + .build(); + + CelTestSuiteException exception = + assertThrows( + CelTestSuiteException.class, + () -> CelTestSuiteTextProtoParser.parseCelTestSuite(testSuite)); + + assertThat(exception) + .hasMessageThat() + .contains("Test case: test_case_name cannot have both input map and input context."); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/CelTestSuiteYamlParserTest.java b/testing/src/test/java/dev/cel/testing/testrunner/CelTestSuiteYamlParserTest.java new file mode 100644 index 000000000..46d509e5e --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/CelTestSuiteYamlParserTest.java @@ -0,0 +1,489 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase.Input.Binding; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelTestSuiteYamlParserTest { + + private static final CelTestSuiteYamlParser CEL_TEST_SUITE_YAML_PARSER = + CelTestSuiteYamlParser.newInstance(); + + @Test + public void parseTestSuite_withBindingsAsInput_success() throws CelTestSuiteException { + String testSuiteYamlContent = + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value:\n" + + " - nested_key: true\n" + + " output:\n" + + " value: 'test_result_value'\n" + + " - name: 'test_case_name_2'\n" + + " description: 'test_case_description_2'\n" + + " input:\n" + + " test_key:\n" + + " value: 1\n" + + " output:\n" + + " value: 2.20\n"; + + CelTestSuite testSuite = CEL_TEST_SUITE_YAML_PARSER.parse(testSuiteYamlContent); + CelTestSuite expectedTestSuite = + CelTestSuite.newBuilder() + .setSource(testSuite.source().get()) + .setName("test_suite_name") + .setDescription("test_suite_description") + .setSections( + ImmutableSet.of( + CelTestSuite.CelTestSection.newBuilder() + .setName("test_section_name") + .setDescription("test_section_description") + .setTests( + ImmutableSet.of( + CelTestSuite.CelTestSection.CelTestCase.newBuilder() + .setName("test_case_name") + .setDescription("test_case_description") + .setInput( + CelTestSuite.CelTestSection.CelTestCase.Input.ofBindings( + ImmutableMap.of( + "test_key", + Binding.ofValue( + ImmutableList.of( + ImmutableMap.of("nested_key", true)))))) + .setOutput( + CelTestSuite.CelTestSection.CelTestCase.Output + .ofResultValue("test_result_value")) + .build(), + CelTestSuite.CelTestSection.CelTestCase.newBuilder() + .setName("test_case_name_2") + .setDescription("test_case_description_2") + .setInput( + CelTestSuite.CelTestSection.CelTestCase.Input.ofBindings( + ImmutableMap.of("test_key", Binding.ofValue(1)))) + .setOutput( + CelTestSuite.CelTestSection.CelTestCase.Output + .ofResultValue(2.20)) + .build())) + .build())) + .build(); + + assertThat(testSuite).isEqualTo(expectedTestSuite); + assertThat(testSuite.source().get().getPositionsMap()).isNotEmpty(); + } + + @Test + public void parseTestSuite_withExprAsOutput_success() throws CelTestSuiteException { + String testSuiteYamlContent = + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " expr: 'some_value'\n" + + " output:\n" + + " expr: '1 == 1'\n"; + + CelTestSuite testSuite = CEL_TEST_SUITE_YAML_PARSER.parse(testSuiteYamlContent); + CelTestSuite expectedTestSuite = + CelTestSuite.newBuilder() + .setSource(testSuite.source().get()) + .setName("test_suite_name") + .setDescription("test_suite_description") + .setSections( + ImmutableSet.of( + CelTestSuite.CelTestSection.newBuilder() + .setName("test_section_name") + .setDescription("test_section_description") + .setTests( + ImmutableSet.of( + CelTestSuite.CelTestSection.CelTestCase.newBuilder() + .setName("test_case_name") + .setDescription("test_case_description") + .setInput( + CelTestSuite.CelTestSection.CelTestCase.Input.ofBindings( + ImmutableMap.of( + "test_key", Binding.ofExpr("some_value")))) + .setOutput( + CelTestSuite.CelTestSection.CelTestCase.Output.ofResultExpr( + "1 == 1")) + .build())) + .build())) + .build(); + + assertThat(testSuite).isEqualTo(expectedTestSuite); + assertThat(testSuite.source().get().getPositionsMap()).isNotEmpty(); + } + + @Test + public void parseTestSuite_failure_throwsException( + @TestParameter TestSuiteYamlParsingErrorTestCase testCase) throws CelTestSuiteException { + CelTestSuiteException celTestSuiteException = + assertThrows( + CelTestSuiteException.class, + () -> CEL_TEST_SUITE_YAML_PARSER.parse(testCase.testSuiteYamlContent)); + + assertThat(celTestSuiteException).hasMessageThat().contains(testCase.expectedErrorMessage); + } + + private enum TestSuiteYamlParsingErrorTestCase { + TEST_SUITE_WITH_MISALIGNED_NAME_TAG( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + "name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key: 'test_value'\n" + + " value: 'test_result_value'\n", + "YAML document is malformed: while parsing a block mapping\n" + + " in 'reader', line 1, column 1:\n" + + " name: 'test_suite_name'\n" + + " ^"), + TEST_SUITE_WITH_ILLEGAL_TEST_SUITE_TAG( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n" + + "unknown_tag: 'test_value'\n", + "ERROR: :14:1: Unknown test suite tag: unknown_tag\n" + + " | unknown_tag: 'test_value'\n" + + " | ^"), + TEST_SUITE_WITH_ILLEGAL_TEST_SECTION_TAG( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " unknown_tag: 'test_value'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :5:3: Unknown test section tag: unknown_tag\n" + + " | unknown_tag: 'test_value'\n" + + " | ..^"), + TEST_SUITE_WITH_ILLEGAL_TEST_CASE_OUTPUT_TAG( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " unknown_tag: 'test_result_value'\n", + "ERROR: :13:7: Unknown output tag: unknown_tag\n" + + " | unknown_tag: 'test_result_value'\n" + + " | ......^"), + TEST_SUITE_WITH_ILLEGAL_TEST_CASE_TAG( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n" + + " unknown_tag: 'test_value'\n", + "ERROR: :14:5: Unknown test case tag: unknown_tag\n" + + " | unknown_tag: 'test_value'\n" + + " | ....^"), + ILLEGAL_TEST_SUITE_WITH_SECTION_NOT_LIST( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + " name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :4:3: Got yaml node type tag:yaml.org,2002:map, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | name: 'test_section_name'\n" + + " | ..^\n" + + "ERROR: :4:3: Sections is not a list: tag:yaml.org,2002:map\n" + + " | name: 'test_section_name'\n" + + " | ..^"), + ILLEGAL_TEST_SUITE_WITH_TEST_SUITE_NOT_MAP( + "- name: 'test_suite_name'\n" + + "- description: 'test_suite_description'\n" + + "- sections:\n" + + " name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :1:1: Got yaml node type tag:yaml.org,2002:seq, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - name: 'test_suite_name'\n" + + " | ^\n" + + "ERROR: :1:1: Unknown test suite type: tag:yaml.org,2002:seq\n" + + " | - name: 'test_suite_name'\n" + + " | ^"), + ILLEGAL_TEST_SUITE_WITH_OUTPUT_NOT_MAP( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " - value: 'test_result_value'\n", + "ERROR: :13:7: Got yaml node type tag:yaml.org,2002:seq, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - value: 'test_result_value'\n" + + " | ......^\n" + + "ERROR: :13:7: Output is not a map: tag:yaml.org,2002:seq\n" + + " | - value: 'test_result_value'\n" + + " | ......^"), + ILLEGAL_TEST_SUITE_WITH_MORE_THAN_ONE_INPUT_VALUES_AGAINST_KEY( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " value: 'test_value_2'\n" + + " expr: 'test_expr'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :11:11: Input binding node must have exactly one value:" + + " tag:yaml.org,2002:map\n" + + " | value: 'test_value'\n" + + " | ..........^"), + ILLEGAL_TEST_SUITE_WITH_UNKNOWN_INPUT_BINDING_VALUE_TAG( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " something: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :11:11: Unknown input binding value tag: something\n" + + " | something: 'test_value'\n" + + " | ..........^"), + ILLEGAL_TEST_SUITE_WITH_BINDINGS_NOT_MAP( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " - test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :10:10: Got yaml node type tag:yaml.org,2002:seq, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - test_key:\n" + + " | .........^\n" + + "ERROR: :10:10: Input is not a map: tag:yaml.org,2002:seq\n" + + " | - test_key:\n" + + " | .........^"), + ILLEGAL_TEST_SUITE_WITH_ILLEGAL_BINDINGS_VALUE( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " - value\n" + + " - 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :11:13: Got yaml node type tag:yaml.org,2002:seq, wanted type(s)" + + " [tag:yaml.org,2002:map]\n" + + " | - value\n" + + " | ............^\n" + + "ERROR: :11:13: Input binding node is not a map: tag:yaml.org,2002:seq\n" + + " | - value\n" + + " | ............^"), + ILLEGAL_TEST_SUITE_WITH_ILLEGAL_CONTEXT_EXPR_VALUE( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " context_expr:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :10:9: Got yaml node type tag:yaml.org,2002:map, wanted type(s)" + + " [tag:yaml.org,2002:str]\n" + + " | test_key:\n" + + " | ........^\n" + + "ERROR: :10:9: Input context is not a string: tag:yaml.org,2002:map\n" + + " | test_key:\n" + + " | ........^"), + ILLEGAL_TEST_SUITE_WITH_TESTS_NOT_LIST( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :7:5: Got yaml node type tag:yaml.org,2002:map, wanted type(s)" + + " [tag:yaml.org,2002:seq]\n" + + " | name: 'test_case_name'\n" + + " | ....^\n" + + "ERROR: :7:5: Tests is not a list: tag:yaml.org,2002:map\n" + + " | name: 'test_case_name'\n" + + " | ....^"), + TEST_SUITE_WITH_ILLEGAL_TEST_SUITE_FORMAT( + "- name: 'test_suite_name'\n" + + "- name: 'test_section_name'\n" + + "- name: 'test_section_name_2'\n", + "ERROR: :1:1: Unknown test suite type: tag:yaml.org,2002:seq\n" + + " | - name: 'test_suite_name'\n" + + " | ^"), + TEST_SUITE_WITH_ILLEGAL_SECTION_TYPE( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "1:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " value: 'test_result_value'\n", + "ERROR: :3:1: Got yaml node type tag:yaml.org,2002:int, wanted type(s)" + + " [tag:yaml.org,2002:str !txt]\n" + + " | 1:\n" + + " | ^"), + TEST_CASE_WITH_ILLEGAL_UNKNOWN_OUTPUT_TYPE( + "name: 'test_suite_name'\n" + + "description: 'test_suite_description'\n" + + "sections:\n" + + "- name: 'test_section_name'\n" + + " description: 'test_section_description'\n" + + " tests:\n" + + " - name: 'test_case_name'\n" + + " description: 'test_case_description'\n" + + " input:\n" + + " test_key:\n" + + " value: 'test_value'\n" + + " output:\n" + + " unknown:\n" + + " - 'test_result_value'\n", + "ERROR: :14:9: Only integer ids are supported in unknown list. Found:" + + " java.lang.String\n" + + " | - 'test_result_value'\n" + + " | ........^"), + ; + + private final String testSuiteYamlContent; + private final String expectedErrorMessage; + + TestSuiteYamlParsingErrorTestCase(String testSuiteYamlContent, String expectedErrorMessage) { + this.testSuiteYamlContent = testSuiteYamlContent; + this.expectedErrorMessage = expectedErrorMessage; + } + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/ContextPbUserTest.java b/testing/src/test/java/dev/cel/testing/testrunner/ContextPbUserTest.java new file mode 100644 index 000000000..0270cc52d --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/ContextPbUserTest.java @@ -0,0 +1,44 @@ +// Copyright 2025 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.testing.testrunner; + +import dev.cel.bundle.CelFactory; +import dev.cel.checker.ProtoTypeMask; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/** + * This test demonstrates the use case where the fields of a proto are used as variables in the CEL + * expression i.e. context_expr. + */ +@RunWith(Parameterized.class) +public class ContextPbUserTest extends CelUserTestTemplate { + + // TODO: Add support for context_expr and remove the need to add the proto type masks + // explicitly. + public ContextPbUserTest() { + super( + CelTestContext.newBuilder() + .setCel( + CelFactory.standardCelBuilder() + .addFileTypes(TestAllTypes.getDescriptor().getFile()) + .addProtoTypeMasks( + ProtoTypeMask.ofAllFields(TestAllTypes.getDescriptor().getFullName()) + .withFieldsAsVariableDeclarations()) + .build()) + .build()); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/CoverageTest.java b/testing/src/test/java/dev/cel/testing/testrunner/CoverageTest.java new file mode 100644 index 000000000..c7b0c395d --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/CoverageTest.java @@ -0,0 +1,39 @@ +// Copyright 2025 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.testing.testrunner; + +import dev.cel.bundle.CelFactory; +import dev.cel.common.types.SimpleType; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/** + * Sample test class used for coverage analysis, demonstrating the use of the CEL test runner + * without a config file. + */ +@RunWith(Parameterized.class) +public class CoverageTest extends CelUserTestTemplate { + + public CoverageTest() { + super( + CelTestContext.newBuilder() + .setCel( + CelFactory.standardCelBuilder() + .addVar("x", SimpleType.INT) + .addVar("y", SimpleType.INT) + .build()) + .build()); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/CustomTestSuite.java b/testing/src/test/java/dev/cel/testing/testrunner/CustomTestSuite.java new file mode 100644 index 000000000..ba9147678 --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/CustomTestSuite.java @@ -0,0 +1,49 @@ +// Copyright 2025 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.testing.testrunner; + +import com.google.common.collect.ImmutableSet; +import dev.cel.testing.testrunner.Annotations.TestSuiteSupplier; +import java.util.logging.Logger; + +final class CustomTestSuite { + + private static final Logger logger = Logger.getLogger(CustomTestSuite.class.getName()); + + @TestSuiteSupplier + public CelTestSuite getCelTestSuite() { + logger.info("TestSuite Parser Triggered."); + return CelTestSuite.newBuilder() + .setDescription("CustomFunctionClass Test Suite") + .setName("CustomFunctionClass Test Suite") + .setSections( + ImmutableSet.of( + CelTestSuite.CelTestSection.newBuilder() + .setName("valid") + .setDescription("valid") + .setTests( + ImmutableSet.of( + CelTestSuite.CelTestSection.CelTestCase.newBuilder() + .setName("valid") + .setDescription("valid") + .setInput(CelTestSuite.CelTestSection.CelTestCase.Input.ofNoInput()) + .setOutput( + CelTestSuite.CelTestSection.CelTestCase.Output.ofResultValue( + true)) + .build())) + .build())) + .build(); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/CustomVariableBindingUserTest.java b/testing/src/test/java/dev/cel/testing/testrunner/CustomVariableBindingUserTest.java new file mode 100644 index 000000000..37382052c --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/CustomVariableBindingUserTest.java @@ -0,0 +1,53 @@ +// Copyright 2025 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.testing.testrunner; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.ExtensionRegistry; +import dev.cel.bundle.CelFactory; +import dev.cel.expr.conformance.proto2.TestAllTypes; +import dev.cel.expr.conformance.proto2.TestAllTypesExtensions; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/** + * This test demonstrates the use case where the custom variable bindings are being provided + * programmatically for using extensions. + */ +@RunWith(Parameterized.class) +public class CustomVariableBindingUserTest extends CelUserTestTemplate { + + public CustomVariableBindingUserTest() { + super(newTestContext()); + } + + private static CelTestContext newTestContext() { + ExtensionRegistry registry = ExtensionRegistry.newInstance(); + registry.add(TestAllTypesExtensions.int32Ext); + + return CelTestContext.newBuilder() + .setCel( + CelFactory.standardCelBuilder() + .addMessageTypes(TestAllTypes.getDescriptor()) + .addFileTypes(TestAllTypesExtensions.getDescriptor()) + .setExtensionRegistry(registry) + .build()) + .setVariableBindings( + ImmutableMap.of( + "spec", + TestAllTypes.newBuilder().setExtension(TestAllTypesExtensions.int32Ext, 1).build())) + .build(); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/DefaultResultMatcherTest.java b/testing/src/test/java/dev/cel/testing/testrunner/DefaultResultMatcherTest.java new file mode 100644 index 000000000..41677c16c --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/DefaultResultMatcherTest.java @@ -0,0 +1,131 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.expr.ExprValue; +import dev.cel.expr.Value; +import com.google.common.collect.ImmutableList; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import dev.cel.bundle.CelFactory; +import dev.cel.common.types.SimpleType; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase.Output; +import dev.cel.testing.testrunner.ResultMatcher.ResultMatcherParams; +import java.util.Optional; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class DefaultResultMatcherTest { + + private static final DefaultResultMatcher MATCHER = new DefaultResultMatcher(); + + @Test + public void match_resultExprEvaluationError_failure() throws Exception { + ResultMatcherParams params = + ResultMatcherParams.newBuilder() + .setExpectedOutput(Optional.of(Output.ofResultExpr("2 / 0"))) + .setComputedOutput( + ResultMatcherParams.ComputedOutput.ofExprValue( + ExprValue.newBuilder() + .setValue(Value.newBuilder().setInt64Value(0).build()) + .build())) + .setResultType(SimpleType.INT) + .build(); + + IllegalArgumentException thrown = + assertThrows( + IllegalArgumentException.class, + () -> MATCHER.match(params, CelFactory.standardCelBuilder().build())); + + assertThat(thrown) + .hasMessageThat() + .contains("Failed to evaluate result_expr: evaluation error at :2: / by zero"); + } + + @Test + public void match_expectedExprValueForResultExprOutputAndComputedEvalError_failure() + throws Exception { + ResultMatcherParams params = + ResultMatcherParams.newBuilder() + .setExpectedOutput(Optional.of(Output.ofResultExpr("x + y"))) + .setComputedOutput( + ResultMatcherParams.ComputedOutput.ofError( + new CelEvaluationException("evaluation error"))) + .setResultType(SimpleType.INT) + .build(); + + AssertionError thrown = + assertThrows( + AssertionError.class, + () -> MATCHER.match(params, CelFactory.standardCelBuilder().build())); + + assertThat(thrown).hasMessageThat().contains("Error: evaluation error"); + } + + @Test + public void match_expectedExprValueAndComputedEvalError_failure() throws Exception { + ResultMatcherParams params = + ResultMatcherParams.newBuilder() + .setExpectedOutput( + Optional.of( + Output.ofResultValue( + ExprValue.newBuilder() + .setValue(Value.newBuilder().setInt64Value(3).build()) + .build()))) + .setComputedOutput( + ResultMatcherParams.ComputedOutput.ofError( + new CelEvaluationException("evaluation error"))) + .setResultType(SimpleType.INT) + .build(); + + AssertionError thrown = + assertThrows( + AssertionError.class, + () -> MATCHER.match(params, CelFactory.standardCelBuilder().build())); + + assertThat(thrown).hasMessageThat().contains("Error: evaluation error"); + } + + @Test + public void match_expectedEvalErrorAndComputedExprValue_failure() throws Exception { + ResultMatcherParams params = + ResultMatcherParams.newBuilder() + .setExpectedOutput( + Optional.of(Output.ofEvalError(ImmutableList.of("evaluation error")))) + .setComputedOutput( + ResultMatcherParams.ComputedOutput.ofExprValue( + ExprValue.newBuilder() + .setValue(Value.newBuilder().setInt64Value(3).build()) + .build())) + .setResultType(SimpleType.INT) + .build(); + + AssertionError thrown = + assertThrows( + AssertionError.class, + () -> MATCHER.match(params, CelFactory.standardCelBuilder().build())); + + assertThat(thrown) + .hasMessageThat() + .contains( + "Evaluation was successful but no value was provided. Computed output: value {\n" + + " int64_value: 3\n" + + "}"); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/EnvConfigUserTest.java b/testing/src/test/java/dev/cel/testing/testrunner/EnvConfigUserTest.java new file mode 100644 index 000000000..99b2d1f79 --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/EnvConfigUserTest.java @@ -0,0 +1,31 @@ +// Copyright 2025 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.testing.testrunner; + +import dev.cel.bundle.CelFactory; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/** + * This test demonstrates the use case where the declarations are provided in the environment config + * file. + */ +@RunWith(Parameterized.class) +public class EnvConfigUserTest extends CelUserTestTemplate { + + public EnvConfigUserTest() { + super(CelTestContext.newBuilder().setCel(CelFactory.standardCelBuilder().build()).build()); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/JUnitXmlReporterTest.java b/testing/src/test/java/dev/cel/testing/testrunner/JUnitXmlReporterTest.java new file mode 100644 index 000000000..b2a610ccb --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/JUnitXmlReporterTest.java @@ -0,0 +1,215 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.when; + +import dev.cel.testing.testrunner.JUnitXmlReporter.TestContext; +import dev.cel.testing.testrunner.JUnitXmlReporter.TestResult; +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; + +@RunWith(JUnit4.class) +public class JUnitXmlReporterTest { + + private static final String SUITE_NAME = "TestSuiteName"; + private static final String TEST_CLASS_NAME = "TestClass1"; + private static final String TEST_METHOD_NAME = "testMethod1"; + + @Rule public final MockitoRule mockito = MockitoJUnit.rule(); + + @Mock private TestContext context; + @Mock private TestResult result1; + @Mock private TestResult result2; + @Mock private TestResult resultFailure; + + @Rule public TemporaryFolder tempFolder = new TemporaryFolder(); + + @Test + public void testGenerateReport_success() throws IOException { + String outputFileName = "test-report.xml"; + File subFolder = tempFolder.newFolder("subFolder"); + File outputFile = new File(subFolder.getAbsolutePath(), outputFileName); + JUnitXmlReporter reporter = new JUnitXmlReporter(outputFile.getAbsolutePath()); + long startTime = 100L; + long test1EndTime = startTime + 400; + long endTime = startTime + 900; + + when(context.getSuiteName()).thenReturn(SUITE_NAME); + when(context.getStartTime()).thenReturn(startTime); + when(context.getEndTime()).thenReturn(endTime); + reporter.onStart(context); + + when(result1.getTestClassName()).thenReturn(TEST_CLASS_NAME); + when(result1.getName()).thenReturn(TEST_METHOD_NAME); + when(result1.getStartMillis()).thenReturn(startTime); + when(result1.getEndMillis()).thenReturn(test1EndTime); + when(result1.getStatus()).thenReturn(JUnitXmlReporter.TestResult.SUCCESS); + reporter.onTestSuccess(result1); + + when(result2.getTestClassName()).thenReturn("TestClass2"); + when(result2.getName()).thenReturn("testMethod2"); + when(result2.getStartMillis()).thenReturn(test1EndTime); + when(result2.getEndMillis()).thenReturn(endTime); + when(result2.getStatus()).thenReturn(JUnitXmlReporter.TestResult.SUCCESS); + reporter.onTestSuccess(result2); + + reporter.onFinish(); + assertThat(outputFile.exists()).isTrue(); + String concatenatedFileContent = String.join("\n", Files.readAllLines(outputFile.toPath())); + + assertThat(concatenatedFileContent) + .contains( + ""); + + outputFile.delete(); + } + + @Test + public void testGenerateReport_failure() throws IOException { + String outputFileName = "test-report.xml"; + File subFolder = tempFolder.newFolder("subFolder"); + File outputFile = new File(subFolder.getAbsolutePath(), outputFileName); + JUnitXmlReporter reporter = new JUnitXmlReporter(outputFile.getAbsolutePath()); + + when(context.getSuiteName()).thenReturn(SUITE_NAME); + when(context.getStartTime()).thenReturn(0L); + when(context.getEndTime()).thenReturn(1000L); + reporter.onStart(context); + + when(resultFailure.getTestClassName()).thenReturn(TEST_CLASS_NAME); + when(resultFailure.getName()).thenReturn(TEST_METHOD_NAME); + when(resultFailure.getStartMillis()).thenReturn(0L); + when(resultFailure.getEndMillis()).thenReturn(500L); + when(resultFailure.getStatus()).thenReturn(JUnitXmlReporter.TestResult.FAILURE); + Throwable throwable = new RuntimeException("Test Exception"); + when(resultFailure.getThrowable()).thenReturn(throwable); + reporter.onTestFailure(resultFailure); + reporter.onFinish(); + + assertThat(reporter.getNumFailed()).isEqualTo(1); + assertThat(outputFile.exists()).isTrue(); + + String concatenatedFileContent = String.join("\n", Files.readAllLines(outputFile.toPath())); + + assertThat(concatenatedFileContent).contains("failures=\"1\""); + assertThat(concatenatedFileContent).contains("failure message=\"Test Exception\""); + } + + @Test + public void testGenerateReport_coverageReport_noCoverage() throws IOException { + String outputFileName = "test-report-with-coverage.xml"; + File subFolder = tempFolder.newFolder("subFolder"); + File outputFile = new File(subFolder.getAbsolutePath(), outputFileName); + JUnitXmlReporter reporter = new JUnitXmlReporter(outputFile.getAbsolutePath()); + long startTime = 100L; + long test1EndTime = startTime + 400; + long endTime = startTime + 900; + + CelCoverageIndex.CoverageReport coverageReport = + CelCoverageIndex.CoverageReport.builder().build(); + + when(context.getSuiteName()).thenReturn(SUITE_NAME); + when(context.getStartTime()).thenReturn(startTime); + when(context.getEndTime()).thenReturn(endTime); + reporter.onStart(context); + + when(result1.getTestClassName()).thenReturn(TEST_CLASS_NAME); + when(result1.getName()).thenReturn(TEST_METHOD_NAME); + when(result1.getStartMillis()).thenReturn(startTime); + when(result1.getEndMillis()).thenReturn(test1EndTime); + when(result1.getStatus()).thenReturn(JUnitXmlReporter.TestResult.SUCCESS); + reporter.onTestSuccess(result1); + + reporter.onFinish(coverageReport); + assertThat(outputFile.exists()).isTrue(); + String concatenatedFileContent = String.join("\n", Files.readAllLines(outputFile.toPath())); + + assertThat(concatenatedFileContent).contains("No coverage stats found"); + + outputFile.delete(); + } + + @Test + public void testGenerateReport_coverageReport_withCoverage() throws IOException { + String outputFileName = "test-report-with-coverage.xml"; + File subFolder = tempFolder.newFolder("subFolder"); + File outputFile = new File(subFolder.getAbsolutePath(), outputFileName); + JUnitXmlReporter reporter = new JUnitXmlReporter(outputFile.getAbsolutePath()); + long startTime = 100L; + long test1EndTime = startTime + 400; + long endTime = startTime + 900; + + CelCoverageIndex.CoverageReport coverageReport = + CelCoverageIndex.CoverageReport.builder() + .setNodes(10L) + .setCoveredNodes(10L) + .setBranches(10L) + .setCoveredBooleanOutcomes(5L) + .addUnencounteredNodes("Node 1") + .addUnencounteredNodes("Node 2") + .addUnencounteredBranches("Branch 1") + .addUnencounteredBranches("Branch 2") + .setGraphUrl("http://graphviz/url") + .build(); + + when(context.getSuiteName()).thenReturn(SUITE_NAME); + when(context.getStartTime()).thenReturn(startTime); + when(context.getEndTime()).thenReturn(endTime); + reporter.onStart(context); + + when(result1.getTestClassName()).thenReturn(TEST_CLASS_NAME); + when(result1.getName()).thenReturn(TEST_METHOD_NAME); + when(result1.getStartMillis()).thenReturn(startTime); + when(result1.getEndMillis()).thenReturn(test1EndTime); + when(result1.getStatus()).thenReturn(JUnitXmlReporter.TestResult.SUCCESS); + reporter.onTestSuccess(result1); + + reporter.onFinish(coverageReport); + assertThat(outputFile.exists()).isTrue(); + String concatenatedFileContent = String.join("\n", Files.readAllLines(outputFile.toPath())); + + assertThat(concatenatedFileContent) + .contains( + ""); + + outputFile.delete(); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/LateFunctionBindingUserTest.java b/testing/src/test/java/dev/cel/testing/testrunner/LateFunctionBindingUserTest.java new file mode 100644 index 000000000..72992be3f --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/LateFunctionBindingUserTest.java @@ -0,0 +1,35 @@ +// Copyright 2025 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.testing.testrunner; + +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelLateFunctionBindings; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/** This test demonstrates the use case where the function bindings are provided at eval stage. */ +@RunWith(Parameterized.class) +public class LateFunctionBindingUserTest extends CelUserTestTemplate { + + public LateFunctionBindingUserTest() { + super( + CelTestContext.newBuilder() + .setCelLateFunctionBindings( + CelLateFunctionBindings.from( + CelFunctionBinding.from("foo_id", String.class, (String a) -> a.equals("foo")), + CelFunctionBinding.from("bar_id", String.class, (String a) -> a.equals("bar")))) + .build()); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/TestRunnerLibraryTest.java b/testing/src/test/java/dev/cel/testing/testrunner/TestRunnerLibraryTest.java new file mode 100644 index 000000000..112ef1f82 --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/TestRunnerLibraryTest.java @@ -0,0 +1,355 @@ +// Copyright 2025 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.testing.testrunner; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.protobuf.Any; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.util.TestUtil; +import dev.cel.bundle.CelFactory; +import dev.cel.checker.ProtoTypeMask; +import dev.cel.common.types.SimpleType; +import dev.cel.expr.conformance.proto3.TestAllTypes; +import dev.cel.testing.testrunner.CelTestSuite.CelTestSection.CelTestCase; +import java.util.Map; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class TestRunnerLibraryTest { + + @Before + public void setUp() { + System.setProperty("is_raw_expr", "False"); + } + + @Test + public void runPolicyTest_simpleBooleanOutput() throws Exception { + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("simple_output_test_case") + .setDescription("simple_output_test_case_description") + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofResultValue(false)) + .build(); + + TestRunnerLibrary.evaluateTestCase( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setCelExpression( + CelExpressionSource.fromSource( + TestUtil.getSrcDir() + + "/google3/third_party/java/cel/testing/src/test/java/dev/cel/testing/testrunner/resources/empty_policy.yaml")) + .build()); + } + + @Test + public void triggerRunTest_evaluatePolicy_simpleBooleanOutput() throws Exception { + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("simple_output_test_case") + .setDescription("simple_output_test_case_description") + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofResultValue(false)) + .build(); + + TestRunnerLibrary.runTest( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setCelExpression( + CelExpressionSource.fromSource( + TestUtil.getSrcDir() + + "/google3/third_party/java/cel/testing/src/test/java/dev/cel/testing/testrunner/resources/empty_policy.yaml")) + .build()); + } + + @Test + public void triggerRunTest_evaluateRawExpr_simpleBooleanOutput() throws Exception { + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("simple_output_test_case") + .setDescription("simple_output_test_case_description") + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofResultValue(true)) + .build(); + + TestRunnerLibrary.runTest( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setCelExpression(CelExpressionSource.fromRawExpr("1 > 0")) + .build()); + } + + @Test + public void runPolicyTest_outputMismatch_failureAssertion() throws Exception { + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("output_mismatch_test_case") + .setDescription("output_mismatch_test_case_description") + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofResultValue(true)) + .build(); + + AssertionError thrown = + assertThrows( + AssertionError.class, + () -> + TestRunnerLibrary.evaluateTestCase( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setCelExpression( + CelExpressionSource.fromSource( + TestUtil.getSrcDir() + + "/google3/third_party/java/cel/testing/src/test/java/dev/cel/testing/testrunner/resources/empty_policy.yaml")) + .build())); + + assertThat(thrown).hasMessageThat().contains("modified: value.bool_value: true -> false"); + } + + @Test + public void runPolicyTest_evaluatedContextExprNotProtoMessage_failure() throws Exception { + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("output_mismatch_test_case") + .setDescription("output_mismatch_test_case_description") + .setInput(CelTestSuite.CelTestSection.CelTestCase.Input.ofContextExpr("1 > 2")) + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofResultValue(false)) + .build(); + + IllegalArgumentException thrown = + assertThrows( + IllegalArgumentException.class, + () -> + TestRunnerLibrary.evaluateTestCase( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setCelExpression( + CelExpressionSource.fromSource( + TestUtil.getSrcDir() + + "/google3/third_party/java/cel/testing/src/test/java/dev/cel/testing/testrunner/resources/empty_policy.yaml")) + .setCel( + CelFactory.standardCelBuilder() + .addFileTypes(TestAllTypes.getDescriptor().getFile()) + .addProtoTypeMasks( + ProtoTypeMask.ofAllFields( + TestAllTypes.getDescriptor().getFullName()) + .withFieldsAsVariableDeclarations()) + .build()) + .build())); + + assertThat(thrown) + .hasMessageThat() + .contains("Context expression must evaluate to a proto message."); + } + + @Test + public void runPolicyTest_evaluationError_failureAssertion() throws Exception { + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("evaluation_error_test_case") + .setDescription("evaluation_error_test_case_description") + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofResultValue(false)) + .build(); + + AssertionError thrown = + assertThrows( + AssertionError.class, + () -> + TestRunnerLibrary.evaluateTestCase( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setVariableBindings(ImmutableMap.of("x", 1L)) + .setCelExpression( + CelExpressionSource.fromSource( + TestUtil.getSrcDir() + + "/google3/third_party/java/cel/testing/src/test/java/dev/cel/testing/testrunner/resources/eval_error_policy.yaml")) + .setCel(CelFactory.standardCelBuilder().addVar("x", SimpleType.INT).build()) + .build())); + + assertThat(thrown) + .hasMessageThat() + .contains( + "Error: Evaluation failed for test case: evaluation_error_test_case." + + " Error: evaluation error: / by zero"); + } + + @Test + public void runExpressionTest_outputMismatch_failureAssertion() throws Exception { + System.setProperty( + "cel_expr", + TestUtil.getSrcDir() + + "/google3/third_party/java/cel/testing/src/test/java/dev/cel/testing/testrunner/output.textproto"); + + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("output_mismatch_test_case") + .setDescription("output_mismatch_test_case_description") + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofResultValue(true)) + .build(); + + AssertionError thrown = + assertThrows( + AssertionError.class, + () -> + TestRunnerLibrary.runTest( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setCelExpression( + CelExpressionSource.fromSource( + TestUtil.getSrcDir() + + "/google3/third_party/java/cel/testing/src/test/java/dev/cel/testing/testrunner/output.textproto")) + .setCel(CelFactory.standardCelBuilder().build()) + .build())); + + assertThat(thrown).hasMessageThat().contains("modified: value.bool_value: true -> false"); + } + + @Test + public void runTest_illegalFileType_failure() throws Exception { + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("illegal_file_type_test_case") + .setDescription("illegal_file_type_test_case_description") + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofNoOutput()) + .build(); + + IllegalArgumentException thrown = + assertThrows( + IllegalArgumentException.class, + () -> + TestRunnerLibrary.runTest( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setCelExpression(CelExpressionSource.fromSource("output.txt")) + .build())); + + assertThat(thrown).hasMessageThat().contains("Unsupported expression file type: output.txt"); + } + + @Test + public void runTest_missingProtoDescriptors_failure() throws Exception { + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("missing_file_descriptor_set_path_test_case") + .setDescription("missing_file_descriptor_set_path_test_case_description") + .setInput( + CelTestSuite.CelTestSection.CelTestCase.Input.ofContextMessage( + Any.pack(TestAllTypes.getDefaultInstance()))) + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofNoOutput()) + .build(); + + IllegalArgumentException thrown = + assertThrows( + IllegalArgumentException.class, + () -> + TestRunnerLibrary.runTest( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setCelExpression(CelExpressionSource.fromRawExpr("true")) + .build())); + + assertThat(thrown) + .hasMessageThat() + .contains("Proto descriptors or type registry are required for unpacking Any messages"); + } + + @Test + public void triggerRunTest_evaluateRawExpr_withCoverage() throws Exception { + CelCoverageIndex celCoverageIndex = new CelCoverageIndex(); + CelTestCase simpleOutputTestCase = + CelTestCase.newBuilder() + .setName("simple_output_test_case") + .setDescription("simple_output_test_case_description") + .setOutput(CelTestSuite.CelTestSection.CelTestCase.Output.ofResultValue(true)) + .build(); + + TestRunnerLibrary.runTest( + simpleOutputTestCase, + CelTestContext.newBuilder() + .setCelExpression(CelExpressionSource.fromRawExpr("1 > 0")) + .build(), + celCoverageIndex); + } + + @Test + public void runTest_withBindingTransformer() throws Exception { + CelTestCase testCase = + CelTestCase.newBuilder() + .setName("binding_transformer_test") + .setDescription("Test binding transformer") + .setInput( + CelTestCase.Input.ofBindings( + ImmutableMap.of("x", CelTestCase.Input.Binding.ofValue(1L)))) + .setOutput(CelTestCase.Output.ofResultValue(3L)) // 1 + 1 (transformed) + 1 (expr) = 3 + .build(); + + TestRunnerLibrary.evaluateTestCase( + testCase, + CelTestContext.newBuilder() + .setCelExpression(CelExpressionSource.fromRawExpr("x + 1")) + .setCel(CelFactory.standardCelBuilder().addVar("x", SimpleType.INT).build()) + .setBindingTransformer( + bindings -> { + ImmutableMap.Builder transformed = ImmutableMap.builder(); + for (Map.Entry entry : bindings.entrySet()) { + if (entry.getKey().equals("x")) { + transformed.put("x", (Long) entry.getValue() + 1L); + } else { + transformed.put(entry); + } + } + return transformed.buildOrThrow(); + }) + .build()); + } + + @Test + public void runTest_withMessageTypes() throws Exception { + CelTestCase testCase = + CelTestCase.newBuilder() + .setName("message_types_consolidation_test") + .setDescription("Test message types consolidation") + .setOutput(CelTestCase.Output.ofResultValue(true)) + .build(); + + TestRunnerLibrary.evaluateTestCase( + testCase, + CelTestContext.newBuilder() + .setCelExpression( + CelExpressionSource.fromRawExpr( + "cel.expr.conformance.proto3.TestAllTypes{single_int64: 1} ==" + + " cel.expr.conformance.proto3.TestAllTypes{single_int64: 1}")) + .addMessageTypes(TestAllTypes.getDescriptor()) + .build()); + } + + @Test + public void typeRegistry_withFileTypes() throws Exception { + CelTestContext celTestContext = + CelTestContext.newBuilder() + .setCelExpression(CelExpressionSource.fromRawExpr("true")) + .setCel(CelFactory.standardCelBuilder().build()) + .addMessageTypes(TestAllTypes.getDescriptor()) + .build(); + + assertThat( + celTestContext + .typeRegistry() + .get() + .find("cel.expr.conformance.proto3.TestAllTypes") + .getFullName()) + .isEqualTo("cel.expr.conformance.proto3.TestAllTypes"); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/UserTest.java b/testing/src/test/java/dev/cel/testing/testrunner/UserTest.java new file mode 100644 index 000000000..6f4c838dd --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/UserTest.java @@ -0,0 +1,39 @@ +// Copyright 2025 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.testing.testrunner; + +import dev.cel.bundle.CelFactory; +import dev.cel.common.types.MapType; +import dev.cel.common.types.SimpleType; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/** + * A sample test class for demonstrating the use of the CEL test runner when no config file is + * provided. + */ +@RunWith(Parameterized.class) +public class UserTest extends CelUserTestTemplate { + + public UserTest() { + super( + CelTestContext.newBuilder() + .setCel( + CelFactory.standardCelBuilder() + .addVar("resource", MapType.create(SimpleType.STRING, SimpleType.ANY)) + .build()) + .build()); + } +} diff --git a/testing/src/test/java/dev/cel/testing/testrunner/resources/empty_policy.yaml b/testing/src/test/java/dev/cel/testing/testrunner/resources/empty_policy.yaml new file mode 100644 index 000000000..ea6863dfd --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/resources/empty_policy.yaml @@ -0,0 +1,17 @@ +# Copyright 2025 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. + +rule: + match: + - output: 'false' diff --git a/testing/src/test/java/dev/cel/testing/testrunner/resources/eval_error_policy.yaml b/testing/src/test/java/dev/cel/testing/testrunner/resources/eval_error_policy.yaml new file mode 100644 index 000000000..e97295c84 --- /dev/null +++ b/testing/src/test/java/dev/cel/testing/testrunner/resources/eval_error_policy.yaml @@ -0,0 +1,20 @@ +# Copyright 2025 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. + +name: "evaluation_error_policy" +rule: + match: + - condition: "x/0 == 0" + output: "false" + - output: "true" diff --git a/testing/src/test/resources/environment/BUILD.bazel b/testing/src/test/resources/environment/BUILD.bazel new file mode 100644 index 000000000..30bd3c8c1 --- /dev/null +++ b/testing/src/test/resources/environment/BUILD.bazel @@ -0,0 +1,49 @@ +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//testing/environment:__pkg__", + ], +) + +filegroup( + name = "dump_env", + srcs = ["dump_env.yaml"], +) + +filegroup( + name = "extended_env", + srcs = ["extended_env.yaml"], +) + +filegroup( + name = "all_extensions", + srcs = ["all_extensions.yaml"], +) + +filegroup( + name = "primitive_variables", + srcs = ["primitive_variables.yaml"], +) + +filegroup( + name = "custom_functions", + srcs = ["custom_functions.yaml"], +) + +filegroup( + name = "library_subset_env", + srcs = ["subset_env.yaml"], +) + +filegroup( + name = "proto2_message_variables", + srcs = ["proto2_message_variables.yaml"], +) + +filegroup( + name = "proto3_message_variables", + srcs = ["proto3_message_variables.yaml"], +) diff --git a/testing/src/test/resources/environment/all_extensions.yaml b/testing/src/test/resources/environment/all_extensions.yaml new file mode 100644 index 000000000..623a0fb5b --- /dev/null +++ b/testing/src/test/resources/environment/all_extensions.yaml @@ -0,0 +1,24 @@ +# Copyright 2025 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. + +name: "all-extensions" +extensions: +- name: "bindings" +- name: "encoders" +- name: "lists" +- name: "math" +- name: "optional" +- name: "protos" +- name: "sets" +- name: "strings" diff --git a/testing/src/test/resources/environment/custom_functions.yaml b/testing/src/test/resources/environment/custom_functions.yaml new file mode 100644 index 000000000..9aab223ae --- /dev/null +++ b/testing/src/test/resources/environment/custom_functions.yaml @@ -0,0 +1,31 @@ +# Copyright 2025 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. + +name: "custom-functions" +functions: +- name: "isEmpty" + overloads: + - id: "string_isEmpty" + target: + type_name: "string" + return: + type_name: "bool" + - id: "list_isEmpty" + target: + type_name: "list" + params: + - type_name: "T" + is_type_param: true + return: + type_name: "bool" \ No newline at end of file diff --git a/testing/src/test/resources/environment/dump_env.yaml b/testing/src/test/resources/environment/dump_env.yaml new file mode 100644 index 000000000..a5ed23753 --- /dev/null +++ b/testing/src/test/resources/environment/dump_env.yaml @@ -0,0 +1,131 @@ +# Copyright 2025 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. + +name: dump_env +description: dump_env description +container: + name: test.container + abbreviations: + - abbr1.Abbr1 + - abbr2.Abbr2 + aliases: + - alias: alias1 + qualified_name: qual.name1 + - alias: alias2 + qualified_name: qual.name2 +extensions: +- name: bindings +- name: encoders +- name: lists +- name: math +- name: optional +- name: protos +- name: sets +- name: strings + version: 1 +variables: +- name: request + type_name: google.rpc.context.AttributeContext.Request +- name: map_var + type_name: map + params: + - type_name: string + - type_name: string +functions: +- name: getOrDefault + overloads: + - id: getOrDefault_key_value + target: + type_name: map + params: + - type_name: K + is_type_param: true + - type_name: V + is_type_param: true + args: + - type_name: K + is_type_param: true + - type_name: V + is_type_param: true + return: + type_name: V + is_type_param: true +- name: zip + overloads: + - id: zip_list_int_list_int + args: + - type_name: list + params: + - type_name: int + - type_name: list + params: + - type_name: int + return: + type_name: list + params: + - type_name: list + params: + - type_name: int +- name: zipGeneric + overloads: + - id: zip_list_list + args: + - type_name: list + params: + - type_name: T + is_type_param: true + - type_name: list + params: + - type_name: T + is_type_param: true + return: + type_name: list + params: + - type_name: list + params: + - type_name: T + is_type_param: true +- name: coalesce + overloads: + - id: coalesce_null_int + target: + type_name: google.protobuf.Int64Value + args: + - type_name: int + return: + type_name: int +stdlib: + disabled: true + disable_macros: true + include_macros: + - exists + - has + include_functions: + - name: _!=_ + - name: _+_ + overloads: + - id: add_bytes + - id: add_list +features: +- name: cel.feature.macro_call_tracking + enabled: true +- name: cel.feature.backtick_escape_syntax + enabled: false +limits: +- name: cel.limit.expression_code_points + value: 1000 +- name: cel.limit.parse_error_recovery + value: 10 +- name: cel.limit.parse_recursion_depth + value: 7 diff --git a/testing/src/test/resources/environment/extended_env.yaml b/testing/src/test/resources/environment/extended_env.yaml new file mode 100644 index 000000000..9fc2d511d --- /dev/null +++ b/testing/src/test/resources/environment/extended_env.yaml @@ -0,0 +1,66 @@ +# Copyright 2025 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. + +name: "extended-env" +container: "cel.expr" +extensions: +- name: "optional" + version: "2" +- name: "math" + version: "latest" +variables: +- name: "msg" + type_name: "cel.expr.conformance.proto3.TestAllTypes" + description: >- + msg represents all possible type permutation which + CEL understands from a proto perspective +functions: +- name: "isEmpty" + description: |- + determines whether a list is empty, + or a string has no characters + overloads: + - id: "wrapper_string_isEmpty" + examples: + - "''.isEmpty() // true" + target: + type_name: "google.protobuf.StringValue" + return: + type_name: "bool" + - id: "list_isEmpty" + examples: + - "[].isEmpty() // true" + - "[1].isEmpty() // false" + target: + type_name: "list" + params: + - type_name: "T" + is_type_param: true + return: + type_name: "bool" +features: +- name: cel.feature.macro_call_tracking + enabled: true +limits: +- name: cel.limit.expression_code_points + value: 1000 +- cel.limit.parse_recursion_depth: 7 +# TODO: Add support for below +#validators: +#- name: cel.validator.duration +#- name: cel.validator.matches +#- name: cel.validator.timestamp +#- name: cel.validator.nesting_comprehension_limit +# config: +# limit: 2 diff --git a/testing/src/test/resources/environment/primitive_variables.yaml b/testing/src/test/resources/environment/primitive_variables.yaml new file mode 100644 index 000000000..f92f704a8 --- /dev/null +++ b/testing/src/test/resources/environment/primitive_variables.yaml @@ -0,0 +1,28 @@ +# Copyright 2025 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. + +name: "primitive-variables" +variables: +- name: "bool_var" + type_name: "bool" +- name: "bytes_var" + type_name: "bytes" +- name: "double_var" + type_name: "double" +- name: "int_var" + type_name: "int" +- name: "uint_var" + type_name: "uint" +- name: "str_var" + type_name: "string" \ No newline at end of file diff --git a/testing/src/test/resources/environment/proto2_message_variables.yaml b/testing/src/test/resources/environment/proto2_message_variables.yaml new file mode 100644 index 000000000..ac06fb1a2 --- /dev/null +++ b/testing/src/test/resources/environment/proto2_message_variables.yaml @@ -0,0 +1,18 @@ +# Copyright 2025 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. + +name: "proto2-message-variables" +variables: +- name: "proto2" + type_name: "cel.expr.conformance.proto2.TestAllTypes" diff --git a/testing/src/test/resources/environment/proto3_message_variables.yaml b/testing/src/test/resources/environment/proto3_message_variables.yaml new file mode 100644 index 000000000..12f39c7fa --- /dev/null +++ b/testing/src/test/resources/environment/proto3_message_variables.yaml @@ -0,0 +1,18 @@ +# Copyright 2025 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. + +name: "proto3-message-variables" +variables: +- name: "proto3" + type_name: "cel.expr.conformance.proto3.TestAllTypes" diff --git a/testing/src/test/resources/environment/subset_env.yaml b/testing/src/test/resources/environment/subset_env.yaml new file mode 100644 index 000000000..f721a1426 --- /dev/null +++ b/testing/src/test/resources/environment/subset_env.yaml @@ -0,0 +1,39 @@ +# Copyright 2025 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. + +name: "subset-env" +stdlib: + exclude_macros: + - map + - filter + exclude_functions: + - name: "_+_" + overloads: + - id: add_bytes + - id: add_list + - id: add_string + - name: "matches" + - name: "timestamp" + overloads: + - id: "string_to_timestamp" + - name: "duration" + overloads: + - id: "string_to_duration" +variables: +- name: "x" + type_name: "int" +- name: "y" + type_name: "double" +- name: "z" + type_name: "uint" diff --git a/testing/src/test/resources/expressions/BUILD.bazel b/testing/src/test/resources/expressions/BUILD.bazel new file mode 100644 index 000000000..3d3415718 --- /dev/null +++ b/testing/src/test/resources/expressions/BUILD.bazel @@ -0,0 +1,16 @@ +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//testing:__pkg__", + ], +) + +exports_files( + srcs = glob([ + "**/*.cel", + "**/*.textproto", + ]), +) diff --git a/testing/src/test/resources/expressions/coverage_test_case/partial_coverage_tests.textproto b/testing/src/test/resources/expressions/coverage_test_case/partial_coverage_tests.textproto new file mode 100644 index 000000000..61b57637c --- /dev/null +++ b/testing/src/test/resources/expressions/coverage_test_case/partial_coverage_tests.textproto @@ -0,0 +1,26 @@ +# proto-file: google3/third_party/cel/spec/proto/cel/expr/conformance/test/suite.proto +# proto-message: cel.expr.conformance.test.TestSuite + +name: "partial_coverage_tests" +description: "Tests for partial coverage." +sections: { + name: "simple_map_operations" + description: "Tests for map operations." + tests: { + name: "literal_and_sum" + description: "Test that a map can be created and values can be accessed." + input: { + key: "x" + value { value { int64_value: 2 } } + } + input { + key: "y" + value { value { int64_value: 2 } } + } + output { + result_value { + bool_value: true + } + } + } +} diff --git a/testing/src/test/resources/expressions/coverage_test_case/simple_expression.cel b/testing/src/test/resources/expressions/coverage_test_case/simple_expression.cel new file mode 100644 index 000000000..0e8256613 --- /dev/null +++ b/testing/src/test/resources/expressions/coverage_test_case/simple_expression.cel @@ -0,0 +1 @@ +{'sum': x + y, 'literal': 3}.sum == 3 || x == y \ No newline at end of file diff --git a/testing/src/test/resources/expressions/coverage_test_case/tests.textproto b/testing/src/test/resources/expressions/coverage_test_case/tests.textproto new file mode 100644 index 000000000..fefee8d6c --- /dev/null +++ b/testing/src/test/resources/expressions/coverage_test_case/tests.textproto @@ -0,0 +1,26 @@ +# proto-file: google3/third_party/cel/spec/proto/cel/expr/conformance/test/suite.proto +# proto-message: cel.expr.conformance.test.TestSuite + +name: "coverage_tests" +description: "Tests for coverage." +sections: { + name: "simple_map_operations" + description: "Tests for map operations." + tests: { + name: "literal_and_sum" + description: "Test that a map can be created and values can be accessed." + input: { + key: "x" + value { value { int64_value: 1 } } + } + input { + key: "y" + value { value { int64_value: 2 } } + } + output { + result_value { + bool_value: true + } + } + } +} diff --git a/testing/src/test/resources/expressions/simple_test_case/simple_expression.cel b/testing/src/test/resources/expressions/simple_test_case/simple_expression.cel new file mode 100644 index 000000000..e120ebc26 --- /dev/null +++ b/testing/src/test/resources/expressions/simple_test_case/simple_expression.cel @@ -0,0 +1 @@ +2 + 2 == 4 \ No newline at end of file diff --git a/testing/src/test/resources/expressions/simple_test_case/tests.textproto b/testing/src/test/resources/expressions/simple_test_case/tests.textproto new file mode 100644 index 000000000..2a431d62f --- /dev/null +++ b/testing/src/test/resources/expressions/simple_test_case/tests.textproto @@ -0,0 +1,18 @@ +# proto-file: google3/third_party/cel/spec/proto/cel/expr/conformance/test/suite.proto +# proto-message: cel.expr.conformance.test.TestSuite + +name: "expr_value_output_tests" +description: "Value as expected output" +sections { + name: "basic value" + description: "Basic value" + tests { + name: "basic value test" + description: "Basic value test" + output { + result_value { + bool_value: true + } + } + } +} \ No newline at end of file diff --git a/testing/src/test/resources/policy/BUILD.bazel b/testing/src/test/resources/policy/BUILD.bazel new file mode 100644 index 000000000..fc9971704 --- /dev/null +++ b/testing/src/test/resources/policy/BUILD.bazel @@ -0,0 +1,28 @@ +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//testing:__subpackages__", + ], +) + +filegroup( + name = "policy_yaml_files", + srcs = glob([ + "**/*.yaml", + "**/*.celpolicy", + "**/*.baseline", + "**/*.textproto", + ]), +) + +exports_files( + srcs = glob([ + "**/*.yaml", + "**/*.baseline", + "**/*.celpolicy", + "**/*.textproto", + ]), +) diff --git a/testing/src/test/resources/policy/compose_conflicting_output/expected_errors.baseline b/testing/src/test/resources/policy/compose_conflicting_output/expected_errors.baseline new file mode 100644 index 000000000..241fca0f6 --- /dev/null +++ b/testing/src/test/resources/policy/compose_conflicting_output/expected_errors.baseline @@ -0,0 +1,6 @@ +ERROR: compose_conflicting_output/policy.yaml:22:14: incompatible output types: block has output type map(string, bool), but previous outputs have type bool + | output: "false" + | .............^ +ERROR: compose_conflicting_output/policy.yaml:23:14: incompatible output types: block has output type map(string, bool), but previous outputs have type bool + | - output: "{'banned': true}" + | .............^ \ No newline at end of file diff --git a/testing/src/test/resources/policy/compose_conflicting_subrule/expected_errors.baseline b/testing/src/test/resources/policy/compose_conflicting_subrule/expected_errors.baseline new file mode 100644 index 000000000..663821b52 --- /dev/null +++ b/testing/src/test/resources/policy/compose_conflicting_subrule/expected_errors.baseline @@ -0,0 +1,6 @@ +ERROR: compose_conflicting_subrule/policy.yaml:34:18: failed composing the subrule 'banned regions' due to incompatible output types. + | output: "true" + | .................^ +ERROR: compose_conflicting_subrule/policy.yaml:36:14: failed composing the subrule 'banned regions' due to incompatible output types. + | output: "{'banned': false}" + | .............^ \ No newline at end of file diff --git a/testing/src/test/resources/policy/context_pb/context_msg_tests.textproto b/testing/src/test/resources/policy/context_pb/context_msg_tests.textproto new file mode 100644 index 000000000..aa5d5051c --- /dev/null +++ b/testing/src/test/resources/policy/context_pb/context_msg_tests.textproto @@ -0,0 +1,23 @@ +# proto-file: google3/third_party/cel/spec/proto/cel/expr/conformance/test/suite.proto +# proto-message: cel.expr.conformance.test.TestSuite + +name: "context_msg_tests" +description: "Protobuf input tests" +sections { + name: "valid" + description: "Valid protobuf input tests" + tests { + name: "good spec" + description: "Valid protobuf input tests" + input_context { + context_message { + [type.googleapis.com/cel.expr.conformance.proto3.TestAllTypes] { + single_int32: 10 + } + } + } + output { + result_expr: "optional.none()" + } + } +} diff --git a/testing/src/test/resources/policy/custom_variable_bindings/config.yaml b/testing/src/test/resources/policy/custom_variable_bindings/config.yaml new file mode 100644 index 000000000..83b3685c3 --- /dev/null +++ b/testing/src/test/resources/policy/custom_variable_bindings/config.yaml @@ -0,0 +1,22 @@ +# Copyright 2025 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. + +name: "custom_variable_bindings" +container: "cel.expr.conformance.proto2" +variables: + - name: "spec" + type: + type_name: "cel.expr.conformance.proto2.TestAllTypes" +extensions: +- name: "protos" \ No newline at end of file diff --git a/testing/src/test/resources/policy/custom_variable_bindings/policy.yaml b/testing/src/test/resources/policy/custom_variable_bindings/policy.yaml new file mode 100644 index 000000000..7a94eebd2 --- /dev/null +++ b/testing/src/test/resources/policy/custom_variable_bindings/policy.yaml @@ -0,0 +1,20 @@ +# Copyright 2025 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. + +name: "custom_variable_bindings" +rule: + match: + - condition: proto.getExt(spec, cel.expr.conformance.proto2.int32_ext) > 0 + output: "true" + - output: "false" \ No newline at end of file diff --git a/testing/src/test/resources/policy/custom_variable_bindings/tests.yaml b/testing/src/test/resources/policy/custom_variable_bindings/tests.yaml new file mode 100644 index 000000000..dd924141c --- /dev/null +++ b/testing/src/test/resources/policy/custom_variable_bindings/tests.yaml @@ -0,0 +1,26 @@ +# Copyright 2025 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. + +name: "custom_variable_bindings" +description: "Tests for custom variable bindings." +sections: + - name: "custom_variable_bindings" + description: "Tests for custom variable bindings." + tests: + - name: "true_by_default" + description: "Tests that the custom variable bindings are set to true by default." + # The input for this test is configured programmatically in the test + # class with a value of 1 (see CustomVariableBindingsUserTest.java). + output: + expr: "true" \ No newline at end of file diff --git a/testing/src/test/resources/policy/duplicate_variable/expected_errors.baseline b/testing/src/test/resources/policy/duplicate_variable/expected_errors.baseline new file mode 100644 index 000000000..b1025bb60 --- /dev/null +++ b/testing/src/test/resources/policy/duplicate_variable/expected_errors.baseline @@ -0,0 +1,3 @@ +ERROR: duplicate_variable/policy.yaml:23:19: overlapping declaration name 'variables.want' (type 'int' cannot be distinguished from 'string') + | - condition: "true" + | ..................^ diff --git a/testing/src/test/resources/policy/expr_value_output/policy.yaml b/testing/src/test/resources/policy/expr_value_output/policy.yaml new file mode 100644 index 000000000..9a49ab808 --- /dev/null +++ b/testing/src/test/resources/policy/expr_value_output/policy.yaml @@ -0,0 +1,19 @@ +# Copyright 2025 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. + +name: "value_as_output" +rule: + match: + - condition: 2 + 2 == 4 + output: "true" diff --git a/testing/src/test/resources/policy/expr_value_output/tests.textproto b/testing/src/test/resources/policy/expr_value_output/tests.textproto new file mode 100644 index 000000000..2a431d62f --- /dev/null +++ b/testing/src/test/resources/policy/expr_value_output/tests.textproto @@ -0,0 +1,18 @@ +# proto-file: google3/third_party/cel/spec/proto/cel/expr/conformance/test/suite.proto +# proto-message: cel.expr.conformance.test.TestSuite + +name: "expr_value_output_tests" +description: "Value as expected output" +sections { + name: "basic value" + description: "Basic value" + tests { + name: "basic value test" + description: "Basic value test" + output { + result_value { + bool_value: true + } + } + } +} \ No newline at end of file diff --git a/testing/src/test/resources/policy/import/expected_errors.baseline b/testing/src/test/resources/policy/import/expected_errors.baseline new file mode 100644 index 000000000..b88402b8c --- /dev/null +++ b/testing/src/test/resources/policy/import/expected_errors.baseline @@ -0,0 +1,6 @@ +ERROR: import/policy.yaml:19:7: Error configuring import: invalid qualified name: punc.Import!, wanted name of the form 'qualified.name' + | punc.Import! + | ......^ +ERROR: import/policy.yaml:20:12: Error configuring import: invalid qualified name: bad import, wanted name of the form 'qualified.name' + | - name: "bad import" + | ...........^ diff --git a/testing/src/test/resources/policy/incompatible_outputs/expected_errors.baseline b/testing/src/test/resources/policy/incompatible_outputs/expected_errors.baseline new file mode 100644 index 000000000..be370847f --- /dev/null +++ b/testing/src/test/resources/policy/incompatible_outputs/expected_errors.baseline @@ -0,0 +1,6 @@ +ERROR: incompatible_outputs/policy.yaml:19:16: incompatible output types: block has output type optional_type(string), but previous outputs have type bool + | output: "true" + | ...............^ +ERROR: incompatible_outputs/policy.yaml:21:16: incompatible output types: block has output type optional_type(string), but previous outputs have type bool + | output: "'false'" + | ...............^ diff --git a/testing/src/test/resources/policy/late_function_binding/config.yaml b/testing/src/test/resources/policy/late_function_binding/config.yaml new file mode 100644 index 000000000..423db293b --- /dev/null +++ b/testing/src/test/resources/policy/late_function_binding/config.yaml @@ -0,0 +1,34 @@ +# Copyright 2025 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. + +name: "late_function_binding" +functions: + - name: "foo" + overloads: + - id: 'foo_id' + args: + - type_name: 'string' + return: + type_name: 'bool' + - name: "bar" + overloads: + - id: 'bar_id' + args: + - type_name: 'string' + return: + type_name: 'bool' +variables: + - name: "a" + type: + type_name: 'string' \ No newline at end of file diff --git a/testing/src/test/resources/policy/late_function_binding/policy.celpolicy b/testing/src/test/resources/policy/late_function_binding/policy.celpolicy new file mode 100644 index 000000000..15cc503e9 --- /dev/null +++ b/testing/src/test/resources/policy/late_function_binding/policy.celpolicy @@ -0,0 +1,20 @@ +# Copyright 2025 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. + +name: "late_function_binding" +rule: + match: + - condition: foo(a) || bar(a) + output: "true" + - output: "false" diff --git a/testing/src/test/resources/policy/late_function_binding/tests.textproto b/testing/src/test/resources/policy/late_function_binding/tests.textproto new file mode 100644 index 000000000..38f53501b --- /dev/null +++ b/testing/src/test/resources/policy/late_function_binding/tests.textproto @@ -0,0 +1,41 @@ +# proto-file: google3/third_party/cel/spec/proto/cel/expr/conformance/test/suite.proto +# proto-message: cel.expr.conformance.test.TestSuite + +name: "late_function_binding_tests" +description: "Tests for late function binding." +sections: { + name: "late_function_binding_tests_section" + description: "Tests for late function binding." + tests: { + name: "true_by_default" + description: "Test that the default value of a late function binding is true." + input: { + key: "a" + value: { + expr: "'foo'" + } + } + output: { + result_value: { + bool_value: true + } + } + } + tests: { + name: "false_by_default" + description: "Test that the default value of a late function binding is false." + input: { + key: "a" + value: { + value: { + string_value: "baz" + } + } + } + output { + result_value { + bool_value: false + } + } + } +} diff --git a/testing/src/test/resources/policy/late_function_binding/tests.yaml b/testing/src/test/resources/policy/late_function_binding/tests.yaml new file mode 100644 index 000000000..cfdaa7ca3 --- /dev/null +++ b/testing/src/test/resources/policy/late_function_binding/tests.yaml @@ -0,0 +1,34 @@ +# Copyright 2025 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. + +name: "late_function_binding_tests" +description: "Tests for late function binding." +sections: + - name: "late_function_binding_tests_section" + description: "Tests for late function binding." + tests: + - name: "true_by_default" + description: "Test that the default value of a late function binding is true." + input: + a: + expr: "'foo'" + output: + value: true + - name: "false_by_default" + description: "Test that the default value of a late function binding is false." + input: + a: + value: "baz" + output: + value: false \ No newline at end of file diff --git a/testing/src/test/resources/policy/nested_rule/config.textproto b/testing/src/test/resources/policy/nested_rule/config.textproto new file mode 100644 index 000000000..94fff8898 --- /dev/null +++ b/testing/src/test/resources/policy/nested_rule/config.textproto @@ -0,0 +1,14 @@ +# proto-file: google3/google/api/expr/conformance/env_config.proto +# proto-message: google.api.expr.conformance.Environment + +declarations: { + name: "resource" + ident { + type { + map_type { + key_type { primitive: STRING } + value_type { well_known: ANY } + } + } + } +} \ No newline at end of file diff --git a/testing/src/test/resources/policy/nested_rule/eval_error_config.yaml b/testing/src/test/resources/policy/nested_rule/eval_error_config.yaml new file mode 100644 index 000000000..2c4863027 --- /dev/null +++ b/testing/src/test/resources/policy/nested_rule/eval_error_config.yaml @@ -0,0 +1,30 @@ +# Copyright 2025 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. + +name: "nested_rule" +functions: + - name: "foo" + overloads: + - id: 'foo_id' + args: + - type_name: 'string' + return: + type_name: 'bool' +variables: + - name: "resource" + type: + type_name: "map" + params: + - type_name: "string" + - type_name: "dyn" \ No newline at end of file diff --git a/testing/src/test/resources/policy/nested_rule/eval_error_policy.yaml b/testing/src/test/resources/policy/nested_rule/eval_error_policy.yaml new file mode 100644 index 000000000..2f1233ea1 --- /dev/null +++ b/testing/src/test/resources/policy/nested_rule/eval_error_policy.yaml @@ -0,0 +1,38 @@ +# Copyright 2024 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. + +name: nested_rule_eval_error +rule: + variables: + - name: "permitted_regions" + expression: "['us', 'uk', 'es']" + match: + - rule: + id: "banned regions" + description: > + determine whether the resource origin is in the banned + list. If the region is also in the permitted list, the + ban has no effect. + variables: + - name: "banned_regions" + expression: "{'us': false, 'ru': false, 'ir': false}" + match: + - condition: | + resource.origin in variables.banned_regions && + !(resource.origin in variables.permitted_regions) + output: "{'banned': true}" + - condition: foo(resource.origin) && resource.origin in variables.permitted_regions + output: "{'banned': false}" + - output: "{'banned': true}" + explanation: "'resource is in the banned region ' + resource.origin" \ No newline at end of file diff --git a/testing/src/test/resources/policy/nested_rule/eval_error_tests.textproto b/testing/src/test/resources/policy/nested_rule/eval_error_tests.textproto new file mode 100644 index 000000000..f841f660b --- /dev/null +++ b/testing/src/test/resources/policy/nested_rule/eval_error_tests.textproto @@ -0,0 +1,37 @@ +# proto-file: google3/third_party/cel/spec/proto/cel/expr/conformance/test/suite.proto +# proto-message: cel.expr.conformance.test.TestSuite +# This testcase is used to test the eval error output in the test runner which +# fails because the function is declared in the compiler but not in the runtime. + +name: "eval_error_tests" +description: "Nested rule conformance tests with eval errors" +sections { + name: "permitted" + description: "Permitted nested rule" + tests { + name: "valid_origin" + description: "Valid origin" + input { + key: "resource" + value { + value { + object_value { + [type.googleapis.com/google.protobuf.Struct] { + fields { + key: "origin" + value { string_value: "uk" } + } + } + } + } + } + } + output { + eval_error { + errors { + message: "evaluation error: No matching overload for function 'foo'. Overload candidates: foo_id" + } + } + } + } +} diff --git a/testing/src/test/resources/policy/nested_rule/eval_error_tests.yaml b/testing/src/test/resources/policy/nested_rule/eval_error_tests.yaml new file mode 100644 index 000000000..7c38c6b9c --- /dev/null +++ b/testing/src/test/resources/policy/nested_rule/eval_error_tests.yaml @@ -0,0 +1,29 @@ +# Copyright 2024 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. + +name: "eval_error" +description: evaluation error tests +sections: + - name: "eval_error" + description: "Tests for evaluation errors" + tests: + - name: "eval_error_no_matching_overload" + description: "No matching overload for function" + input: + resource: + value: + origin: "uk" + output: + error_set: + - "evaluation error: No matching overload for function 'foo'. Overload candidates: foo_id" diff --git a/testing/src/test/resources/policy/nested_rule/testrunner_unknown_output_tests.yaml b/testing/src/test/resources/policy/nested_rule/testrunner_unknown_output_tests.yaml new file mode 100644 index 000000000..ac916c7c6 --- /dev/null +++ b/testing/src/test/resources/policy/nested_rule/testrunner_unknown_output_tests.yaml @@ -0,0 +1,25 @@ +# Copyright 2024 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. + +name: "nested_rule" +description: Nested rule conformance tests +sections: + - name: "banned" + description: "Tests for the banned section." + tests: + - name: "restricted_origin" + description: "Tests that the ir origin is restricted." + output: + unknown: + - 4 \ No newline at end of file diff --git a/testing/src/test/resources/policy/nested_rule/tests.textproto b/testing/src/test/resources/policy/nested_rule/tests.textproto new file mode 100644 index 000000000..701175394 --- /dev/null +++ b/testing/src/test/resources/policy/nested_rule/tests.textproto @@ -0,0 +1,69 @@ +# proto-file: google3/google/api/expr/conformance/test_suite.proto +# proto-message: google.api.expr.conformance.TestSuite + +description: "Nested rule conformance tests" + +sections { + name: "valid" + tests { + name: "restricted_origin" + input { + key: "resource" + value { + expr_value { + object_value { + [type.googleapis.com/google.protobuf.Struct] { + fields { + key: "origin" + value { string_value: "ir" } + } + } + } + } + } + } + expr: "{'banned': true}" + } + tests { + name: "by_default" + input { + key: "resource" + value { + expr_value { + object_value { + [type.googleapis.com/google.protobuf.Struct] { + fields { + key: "origin" + value { string_value: "'de'" } + } + } + } + } + } + } + expr: "{'banned': true}" + } +} + +sections { + name: "permitted" + tests { + name: "valid_origin" + input { + key: "resource" + value { + expr_value { + object_value { + [type.googleapis.com/google.protobuf.Struct] { + fields { + key: "origin" + value { string_value: "uk" } + } + } + } + } + } + } + expr: "{'banned': false}" + } +} \ No newline at end of file diff --git a/testing/src/test/resources/policy/protoextension_value_as_input/tests.textproto b/testing/src/test/resources/policy/protoextension_value_as_input/tests.textproto new file mode 100644 index 000000000..455ac4bdc --- /dev/null +++ b/testing/src/test/resources/policy/protoextension_value_as_input/tests.textproto @@ -0,0 +1,31 @@ +# proto-file: google3/third_party/cel/spec/proto/cel/expr/conformance/test/suite.proto +# proto-message: cel.expr.conformance.test.TestSuite + +# The input binding is not used for evaluation, but rather to ensure +# extension registry generation and support for `Any` typed inputs with +# extensions. + +name: "protoextension_value_as_input" +description: "Valid proto extension value as input" +sections { + name: "valid" + description: "Valid proto extension value as input" + tests { + name: "value_extension_input" + input { + key: "spec" + value { + value { + object_value { + [type.googleapis.com/cel.expr.conformance.proto2.TestAllTypes] { + [cel.expr.conformance.proto2.Proto2ExtensionScopedMessage.message_scoped_nested_ext]: {} + } + } + } + } + } + output { + result_expr: "true" + } + } +} \ No newline at end of file diff --git a/testing/src/test/resources/policy/syntax/expected_errors.baseline b/testing/src/test/resources/policy/syntax/expected_errors.baseline new file mode 100644 index 000000000..dd6af277e --- /dev/null +++ b/testing/src/test/resources/policy/syntax/expected_errors.baseline @@ -0,0 +1,12 @@ +ERROR: syntax/policy.yaml:19:51: mismatched input 'resource' expecting {'==', '!=', 'in', '<', '<=', '>=', '>', '&&', '||', '[', ')', '.', '-', '?', '+', '*', '/', '%%'} + | expression: "variables.want.filter(l, !(lin resource.labels))" + | ..................................................^ +ERROR: syntax/policy.yaml:19:67: extraneous input ')' expecting + | expression: "variables.want.filter(l, !(lin resource.labels))" + | ..................................................................^ +ERROR: syntax/policy.yaml:21:27: mismatched input '2' expecting {'}', ','} + | expression: "{1:305 2:569}" + | ..........................^ +ERROR: syntax/policy.yaml:24:33: extraneous input ']' expecting + | output: "variables.missing]" + | ................................^ diff --git a/testing/src/test/resources/policy/undeclared_reference/expected_errors.baseline b/testing/src/test/resources/policy/undeclared_reference/expected_errors.baseline new file mode 100644 index 000000000..4b887180e --- /dev/null +++ b/testing/src/test/resources/policy/undeclared_reference/expected_errors.baseline @@ -0,0 +1,6 @@ +ERROR: undeclared_reference/policy.yaml:19:19: undeclared reference to 'spec' (in container '') + | expression: spec.labels + | ..................^ +ERROR: undeclared_reference/policy.yaml:23:29: undeclared reference to 'format' (in container '') + | "invalid: %s".format([variables.val]) + | ............................^ diff --git a/testing/src/test/resources/policy/unreachable/expected_errors.baseline b/testing/src/test/resources/policy/unreachable/expected_errors.baseline new file mode 100644 index 000000000..768f0eeb1 --- /dev/null +++ b/testing/src/test/resources/policy/unreachable/expected_errors.baseline @@ -0,0 +1,6 @@ +ERROR: unreachable/policy.yaml:36:9: Match creates unreachable outputs + | - output: | + | ........^ +ERROR: unreachable/policy.yaml:28:7: Rule creates unreachable outputs + | match: + | ......^ \ No newline at end of file diff --git a/testing/src/test/resources/protos/BUILD.bazel b/testing/src/test/resources/protos/BUILD.bazel new file mode 100644 index 000000000..1fac2e1f0 --- /dev/null +++ b/testing/src/test/resources/protos/BUILD.bazel @@ -0,0 +1,120 @@ +load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library") +load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library") +load("//:java_lite_proto_cel_library.bzl", "java_lite_proto_cel_library") +load("//:java_lite_proto_cel_library_impl.bzl", "java_lite_proto_cel_library_impl") + +package( + default_applicable_licenses = [ + "//:license", + ], + default_testonly = True, + default_visibility = [ + "//testing/protos:__pkg__", + ], +) + +proto_library( + name = "single_file_proto", + srcs = ["single_file.proto"], +) + +java_proto_library( + name = "single_file_java_proto", + tags = [ + ], + deps = [":single_file_proto"], +) + +proto_library( + name = "single_file_extension_proto", + srcs = ["single_file_extensions.proto"], + deps = [":single_file_proto"], +) + +java_proto_library( + name = "single_file_extension_java_proto", + tags = [ + ], + deps = [":single_file_extension_proto"], +) + +proto_library( + name = "multi_file_proto", + srcs = [ + "multi_file.proto", + ], + deps = [":single_file_proto"], +) + +proto_library( + name = "message_with_enum_proto", + srcs = ["message_with_enum.proto"], +) + +java_proto_library( + name = "message_with_enum_java_proto", + deps = [":message_with_enum_proto"], +) + +# Test only. java_proto_library supports generating a jar with multiple proto deps, +# so we must test this case as well for lite descriptors. +# buildifier: disable=LANG_proto_library-single-deps +java_proto_library( + name = "multi_file_java_proto", + deps = [ + ":multi_file_proto", + ":single_file_proto", + ], +) + +java_lite_proto_cel_library( + name = "multi_file_cel_java_proto_lite", + deps = [ + ":multi_file_proto", + ":single_file_proto", + ], +) + +java_lite_proto_cel_library( + name = "test_all_types_cel_java_proto2_lite", + deps = ["@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto"], +) + +java_lite_proto_cel_library( + name = "test_all_types_cel_java_proto3_lite", + deps = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) + +# The below targets exist to exercise lite descriptor tests against the full protobuf runtime (thus the overridden java_proto_library_dep). +# Use cases outside CEL should follow the example above. + +java_lite_proto_cel_library_impl( + name = "multi_file_cel_java_proto", + java_descriptor_class_suffix = "CelDescriptor", + java_proto_library_dep = ":multi_file_java_proto", + deps = [ + ":multi_file_proto", + ":single_file_proto", + ], +) + +java_lite_proto_cel_library_impl( + name = "test_all_types_cel_java_proto2", + java_descriptor_class_suffix = "CelDescriptor", + java_proto_library_dep = "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto", + deps = ["@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_proto"], +) + +java_lite_proto_cel_library_impl( + name = "test_all_types_cel_java_proto3", + java_descriptor_class_suffix = "CelDescriptor", + java_proto_library_dep = "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto", + deps = ["@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_proto"], +) + +java_lite_proto_cel_library_impl( + name = "message_with_enum_cel_java_proto", + java_descriptor_class_suffix = "CelDescriptor", + java_proto_library_dep = ":message_with_enum_java_proto", + deps = [":message_with_enum_proto"], +) diff --git a/testing/src/test/resources/protos/message_with_enum.proto b/testing/src/test/resources/protos/message_with_enum.proto new file mode 100644 index 000000000..c495eea16 --- /dev/null +++ b/testing/src/test/resources/protos/message_with_enum.proto @@ -0,0 +1,31 @@ +// Copyright 2025 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. + +syntax = "proto3"; + +package dev.cel.testing.testdata; + +option java_multiple_files = true; +option java_package = "dev.cel.testing.testdata"; +option java_outer_classname = "MessageWithEnumProto"; + +message MessageWithEnum { + SimpleEnum simple_enum = 1; +} + +enum SimpleEnum { + FOO = 0; + BAR = 1; + BAZ = 2; +} diff --git a/testing/src/test/resources/protos/multi_file.proto b/testing/src/test/resources/protos/multi_file.proto new file mode 100644 index 000000000..309278e66 --- /dev/null +++ b/testing/src/test/resources/protos/multi_file.proto @@ -0,0 +1,38 @@ +// Copyright 2022 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. + +syntax = "proto3"; + +package dev.cel.testing.testdata; + +import "testing/src/test/resources/protos/single_file.proto"; + +option java_multiple_files = true; +option java_package = "dev.cel.testing.testdata"; +option java_outer_classname = "MultiFileProto"; + +message MultiFile { + message File { + message Path { + repeated string fragments = 1; + } + + string name = 2; + Path path = 3; + } + + repeated File files = 4; + + SingleFile nested_single_file = 5; +} diff --git a/testing/src/test/resources/protos/single_file.proto b/testing/src/test/resources/protos/single_file.proto new file mode 100644 index 000000000..8306cc16c --- /dev/null +++ b/testing/src/test/resources/protos/single_file.proto @@ -0,0 +1,38 @@ +// Copyright 2022 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. + +edition = "2024"; + +package dev.cel.testing.testdata; + +option java_package = "dev.cel.testing.testdata"; + +message SingleFile { + message Path { + repeated string fragments = 1; + } + + string name = 1; + Path path = 2; + int32 int32_snake_case_json_name = 4 [json_name = "int32_snake_case_json_name"]; + int64 int64_camel_case_json_name = 5 [json_name = "int64CamelCaseJsonName"]; + uint32 uint32_default_json_name = 6; + uint64 uint64_custom_json_name = 7 [json_name = "uint64-custom-json-name"]; + + // Collides with normal field name. + string string_json_name_shadows = 8 [json_name = "single_string"]; + string single_string = 9; + + extensions 1000 to max; +} diff --git a/testing/src/test/resources/protos/single_file_extensions.proto b/testing/src/test/resources/protos/single_file_extensions.proto new file mode 100644 index 000000000..9d18d38df --- /dev/null +++ b/testing/src/test/resources/protos/single_file_extensions.proto @@ -0,0 +1,27 @@ +// 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. + +edition = "2024"; + +package dev.cel.testing.testdata; + +import "testing/src/test/resources/protos/single_file.proto"; + +option java_package = "dev.cel.testing.testdata"; +option features.enforce_naming_style = STYLE_LEGACY; + +extend SingleFile { + int64 int64CamelCaseJsonName = 1000; + string single_string = 1001; +} diff --git a/testing/testrunner/BUILD.bazel b/testing/testrunner/BUILD.bazel new file mode 100644 index 000000000..043d62c88 --- /dev/null +++ b/testing/testrunner/BUILD.bazel @@ -0,0 +1,118 @@ +load("@bazel_skylib//:bzl_library.bzl", "bzl_library") +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_testonly = True, + default_visibility = ["//visibility:public"], +) + +java_library( + name = "cel_user_test_template", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:cel_user_test_template"], +) + +java_library( + name = "junit_xml_reporter", + visibility = ["//:internal"], + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:junit_xml_reporter"], +) + +java_library( + name = "test_runner_library", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:test_runner_library"], +) + +java_library( + name = "test_executor", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:test_executor"], +) + +java_library( + name = "cel_test_suite", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:cel_test_suite"], +) + +java_library( + name = "cel_test_context", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:cel_test_context"], +) + +java_library( + name = "cel_test_suite_yaml_parser", + visibility = ["//:internal"], + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:cel_test_suite_yaml_parser"], +) + +java_library( + name = "cel_test_suite_text_proto_parser", + visibility = ["//:internal"], + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:cel_test_suite_text_proto_parser"], +) + +java_library( + name = "cel_test_suite_exception", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:cel_test_suite_exception"], +) + +java_library( + name = "result_matcher", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:result_matcher"], +) + +java_library( + name = "default_result_matcher", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:default_result_matcher"], +) + +alias( + name = "test_runner_binary", + actual = "//testing/src/main/java/dev/cel/testing/testrunner:test_runner_binary", +) + +java_library( + name = "annotations", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:annotations"], +) + +exports_files( + srcs = ["run_testrunner_binary.sh"], +) + +java_library( + name = "registry_utils", + visibility = ["//:internal"], + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:registry_utils"], +) + +java_library( + name = "class_loader_utils", + visibility = ["//:internal"], + exports = ["//testing/src/main/java/dev/cel/testing/utils:class_loader_utils"], +) + +java_library( + name = "proto_descriptor_utils", + visibility = ["//:internal"], + exports = ["//testing/src/main/java/dev/cel/testing/utils:proto_descriptor_utils"], +) + +java_library( + name = "cel_expression_source", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:cel_expression_source"], +) + +java_library( + name = "cel_coverage_index", + exports = ["//testing/src/main/java/dev/cel/testing/testrunner:cel_coverage_index"], +) + +bzl_library( + name = "cel_java_test", + srcs = ["cel_java_test.bzl"], + deps = [ + "@bazel_skylib//lib:paths", + "@rules_java//java:core_rules", + "@rules_proto//proto:defs", + ], +) diff --git a/testing/testrunner/cel_java_test.bzl b/testing/testrunner/cel_java_test.bzl new file mode 100644 index 000000000..d2dd796c0 --- /dev/null +++ b/testing/testrunner/cel_java_test.bzl @@ -0,0 +1,159 @@ +# Copyright 2025 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. + +"""Rules for triggering the java impl of the CEL test runner.""" + +load("@rules_java//java:java_binary.bzl", "java_binary") +load("@rules_proto//proto:defs.bzl", "proto_descriptor_set") +load("@rules_shell//shell:sh_test.bzl", "sh_test") +load("@bazel_skylib//lib:paths.bzl", "paths") +load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library") + +def _is_label(s): + return s.startswith("//") or s.startswith(":") + +def cel_java_test( + name, + cel_expr, + test_src, + is_raw_expr = False, + test_suite = "", + filegroup = "", + config = "", + deps = [], + proto_deps = [], + enable_coverage = False, + test_data_path = "", + data = []): + """Triggers the Java impl of the CEL test runner. + + This rule generates a java_binary and a run_test rule. + + Note: This rule is to be used only for OSS until cel/expr folder is made available in OSS. + Internally, the cel_test rule is supposed to be used. + + Args: + name: str name for the generated artifact. + cel_expr: cel expression to be evaluated (raw expression, compiled expression, or policy). + test_src: user's test class build target. + is_raw_expr: bool whether the cel_expr is a raw expression (not treated as a file path). + test_suite: str label of a test suite file (.yaml or .textproto). + filegroup: str label of a filegroup containing the test suite, config, and checked expression. + config: str label of a google.api.expr.conformance.Environment textproto file. + deps: list of dependencies for the java_binary rule. + proto_deps: list of proto_library dependencies for the test. + enable_coverage: bool whether to enable coverage for the test. + test_data_path: absolute path of the directory containing the test files (e.g., "//foo/bar"). + data: list of data dependencies for the java_binary rule. + """ + + jvm_flags = [] + + # Avoid mutating the original data list passed into the macro + resolved_data = list(data) + resolved_deps = list(deps) + + # Normalize paths + pkg_name = native.package_name() + test_data_dir = test_data_path.lstrip("/") if test_data_path else pkg_name + + # Add filegroup if provided + if filegroup: + resolved_data.append(filegroup) + + def _process_file_arg(file_val, flag_name): + """Helper to append JVM flags and resolve data targets for file inputs.""" + if not file_val: + return + + if _is_label(file_val): + jvm_flags.append("-D{}=$(location {})".format(flag_name, file_val)) + resolved_data.append(file_val) + else: + jvm_flags.append("-D{}={}/{}".format(flag_name, test_data_dir, file_val)) + + # If no filegroup is provided, we must add the file directly to data + if not filegroup: + target = file_val if test_data_dir == pkg_name else "//{}:{}".format(test_data_dir, file_val) + resolved_data.append(target) + + # Process standard file inputs + _process_file_arg(test_suite, "test_suite_path") + _process_file_arg(config, "config_path") + + # Process cel_expr (has specialized fallback logic) + _, cel_expr_format = paths.split_extension(cel_expr) + is_valid_cel_ext = cel_expr_format in [".cel", ".celpolicy", ".yaml"] + + if _is_label(cel_expr): + jvm_flags.append("-Dcel_expr=$(location {})".format(cel_expr)) + resolved_data.append(cel_expr) + elif is_raw_expr: + jvm_flags.append("-Dcel_expr='{}'".format(cel_expr)) + elif is_valid_cel_ext: + jvm_flags.append("-Dcel_expr={}/{}".format(test_data_dir, cel_expr)) + if not filegroup: + target = cel_expr if test_data_dir == pkg_name else "//{}:{}".format(test_data_dir, cel_expr) + resolved_data.append(target) + else: + # Fallback: Treat as a local target + jvm_flags.append("-Dcel_expr=$(location {})".format(cel_expr)) + resolved_data.append(cel_expr) + + # Process Proto Dependencies + if proto_deps: + descriptor_set_name = name + "_proto_descriptor_set" + descriptor_set_path = ":" + descriptor_set_name + + proto_descriptor_set( + name = descriptor_set_name, + deps = proto_deps, + ) + java_proto_library( + name = descriptor_set_name + "_java_proto", + deps = proto_deps, + ) + + resolved_data.append(descriptor_set_path) + resolved_deps.append(":" + descriptor_set_name + "_java_proto") + jvm_flags.append("-Dfile_descriptor_set_path=$(location {})".format(descriptor_set_path)) + + # Add boolean flags + jvm_flags.append("-Dis_raw_expr={}".format(is_raw_expr)) + jvm_flags.append("-Dis_coverage_enabled={}".format(enable_coverage)) + + # Generate the runner binary + java_binary( + name = name + "_test_runner_binary", + srcs = ["//testing/testrunner:test_runner_binary"], + data = resolved_data, + jvm_flags = jvm_flags, + testonly = True, + main_class = "dev.cel.testing.testrunner.TestRunnerBinary", + runtime_deps = [test_src], + deps = [ + "//testing/testrunner:test_executor", + "@maven//:com_google_guava_guava", + "@bazel_tools//tools/java/runfiles:runfiles", + ] + resolved_deps, + ) + + # Generate the execution shell test + sh_test( + name = name, + tags = ["nomsan"], + srcs = ["//testing/testrunner:run_testrunner_binary.sh"], + data = [":{}_test_runner_binary".format(name)], + args = [name], + ) diff --git a/testing/testrunner/run_testrunner_binary.sh b/testing/testrunner/run_testrunner_binary.sh new file mode 100755 index 000000000..551a41cc9 --- /dev/null +++ b/testing/testrunner/run_testrunner_binary.sh @@ -0,0 +1,28 @@ +#!/bin/bash +# Path: //third_party/java/cel/testing/testrunner/run_testrunner_binary.sh + +die() { + echo "ERROR: $*" >&2 + exit 1 +} + +# Get the name passed to the sh_test rule from the arguments. +# This is the name passed to the sh_test macro, +# and it's also the name of the java_binary +NAME=$1 + +# Find the test_runner_binary executable (wrapper script), using the NAME +TEST_RUNNER_BINARY="$(find -L "${TEST_SRCDIR}" -name "${NAME}_test_runner_binary" -type f -executable)" + +# This would have also worked but the above is more strict in finding +# a file that's a symlink to the executable. +# TEST_RUNNER_BINARY="$(find "${TEST_SRCDIR}" -name "${NAME}_test_runner_binary")" + +if [ -z "$TEST_RUNNER_BINARY" ]; then + die "Test runner binary (wrapper script) $TEST_RUNNER_BINARY not found in runfiles." +fi + +#Execute the symlink to the executable. +"$TEST_RUNNER_BINARY" || die "Some or all the tests failed." + +echo "PASS" diff --git a/validator/BUILD.bazel b/validator/BUILD.bazel new file mode 100644 index 000000000..fe40153fc --- /dev/null +++ b/validator/BUILD.bazel @@ -0,0 +1,28 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "validator", + exports = ["//validator/src/main/java/dev/cel/validator"], +) + +java_library( + name = "validator_builder", + exports = ["//validator/src/main/java/dev/cel/validator:validator_builder"], +) + +java_library( + name = "ast_validator", + exports = ["//validator/src/main/java/dev/cel/validator:ast_validator"], +) + +java_library( + name = "validator_impl", + testonly = 1, + visibility = ["//validator/src/test/java/dev/cel/validator:__pkg__"], + exports = ["//validator/src/main/java/dev/cel/validator:validator_impl"], +) diff --git a/validator/src/main/java/dev/cel/validator/BUILD.bazel b/validator/src/main/java/dev/cel/validator/BUILD.bazel new file mode 100644 index 000000000..95cf65f8a --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/BUILD.bazel @@ -0,0 +1,79 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//publish:__pkg__", + "//validator:__pkg__", + ], +) + +java_library( + name = "validator", + srcs = [ + "CelValidatorFactory.java", + ], + tags = [ + ], + deps = [ + ":validator_builder", + ":validator_impl", + "//bundle:cel", + "//checker:checker_builder", + "//compiler", + "//compiler:compiler_builder", + "//parser:parser_builder", + "//runtime", + ], +) + +java_library( + name = "validator_builder", + srcs = [ + "CelValidator.java", + "CelValidatorBuilder.java", + ], + tags = [ + ], + deps = [ + ":ast_validator", + "//common:cel_ast", + "//common:compiler_common", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "validator_impl", + srcs = [ + "CelValidatorImpl.java", + ], + tags = [ + ], + deps = [ + ":ast_validator", + ":validator_builder", + "//bundle:cel", + "//common:cel_ast", + "//common:compiler_common", + "//common/navigation", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "ast_validator", + srcs = ["CelAstValidator.java"], + tags = [ + ], + deps = [ + "//bundle:cel", + "//common:cel_source", + "//common:compiler_common", + "//common:source_location", + "//common/navigation", + "//common/types", + "//common/types:type_providers", + "@maven//:com_google_guava_guava", + ], +) diff --git a/validator/src/main/java/dev/cel/validator/CelAstValidator.java b/validator/src/main/java/dev/cel/validator/CelAstValidator.java new file mode 100644 index 000000000..ae919696f --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/CelAstValidator.java @@ -0,0 +1,83 @@ +// Copyright 2023 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.validator; + +import com.google.common.collect.ImmutableList; +import dev.cel.bundle.Cel; +import dev.cel.common.CelIssue; +import dev.cel.common.CelIssue.Severity; +import dev.cel.common.CelSource; +import dev.cel.common.CelSourceLocation; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; +import java.util.Optional; + +/** Public interface for performing a single, custom validation on an AST. */ +public interface CelAstValidator { + + void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory); + + /** Enforces a specific expected result type during validation, if set. */ + default CelType expectedResultType() { + return SimpleType.DYN; + } + + /** Factory for populating issues while performing AST validation. */ + final class IssuesFactory { + private final ImmutableList.Builder issuesBuilder; + private final CelNavigableAst navigableAst; + + public IssuesFactory(CelNavigableAst navigableAst) { + this.navigableAst = navigableAst; + this.issuesBuilder = ImmutableList.builder(); + } + + /** Adds an error for the expression. */ + public void addError(long exprId, String message) { + add(exprId, message, Severity.ERROR); + } + + /** Adds a warning for the expression. */ + public void addWarning(long exprId, String message) { + add(exprId, message, Severity.WARNING); + } + + /** Adds an info for the expression. */ + public void addInfo(long exprId, String message) { + add(exprId, message, Severity.INFORMATION); + } + + private void add(long exprId, String message, Severity severity) { + CelSource source = navigableAst.getAst().getSource(); + int position = Optional.ofNullable(source.getPositionsMap().get(exprId)).orElse(-1); + CelSourceLocation sourceLocation = CelSourceLocation.NONE; + if (position >= 0) { + sourceLocation = source.getOffsetLocation(position).get(); + } + issuesBuilder.add( + CelIssue.newBuilder() + .setExprId(exprId) + .setSeverity(severity) + .setMessage(message) + .setSourceLocation(sourceLocation) + .build()); + } + + public ImmutableList getIssues() { + return issuesBuilder.build(); + } + } +} diff --git a/validator/src/main/java/dev/cel/validator/CelValidator.java b/validator/src/main/java/dev/cel/validator/CelValidator.java new file mode 100644 index 000000000..88c83b8cf --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/CelValidator.java @@ -0,0 +1,35 @@ +// Copyright 2023 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.validator; + +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationResult; + +/** Public interface for validating an AST. */ +public interface CelValidator { + + /** + * Performs custom validation of the provided AST. + * + *

This invokes all the AST validators present in this CelValidator instance via {@link + * CelValidatorBuilder#addAstValidators} in their added order. Any exceptions thrown within the + * AST validator will be propagated to the caller and will abort the validation process. + * + *

The result of the validation is bundled inside {@link CelValidationResult}. + * + * @param ast A type-checked AST. + */ + CelValidationResult validate(CelAbstractSyntaxTree ast); +} diff --git a/validator/src/main/java/dev/cel/validator/CelValidatorBuilder.java b/validator/src/main/java/dev/cel/validator/CelValidatorBuilder.java new file mode 100644 index 000000000..b4acd105c --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/CelValidatorBuilder.java @@ -0,0 +1,34 @@ +// Copyright 2023 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.validator; + +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import com.google.errorprone.annotations.CheckReturnValue; + +/** Interface for building an instance of CelValidator. */ +public interface CelValidatorBuilder { + + /** Adds one or more validator to perform custom AST validation. */ + @CanIgnoreReturnValue + CelValidatorBuilder addAstValidators(CelAstValidator... astValidators); + + /** Adds one or more validator to perform custom AST validation. */ + @CanIgnoreReturnValue + CelValidatorBuilder addAstValidators(Iterable astValidators); + + /** Build a new instance of the {@link CelValidator}. */ + @CheckReturnValue + CelValidator build(); +} diff --git a/validator/src/main/java/dev/cel/validator/CelValidatorFactory.java b/validator/src/main/java/dev/cel/validator/CelValidatorFactory.java new file mode 100644 index 000000000..3569bcec0 --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/CelValidatorFactory.java @@ -0,0 +1,47 @@ +// Copyright 2023 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.validator; + +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.checker.CelChecker; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelParser; +import dev.cel.runtime.CelRuntime; + +/** Factory class for constructing an {@link CelValidator} instance. */ +public final class CelValidatorFactory { + + /** Create a new builder for constructing a {@link CelValidator} instance. */ + public static CelValidatorBuilder standardCelValidatorBuilder(Cel cel) { + return CelValidatorImpl.newBuilder(cel); + } + + /** Create a new builder for constructing a {@link CelValidator} instance. */ + public static CelValidatorBuilder standardCelValidatorBuilder( + CelCompiler celCompiler, CelRuntime celRuntime) { + return standardCelValidatorBuilder(CelFactory.combine(celCompiler, celRuntime)); + } + + /** Create a new builder for constructing a {@link CelValidator} instance. */ + public static CelValidatorBuilder standardCelValidatorBuilder( + CelParser celParser, CelChecker celChecker, CelRuntime celRuntime) { + return standardCelValidatorBuilder( + CelCompilerFactory.combine(celParser, celChecker), celRuntime); + } + + private CelValidatorFactory() {} +} diff --git a/validator/src/main/java/dev/cel/validator/CelValidatorImpl.java b/validator/src/main/java/dev/cel/validator/CelValidatorImpl.java new file mode 100644 index 000000000..9561799ca --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/CelValidatorImpl.java @@ -0,0 +1,95 @@ +// Copyright 2023 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.validator; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelIssue; +import dev.cel.common.CelValidationResult; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.validator.CelAstValidator.IssuesFactory; +import java.util.Arrays; + +/** + * {@link CelValidator} implementation to handle AST validation. An instance should be created using + * {@link CelValidatorFactory}. + */ +final class CelValidatorImpl implements CelValidator { + private final Cel cel; + private final ImmutableSet astValidators; + + CelValidatorImpl(Cel cel, ImmutableSet astValidators) { + this.cel = cel; + this.astValidators = astValidators; + } + + @Override + public CelValidationResult validate(CelAbstractSyntaxTree ast) { + if (!ast.isChecked()) { + throw new IllegalArgumentException("AST must be type-checked."); + } + + ImmutableList.Builder issueBuilder = ImmutableList.builder(); + + for (CelAstValidator validator : astValidators) { + Cel celEnv = this.cel.toCelBuilder().setResultType(validator.expectedResultType()).build(); + + CelNavigableAst navigableAst = CelNavigableAst.fromAst(ast); + IssuesFactory issuesFactory = new IssuesFactory(navigableAst); + validator.validate(navigableAst, celEnv, issuesFactory); + issueBuilder.addAll(issuesFactory.getIssues()); + } + + return new CelValidationResult(ast, issueBuilder.build()); + } + + /** Create a new builder for constructing a {@link CelValidator} instance. */ + static Builder newBuilder(Cel cel) { + return new Builder(cel); + } + + /** Builder class for {@link CelValidatorImpl}. */ + static final class Builder implements CelValidatorBuilder { + private final Cel cel; + private final ImmutableSet.Builder astValidators; + + private Builder(Cel cel) { + this.cel = cel; + this.astValidators = ImmutableSet.builder(); + } + + @Override + public CelValidatorBuilder addAstValidators(CelAstValidator... astValidators) { + checkNotNull(astValidators); + return addAstValidators(Arrays.asList(astValidators)); + } + + @Override + public CelValidatorBuilder addAstValidators(Iterable astValidators) { + checkNotNull(astValidators); + this.astValidators.addAll(astValidators); + return this; + } + + @Override + public CelValidator build() { + return new CelValidatorImpl(cel, astValidators.build()); + } + } +} diff --git a/validator/src/main/java/dev/cel/validator/validators/AstDepthLimitValidator.java b/validator/src/main/java/dev/cel/validator/validators/AstDepthLimitValidator.java new file mode 100644 index 000000000..c255624e5 --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/validators/AstDepthLimitValidator.java @@ -0,0 +1,69 @@ +// Copyright 2024 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.validator.validators; + +import static com.google.common.base.Preconditions.checkArgument; + +import dev.cel.bundle.Cel; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.validator.CelAstValidator; + +/** Enforces a compiled AST to stay below the configured depth limit. */ +public final class AstDepthLimitValidator implements CelAstValidator { + + // Protobuf imposes a default parse-depth limit of 100. We set it to half here because navigable + // expr does not include operands in the depth calculation. + // As an example, an expression 'x.y' has a depth of 2 in NavigableExpr, but the ParsedExpr has a + // depth of 4 as illustrated below: + // + // expr { + // id: 2 + // select_expr { + // operand { + // id: 1 + // ident_expr { + // name: "x" + // } + // } + // field: "y" + // } + // } + static final int DEFAULT_DEPTH_LIMIT = 50; + + public static final AstDepthLimitValidator DEFAULT = newInstance(DEFAULT_DEPTH_LIMIT); + private final int maxDepth; + + /** + * Constructs a new instance of {@link AstDepthLimitValidator} with the configured maxDepth as its + * limit. + */ + public static AstDepthLimitValidator newInstance(int maxDepth) { + checkArgument(maxDepth > 0); + return new AstDepthLimitValidator(maxDepth); + } + + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + if (navigableAst.getRoot().height() >= maxDepth) { + issuesFactory.addError( + navigableAst.getRoot().id(), + String.format("AST's depth exceeds the configured limit: %s.", maxDepth)); + } + } + + private AstDepthLimitValidator(int maxDepth) { + this.maxDepth = maxDepth; + } +} diff --git a/validator/src/main/java/dev/cel/validator/validators/BUILD.bazel b/validator/src/main/java/dev/cel/validator/validators/BUILD.bazel new file mode 100644 index 000000000..93a2c0d28 --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/validators/BUILD.bazel @@ -0,0 +1,126 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = [ + "//publish:__pkg__", + "//validator/validators:__pkg__", + ], +) + +java_library( + name = "timestamp", + srcs = [ + "TimestampLiteralValidator.java", + ], + tags = [ + ], + deps = [ + ":literal_validator", + "//common/types", + "//common/types:type_providers", + ], +) + +java_library( + name = "duration", + srcs = [ + "DurationLiteralValidator.java", + ], + tags = [ + ], + deps = [ + ":literal_validator", + "//common/types", + "//common/types:type_providers", + ], +) + +java_library( + name = "regex", + srcs = [ + "RegexLiteralValidator.java", + ], + tags = [ + ], + deps = [ + "//bundle:cel", + "//common/ast", + "//common/navigation", + "//validator:ast_validator", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "homogeneous_literal", + srcs = [ + "HomogeneousLiteralValidator.java", + ], + tags = [ + ], + deps = [ + "//bundle:cel", + "//common:cel_ast", + "//common/ast", + "//common/navigation", + "//common/types:cel_types", + "//common/types:type_providers", + "//validator:ast_validator", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "ast_depth_limit_validator", + srcs = [ + "AstDepthLimitValidator.java", + ], + tags = [ + ], + deps = [ + "//bundle:cel", + "//common/navigation", + "//validator:ast_validator", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "comprehension_nesting_limit_validator", + srcs = [ + "ComprehensionNestingLimitValidator.java", + ], + tags = [ + ], + deps = [ + "//bundle:cel", + "//common/ast", + "//common/navigation", + "//common/navigation:common", + "//validator:ast_validator", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "literal_validator", + srcs = [ + "LiteralValidator.java", + ], + tags = [ + ], + deps = [ + "//bundle:cel", + "//common:cel_ast", + "//common:cel_source", + "//common:compiler_common", + "//common/ast", + "//common/ast:expr_factory", + "//common/navigation", + "//common/types:type_providers", + "//runtime", + "//validator:ast_validator", + "@maven//:com_google_errorprone_error_prone_annotations", + ], +) diff --git a/validator/src/main/java/dev/cel/validator/validators/ComprehensionNestingLimitValidator.java b/validator/src/main/java/dev/cel/validator/validators/ComprehensionNestingLimitValidator.java new file mode 100644 index 000000000..55dadacc5 --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/validators/ComprehensionNestingLimitValidator.java @@ -0,0 +1,85 @@ +// Copyright 2025 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.validator.validators; + +import static com.google.common.base.Preconditions.checkArgument; + +import dev.cel.bundle.Cel; +import dev.cel.common.ast.CelExpr.ExprKind; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.common.navigation.CelNavigableExpr; +import dev.cel.common.navigation.TraversalOrder; +import dev.cel.validator.CelAstValidator; + +/** + * Checks that the nesting depth of comprehensions does not exceed the configured limit. Nesting + * occurs when a comprehension is used in the range expression or the body of a comprehension. + * + *

Trivial comprehensions (comprehensions over an empty range) do not count towards the limit. + */ +public final class ComprehensionNestingLimitValidator implements CelAstValidator { + private final int nestingLimit; + + /** + * Constructs a new instance of {@link ComprehensionNestingLimitValidator} with the configured + * maxNesting as its limit. A limit of 0 means no comprehensions are allowed. + */ + public static ComprehensionNestingLimitValidator newInstance(int maxNesting) { + checkArgument(maxNesting >= 0); + return new ComprehensionNestingLimitValidator(maxNesting); + } + + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + navigableAst + .getRoot() + .allNodes(TraversalOrder.PRE_ORDER) + .filter(node -> node.getKind().equals(ExprKind.Kind.COMPREHENSION)) + .filter(node -> nestingLevel(node) > nestingLimit) + .forEach( + node -> + issuesFactory.addError( + node.id(), + String.format( + "comprehension nesting exceeds the configured limit: %s.", nestingLimit))); + } + + private static boolean isTrivialComprehension(CelNavigableExpr node) { + return (node.expr().comprehension().iterRange().getKind().equals(ExprKind.Kind.LIST) + && node.expr().comprehension().iterRange().list().elements().isEmpty()) + || (node.expr().comprehension().iterRange().getKind().equals(ExprKind.Kind.MAP) + && node.expr().comprehension().iterRange().map().entries().isEmpty()); + } + + private static int nestingLevel(CelNavigableExpr node) { + if (isTrivialComprehension(node)) { + return 0; + } + int count = 1; + while (node.parent().isPresent()) { + CelNavigableExpr parent = node.parent().get(); + + if (parent.getKind().equals(ExprKind.Kind.COMPREHENSION) && !isTrivialComprehension(parent)) { + count++; + } + node = parent; + } + return count; + } + + private ComprehensionNestingLimitValidator(int maxNesting) { + this.nestingLimit = maxNesting; + } +} diff --git a/validator/src/main/java/dev/cel/validator/validators/DurationLiteralValidator.java b/validator/src/main/java/dev/cel/validator/validators/DurationLiteralValidator.java new file mode 100644 index 000000000..0670893b3 --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/validators/DurationLiteralValidator.java @@ -0,0 +1,30 @@ +// Copyright 2023 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.validator.validators; + +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; +import java.time.Duration; + +/** DurationLiteralValidator ensures that duration literal arguments are valid. */ +public final class DurationLiteralValidator extends LiteralValidator { + public static final DurationLiteralValidator INSTANCE = + new DurationLiteralValidator("duration", Duration.class, SimpleType.DURATION); + + private DurationLiteralValidator( + String functionName, Class expectedJavaType, CelType expectedResultType) { + super(functionName, expectedJavaType, expectedResultType); + } +} diff --git a/validator/src/main/java/dev/cel/validator/validators/HomogeneousLiteralValidator.java b/validator/src/main/java/dev/cel/validator/validators/HomogeneousLiteralValidator.java new file mode 100644 index 000000000..f83be31c6 --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/validators/HomogeneousLiteralValidator.java @@ -0,0 +1,145 @@ +// Copyright 2023 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.validator.validators; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.common.navigation.CelNavigableExpr; +import dev.cel.common.types.CelType; +import dev.cel.common.types.CelTypes; +import dev.cel.validator.CelAstValidator; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Optional; + +/** + * HomogeneousLiteralValidator checks that all list and map literals entries have the same types, + * i.e. no mixed list element types or mixed map key or map value types. + */ +public final class HomogeneousLiteralValidator implements CelAstValidator { + private final ImmutableSet exemptFunctions; + + /** + * Construct a new instance of {@link HomogeneousLiteralValidator}. This validator will not run + * for functions in {@code exemptFunctions}. + */ + public static HomogeneousLiteralValidator newInstance(Iterable exemptFunctions) { + return new HomogeneousLiteralValidator(exemptFunctions); + } + + /** + * Construct a new instance of {@link HomogeneousLiteralValidator}. This validator will not run + * for functions in {@code exemptFunctions}. + */ + public static HomogeneousLiteralValidator newInstance(String... exemptFunctions) { + return newInstance(Arrays.asList(exemptFunctions)); + } + + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.getKind().equals(Kind.LIST) || node.getKind().equals(Kind.MAP)) + .filter(node -> !isExemptFunction(node)) + .map(CelNavigableExpr::expr) + .forEach( + expr -> { + if (expr.exprKind().getKind().equals(Kind.LIST)) { + validateList(navigableAst.getAst(), issuesFactory, expr); + } else if (expr.exprKind().getKind().equals(Kind.MAP)) { + validateMap(navigableAst.getAst(), issuesFactory, expr); + } + }); + } + + private void validateList(CelAbstractSyntaxTree ast, IssuesFactory issuesFactory, CelExpr expr) { + CelType previousType = null; + HashSet optionalIndices = new HashSet<>(expr.list().optionalIndices()); + ImmutableList elements = expr.list().elements(); + for (int i = 0; i < elements.size(); i++) { + CelExpr element = elements.get(i); + CelType currentType = ast.getType(element.id()).get(); + if (optionalIndices.contains(i)) { + currentType = currentType.parameters().get(0); + } + + if (previousType == null) { + previousType = currentType; + continue; + } + + reportErrorIfUnassignable(issuesFactory, element.id(), previousType, currentType); + } + } + + private void validateMap(CelAbstractSyntaxTree ast, IssuesFactory issuesFactory, CelExpr expr) { + CelType previousKeyType = null; + CelType previousValueType = null; + for (CelMap.Entry entry : expr.map().entries()) { + CelType currentKeyType = ast.getType(entry.key().id()).get(); + CelType currentValueType = ast.getType(entry.value().id()).get(); + if (entry.optionalEntry()) { + currentValueType = currentValueType.parameters().get(0); + } + + if (previousKeyType == null) { + previousKeyType = currentKeyType; + previousValueType = currentValueType; + continue; + } + + reportErrorIfUnassignable(issuesFactory, entry.id(), previousKeyType, currentKeyType); + reportErrorIfUnassignable(issuesFactory, entry.id(), previousValueType, currentValueType); + } + } + + private void reportErrorIfUnassignable( + IssuesFactory issuesFactory, long elementId, CelType previousType, CelType currentType) { + if (!previousType.isAssignableFrom(currentType)) { + issuesFactory.addError( + elementId, + String.format( + "expected type '%s' but found '%s'", + CelTypes.format(previousType), CelTypes.format(currentType))); + } + } + + private boolean isExemptFunction(CelNavigableExpr listExpr) { + Optional parent = listExpr.parent(); + while (parent.isPresent()) { + CelNavigableExpr node = parent.get(); + if (node.getKind().equals(Kind.CALL)) { + if (exemptFunctions.contains(node.expr().callOrDefault().function())) { + return true; + } + } + + parent = node.parent(); + } + + return false; + } + + private HomogeneousLiteralValidator(Iterable exemptFunctions) { + this.exemptFunctions = ImmutableSet.copyOf(exemptFunctions); + } +} diff --git a/validator/src/main/java/dev/cel/validator/validators/LiteralValidator.java b/validator/src/main/java/dev/cel/validator/validators/LiteralValidator.java new file mode 100644 index 000000000..6d48c4f0c --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/validators/LiteralValidator.java @@ -0,0 +1,99 @@ +// Copyright 2023 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.validator.validators; + +import com.google.errorprone.annotations.CanIgnoreReturnValue; +import dev.cel.bundle.Cel; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelSource; +import dev.cel.common.CelValidationException; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.ast.CelExprFactory; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.common.navigation.CelNavigableExpr; +import dev.cel.common.types.CelType; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.validator.CelAstValidator; + +/** + * LiteralValidator defines the common logic to handle simple validation of a literal in a function + * call by evaluating it and ensuring that no errors are thrown (example: duration / timestamp + * literals). + */ +public abstract class LiteralValidator implements CelAstValidator { + private final String functionName; + private final Class expectedJavaType; + private final CelType expectedResultType; + + protected LiteralValidator( + String functionName, Class expectedJavaType, CelType expectedResultType) { + this.functionName = functionName; + this.expectedJavaType = expectedJavaType; + this.expectedResultType = expectedResultType; + } + + @Override + public CelType expectedResultType() { + return expectedResultType; + } + + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + CelExprFactory exprFactory = CelExprFactory.newInstance(); + + navigableAst + .getRoot() + .descendants() + .filter( + node -> + node.getKind().equals(Kind.CONSTANT) + && node.parent() + .map( + parent -> parent.expr().callOrDefault().function().equals(functionName)) + .orElse(false)) + .map(CelNavigableExpr::expr) + .forEach( + expr -> { + CelExpr callExpr = + exprFactory.newGlobalCall(functionName, exprFactory.newConstant(expr.constant())); + try { + evaluateExpr(cel, callExpr, expectedJavaType); + } catch (Exception e) { + issuesFactory.addError( + expr.id(), + String.format( + "%s validation failed. Reason: %s", functionName, e.getMessage())); + } + }); + } + + @CanIgnoreReturnValue + private static Object evaluateExpr(Cel cel, CelExpr expr, Class expectedJavaType) + throws CelValidationException, CelEvaluationException { + CelAbstractSyntaxTree ast = + CelAbstractSyntaxTree.newParsedAst(expr, CelSource.newBuilder().build()); + ast = cel.check(ast).getAst(); + Object result = cel.createProgram(ast).eval(); + + if (!expectedJavaType.isInstance(result)) { + throw new IllegalStateException( + String.format( + "Expected %s type but got %s instead", + expectedJavaType.getName(), result.getClass().getName())); + } + return result; + } +} diff --git a/validator/src/main/java/dev/cel/validator/validators/RegexLiteralValidator.java b/validator/src/main/java/dev/cel/validator/validators/RegexLiteralValidator.java new file mode 100644 index 000000000..a596de9c1 --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/validators/RegexLiteralValidator.java @@ -0,0 +1,59 @@ +// Copyright 2023 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.validator.validators; + +import com.google.common.collect.ImmutableList; +import dev.cel.bundle.Cel; +import dev.cel.common.ast.CelExpr; +import dev.cel.common.ast.CelExpr.ExprKind.Kind; +import dev.cel.common.navigation.CelNavigableAst; +import dev.cel.validator.CelAstValidator; +import java.util.regex.Pattern; +import java.util.regex.PatternSyntaxException; + +/** RegexLiteralValidator ensures that regex patterns are valid. */ +public final class RegexLiteralValidator implements CelAstValidator { + public static final RegexLiteralValidator INSTANCE = new RegexLiteralValidator(); + + @Override + public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issuesFactory) { + navigableAst + .getRoot() + .allNodes() + .filter(node -> node.expr().callOrDefault().function().equals("matches")) + .filter(node -> ImmutableList.of(1, 2).contains(node.expr().call().args().size())) + .map(node -> node.expr().call()) + .forEach( + matchesCallExpr -> { + CelExpr regexArg = + matchesCallExpr.target().isPresent() + ? matchesCallExpr.args().get(0) + : matchesCallExpr.args().get(1); + if (!regexArg.exprKind().getKind().equals(Kind.CONSTANT)) { + return; + } + + String regexPattern = regexArg.constant().stringValue(); + try { + Pattern.compile(regexPattern); + } catch (PatternSyntaxException e) { + issuesFactory.addError( + regexArg.id(), "Regex validation failed. Reason: " + e.getMessage()); + } + }); + } + + private RegexLiteralValidator() {} +} diff --git a/validator/src/main/java/dev/cel/validator/validators/TimestampLiteralValidator.java b/validator/src/main/java/dev/cel/validator/validators/TimestampLiteralValidator.java new file mode 100644 index 000000000..da3630548 --- /dev/null +++ b/validator/src/main/java/dev/cel/validator/validators/TimestampLiteralValidator.java @@ -0,0 +1,30 @@ +// Copyright 2023 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.validator.validators; + +import dev.cel.common.types.CelType; +import dev.cel.common.types.SimpleType; +import java.time.Instant; + +/** TimestampLiteralValidator ensures that timestamp literal arguments are valid. */ +public final class TimestampLiteralValidator extends LiteralValidator { + public static final TimestampLiteralValidator INSTANCE = + new TimestampLiteralValidator("timestamp", Instant.class, SimpleType.TIMESTAMP); + + private TimestampLiteralValidator( + String functionName, Class expectedJavaType, CelType expectedResultType) { + super(functionName, expectedJavaType, expectedResultType); + } +} diff --git a/validator/src/test/java/dev/cel/validator/BUILD.bazel b/validator/src/test/java/dev/cel/validator/BUILD.bazel new file mode 100644 index 000000000..d7384bf74 --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/BUILD.bazel @@ -0,0 +1,33 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], +) + +java_library( + name = "tests", + testonly = 1, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//bundle:cel", + "//common:compiler_common", + "//compiler", + "//parser:parser_factory", + "//runtime", + "//validator", + "//validator:validator_builder", + "//validator:validator_impl", + "@maven//:junit_junit", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/validator/src/test/java/dev/cel/validator/CelValidatorFactoryTest.java b/validator/src/test/java/dev/cel/validator/CelValidatorFactoryTest.java new file mode 100644 index 000000000..46ad1fc55 --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/CelValidatorFactoryTest.java @@ -0,0 +1,61 @@ +// Copyright 2023 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.validator; + +import static com.google.common.truth.Truth.assertThat; + +import dev.cel.bundle.CelFactory; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.parser.CelParserFactory; +import dev.cel.runtime.CelRuntimeFactory; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelValidatorFactoryTest { + + @Test + public void standardCelValidatorBuilder_withParserCheckerAndRuntime() { + CelValidatorBuilder builder = + CelValidatorFactory.standardCelValidatorBuilder( + CelParserFactory.standardCelParserBuilder().build(), + CelCompilerFactory.standardCelCheckerBuilder().build(), + CelRuntimeFactory.standardCelRuntimeBuilder().build()); + + assertThat(builder).isNotNull(); + assertThat(builder.build()).isNotNull(); + } + + @Test + public void standardCelValidatorBuilder_withCompilerAndRuntime() { + CelValidatorBuilder builder = + CelValidatorFactory.standardCelValidatorBuilder( + CelCompilerFactory.standardCelCompilerBuilder().build(), + CelRuntimeFactory.standardCelRuntimeBuilder().build()); + + assertThat(builder).isNotNull(); + assertThat(builder.build()).isNotNull(); + } + + @Test + public void standardCelValidatorBuilder_withCel() { + CelValidatorBuilder builder = + CelValidatorFactory.standardCelValidatorBuilder(CelFactory.standardCelBuilder().build()); + + assertThat(builder).isNotNull(); + assertThat(builder.build()).isNotNull(); + } +} diff --git a/validator/src/test/java/dev/cel/validator/CelValidatorImplTest.java b/validator/src/test/java/dev/cel/validator/CelValidatorImplTest.java new file mode 100644 index 000000000..521faa9d4 --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/CelValidatorImplTest.java @@ -0,0 +1,125 @@ +// Copyright 2023 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.validator; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelIssue.Severity; +import dev.cel.common.CelValidationResult; +import java.util.ArrayList; +import java.util.List; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public class CelValidatorImplTest { + private static final Cel CEL = CelFactory.standardCelBuilder().build(); + + @Test + public void constructCelValidator_success() { + CelValidator celValidator = + CelValidatorImpl.newBuilder(CEL) + .addAstValidators( + (navigableAst, cel, issuesFactory) -> { + // no-op + }) + .build(); + + assertThat(celValidator).isNotNull(); + assertThat(celValidator).isInstanceOf(CelValidatorImpl.class); + } + + @Test + public void validator_inOrder() throws Exception { + List list = new ArrayList<>(); + CelValidator celValidator = + CelValidatorImpl.newBuilder(CEL) + .addAstValidators((navigableAst, cel, issuesFactory) -> list.add(1)) + .addAstValidators((navigableAst, cel, issuesFactory) -> list.add(2)) + .addAstValidators((navigableAst, cel, issuesFactory) -> list.add(3)) + .build(); + + CelValidationResult result = celValidator.validate(CEL.compile("'test'").getAst()); + + assertThat(result.hasError()).isFalse(); + assertThat(list).containsExactly(1, 2, 3).inOrder(); + } + + @Test + public void validator_whenAstValidatorThrows_throwsException() { + CelValidator celValidator = + CelValidatorImpl.newBuilder(CEL) + .addAstValidators( + (navigableAst, cel, issuesFactory) -> issuesFactory.addError(1, "Test error")) + .addAstValidators( + (navigableAst, cel, issuesFactory) -> { + throw new IllegalArgumentException("Test exception"); + }) + .build(); + + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> celValidator.validate(CEL.compile("'test'").getAst())); + assertThat(e).hasMessageThat().contains("Test exception"); + } + + @Test + public void validator_addIssueWithAllSeverities() throws Exception { + CelValidator celValidator = + CelValidatorImpl.newBuilder(CEL) + .addAstValidators( + (navigableAst, cel, issuesFactory) -> issuesFactory.addError(1, "Test error")) + .addAstValidators( + (navigableAst, cel, issuesFactory) -> issuesFactory.addWarning(1, "Test warning")) + .addAstValidators( + (navigableAst, cel, issuesFactory) -> issuesFactory.addInfo(1, "Test info")) + .build(); + + CelValidationResult result = celValidator.validate(CEL.compile("'test'").getAst()); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(3); + assertThat(result.getAllIssues().get(0).getSeverity()).isEqualTo(Severity.ERROR); + assertThat(result.getAllIssues().get(1).getSeverity()).isEqualTo(Severity.WARNING); + assertThat(result.getAllIssues().get(2).getSeverity()).isEqualTo(Severity.INFORMATION); + assertThat(result.getIssueString()) + .contains( + "ERROR: :1:1: Test error\n" + + " | 'test'\n" + + " | ^\n" + + "WARNING: :1:1: Test warning\n" + + " | 'test'\n" + + " | ^\n" + + "INFORMATION: :1:1: Test info\n" + + " | 'test'\n" + + " | ^"); + } + + @Test + public void parsedAst_throwsException() throws Exception { + CelValidator celValidator = CelValidatorImpl.newBuilder(CEL).build(); + + IllegalArgumentException e = + assertThrows( + IllegalArgumentException.class, + () -> celValidator.validate(CEL.parse("'test'").getAst())); + assertThat(e).hasMessageThat().contains("AST must be type-checked."); + } +} diff --git a/validator/src/test/java/dev/cel/validator/validators/AstDepthLimitValidatorTest.java b/validator/src/test/java/dev/cel/validator/validators/AstDepthLimitValidatorTest.java new file mode 100644 index 000000000..acc2544c7 --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/validators/AstDepthLimitValidatorTest.java @@ -0,0 +1,112 @@ +// Copyright 2024 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.validator.validators; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; +import static dev.cel.validator.validators.AstDepthLimitValidator.DEFAULT_DEPTH_LIMIT; +import static org.junit.Assert.assertThrows; + +import dev.cel.expr.CheckedExpr; +import com.google.protobuf.ByteString; +import com.google.protobuf.ExtensionRegistryLite; +import com.google.protobuf.InvalidProtocolBufferException; +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.CelIssue.Severity; +import dev.cel.common.CelProtoAbstractSyntaxTree; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.SimpleType; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class AstDepthLimitValidatorTest { + + private static final Cel CEL = + CelFactory.standardCelBuilder() + .addVar("x", SimpleType.DYN) + .addFunctionDeclarations( + newFunctionDeclaration( + "f", newGlobalOverload("f_int64", SimpleType.INT, SimpleType.INT))) + .build(); + + private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL) + .addAstValidators(AstDepthLimitValidator.DEFAULT) + .build(); + + private enum DefaultTestCase { + NESTED_SELECTS( + "x.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y.y"), + NESTED_CALCS( + "0+1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20+21+22+23+24+25+26+27+28+29+30+31+32+33+34+35+36+37+38+39+40+41+42+43+44+45+46+47+48+49+50"), + NESTED_FUNCS( + "f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(0)))))))))))))))))))))))))))))))))))))))))))))))))))"); + + private final String expression; + + DefaultTestCase(String expression) { + this.expression = expression; + } + } + + @Test + public void astExceedsDefaultDepthLimit_populatesErrors(@TestParameter DefaultTestCase testCase) + throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(testCase.expression).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getAllIssues().get(0).getSeverity()).isEqualTo(Severity.ERROR); + assertThat(result.getAllIssues().get(0).toDisplayString(ast.getSource())) + .contains("AST's depth exceeds the configured limit: 50."); + assertThrows(InvalidProtocolBufferException.class, () -> verifyProtoAstRoundTrips(ast)); + } + + @Test + public void astIsUnderDepthLimit_noErrors() throws Exception { + StringBuilder sb = new StringBuilder().append("x"); + for (int i = 0; i < DEFAULT_DEPTH_LIMIT - 1; i++) { + sb.append(".y"); + } + // Depth level of 49 + CelAbstractSyntaxTree ast = CEL.compile(sb.toString()).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + verifyProtoAstRoundTrips(ast); + } + + private void verifyProtoAstRoundTrips(CelAbstractSyntaxTree ast) throws Exception { + CheckedExpr checkedExpr = CelProtoAbstractSyntaxTree.fromCelAst(ast).toCheckedExpr(); + ByteString serialized = checkedExpr.toByteString(); + CheckedExpr deserializedCheckedExpr = + CheckedExpr.parseFrom(serialized, ExtensionRegistryLite.getEmptyRegistry()); + if (!checkedExpr.equals(deserializedCheckedExpr)) { + throw new IllegalStateException("Expected checked expressions to round trip!"); + } + } +} diff --git a/validator/src/test/java/dev/cel/validator/validators/BUILD.bazel b/validator/src/test/java/dev/cel/validator/validators/BUILD.bazel new file mode 100644 index 000000000..adfd406c8 --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/validators/BUILD.bazel @@ -0,0 +1,50 @@ +load("@rules_java//java:defs.bzl", "java_library") +load("//:testing.bzl", "junit4_test_suites") + +package( + default_applicable_licenses = ["//:license"], +) + +java_library( + name = "tests", + testonly = 1, + srcs = glob(["*.java"]), + deps = [ + "//:java_truth", + "//bundle:cel", + "//common:cel_ast", + "//common:compiler_common", + "//common:options", + "//common:proto_ast", + "//common/internal:proto_time_utils", + "//common/types", + "//extensions", + "//extensions:optional_library", + "//parser:macro", + "//runtime", + "//runtime:function_binding", + "//validator", + "//validator:validator_builder", + "//validator/validators:ast_depth_limit_validator", + "//validator/validators:comprehension_nesting_limit_validator", + "//validator/validators:duration", + "//validator/validators:homogeneous_literal", + "//validator/validators:regex", + "//validator/validators:timestamp", + "@cel_spec//proto/cel/expr:checked_java_proto", + "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_testparameterinjector_test_parameter_injector", + "@maven//:junit_junit", + "@maven_android//:com_google_protobuf_protobuf_javalite", + ], +) + +junit4_test_suites( + name = "test_suites", + sizes = [ + "small", + ], + src_dir = "src/test/java", + deps = [":tests"], +) diff --git a/validator/src/test/java/dev/cel/validator/validators/ComprehensionNestingLimitValidatorTest.java b/validator/src/test/java/dev/cel/validator/validators/ComprehensionNestingLimitValidatorTest.java new file mode 100644 index 000000000..ccf625d88 --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/validators/ComprehensionNestingLimitValidatorTest.java @@ -0,0 +1,176 @@ +// Copyright 2025 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.validator.validators; + +import static com.google.common.truth.Truth.assertThat; +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.CelIssue.Severity; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.SimpleType; +import dev.cel.extensions.CelExtensions; +import dev.cel.parser.CelStandardMacro; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class ComprehensionNestingLimitValidatorTest { + + private static final Cel CEL = + CelFactory.standardCelBuilder() + .addCompilerLibraries( + CelExtensions.optional(), CelExtensions.comprehensions(), CelExtensions.bindings()) + .addRuntimeLibraries(CelExtensions.optional(), CelExtensions.comprehensions()) + .setStandardMacros(CelStandardMacro.STANDARD_MACROS) + .addVar("x", SimpleType.DYN) + .build(); + + private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL) + .addAstValidators(ComprehensionNestingLimitValidator.newInstance(1)) + .build(); + + @Test + public void comprehensionNestingLimit_populatesErrors( + @TestParameter({ + "[1, 2, 3].map(x, [1, 2, 3].map(y, x + y))", + "[1, 2, 3].map(x, [1, 2, 3].map(y, x + y).size() > 0, x)", + "[1, 2, 3].all(x, [1, 2, 3].exists(y, x + y > 0))", + "[1, 2, 3].map(x, {x: [1, 2, 3].map(y, x + y)})", + "[1, 2, 3].exists(i, v, i < 3 && [1, 2, 3].all(j, v2, j < 3 && v2 > 0))", + "{1: 2}.all(k, {2: 3}.all(k2, k != k2))" + }) + String expr) + throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(expr).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getAllIssues().get(0).getSeverity()).isEqualTo(Severity.ERROR); + assertThat(result.getAllIssues().get(0).toDisplayString(ast.getSource())) + .contains("comprehension nesting exceeds the configured limit: 1."); + } + + @Test + public void comprehensionNestingLimit_accumulatesErrors( + @TestParameter({ + "[1, 2, 3].map(x, [1, 2, 3].map(y, [1, 2, 3].map(z, x + y + z)))", + }) + String expr) + throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(expr).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(2); + } + + @Test + public void comprehensionNestingLimit_limitConfigurable( + @TestParameter({ + "[1, 2, 3].map(x, [1, 2, 3].map(y, x + y))", + "[1, 2, 3].map(x, [1, 2, 3].map(y, x + y).size() > 0, x)", + "[1, 2, 3].all(x, [1, 2, 3].exists(y, x + y > 0))", + "[1, 2, 3].map(x, {x: [1, 2, 3].map(y, x + y)})", + "[1, 2, 3].exists(i, v, i < 3 && [1, 2, 3].all(j, v2, j < 3 && v2 > 0))", + "{1: 2}.all(k, {2: 3}.all(k2, k != k2))" + }) + String expr) + throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(expr).getAst(); + CelValidator celValidator = + CelValidatorFactory.standardCelValidatorBuilder(CEL) + .addAstValidators(ComprehensionNestingLimitValidator.newInstance(2)) + .build(); + + CelValidationResult result = celValidator.validate(ast); + + assertThat(result.hasError()).isFalse(); + } + + @Test + public void comprehensionNestingLimit_trivialLoopsDontCount( + @TestParameter({ + "cel.bind(x, [1, 2].map(x, x + 1), x + [1, 2].map(x, x + 1))", + "optional.of(1).optMap(x, [1, 2, 3].exists(y, y == x))", + "[].map(x, [1, 2, 3].map(y, x + y))", + "{}.map(k1, {1: 2, 3: 4}.map(k2, k1 + k2))", + "[1, 2, 3].map(x, cel.bind(y, 2, x + y))", + "[1, 2, 3].map(x, optional.of(1).optMap(y, x + y).orValue(0))", + }) + String expr) + throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(expr).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + } + + @Test + public void comprehensionNestingLimit_zeroLimitAcceptedComprehenions( + @TestParameter({ + "cel.bind(x, 1, x + 1)", + "optional.of(1).optMap(x, x + 1)", + "[].map(x, int(x))", + "cel.bind(x, 1 + [].map(x, int(x)).size(), x + 1)" + }) + String expr) + throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(expr).getAst(); + + CelValidator celValidator = + CelValidatorFactory.standardCelValidatorBuilder(CEL) + .addAstValidators(ComprehensionNestingLimitValidator.newInstance(0)) + .build(); + + CelValidationResult result = celValidator.validate(ast); + + assertThat(result.hasError()).isFalse(); + } + + @Test + public void comprehensionNestingLimit_zeroLimitRejectedComprehensions( + @TestParameter({ + "[1].map(x, x)", + "[1].exists(x, x > 0)", + "[].exists(x, [1].all(y, y > 0))", + }) + String expr) + throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(expr).getAst(); + + CelValidator celValidator = + CelValidatorFactory.standardCelValidatorBuilder(CEL) + .addAstValidators(ComprehensionNestingLimitValidator.newInstance(0)) + .build(); + + CelValidationException e = + assertThrows(CelValidationException.class, () -> celValidator.validate(ast).getAst()); + + assertThat(e.getMessage()).contains("comprehension nesting exceeds the configured limit: 0."); + } +} diff --git a/validator/src/test/java/dev/cel/validator/validators/DurationLiteralValidatorTest.java b/validator/src/test/java/dev/cel/validator/validators/DurationLiteralValidatorTest.java new file mode 100644 index 000000000..1ec3ef4aa --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/validators/DurationLiteralValidatorTest.java @@ -0,0 +1,193 @@ +// Copyright 2023 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.validator.validators; + +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.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelIssue.Severity; +import dev.cel.common.CelValidationResult; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.types.SimpleType; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; +import java.text.ParseException; +import java.time.Duration; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class DurationLiteralValidatorTest { + private static final Cel CEL = CelFactory.standardCelBuilder().build(); + + private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL) + .addAstValidators(DurationLiteralValidator.INSTANCE) + .build(); + + @Test + @TestParameters("{source: duration('0')}") + @TestParameters("{source: duration('1h')}") + @TestParameters("{source: duration('-1m6s')}") + @TestParameters("{source: duration('2h3m4s5us')}") + public void duration_validFormat(String source) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(CEL.createProgram(ast).eval()).isInstanceOf(Duration.class); + } + + @Test + public void durationsInCallArgument_validFormat() throws Exception { + String source = "string(duration('1h')) + ':' + string(duration('-1m'))"; + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(CEL.createProgram(ast).eval()).isInstanceOf(String.class); + } + + @Test + public void duration_withVariable_noOp() throws Exception { + Cel cel = CelFactory.standardCelBuilder().addVar("str_var", SimpleType.STRING).build(); + CelAbstractSyntaxTree ast = cel.compile("duration(str_var)").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + // Static AST validation cannot handle variables. This expectedly contains no errors + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + // However, the same AST fails on evaluation when a bad variable is passed in. + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> CEL.createProgram(ast).eval(ImmutableMap.of("str_var", "bad"))); + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :8: invalid duration format"); + } + + @Test + public void duration_withFunction_noOp() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "testFunc", + newGlobalOverload("testFuncOverloadId", SimpleType.STRING, SimpleType.STRING))) + .addFunctionBindings( + CelFunctionBinding.from( + "testFuncOverloadId", + String.class, + stringArg -> { + try { + return ProtoTimeUtils.parse(stringArg).toString(); + } catch (ParseException e) { + throw new RuntimeException(e); + } + })) + .build(); + CelAbstractSyntaxTree ast = cel.compile("duration(testFunc('bad'))").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + // Static AST validation cannot handle functions. This expectedly contains no errors + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + // However, the same AST fails on evaluation when the function dispatch fails. + assertThat(e) + .hasMessageThat() + .contains( + "evaluation error at :17: Function 'testFuncOverloadId' failed with arg(s)" + + " 'bad'"); + } + + @Test + public void duration_invalidFormat() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("duration('bad')").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getAllIssues().get(0).getSeverity()).isEqualTo(Severity.ERROR); + assertThat(result.getAllIssues().get(0).toDisplayString(ast.getSource())) + .isEqualTo( + "ERROR: :1:10: duration validation failed. Reason: evaluation error: invalid" + + " duration format\n" + + " | duration('bad')\n" + + " | .........^"); + } + + @Test + public void duration_unexpectedResultType_throws() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .setStandardEnvironmentEnabled(false) + .addFunctionDeclarations( + newFunctionDeclaration( + "duration", + newGlobalOverload("duration_overload", SimpleType.DURATION, SimpleType.STRING))) + .addFunctionBindings( + CelFunctionBinding.from("duration_overload", String.class, (arg) -> 1)) + .build(); + CelAbstractSyntaxTree ast = cel.compile("duration('1h')").getAst(); + CelValidator celValidator = + CelValidatorFactory.standardCelValidatorBuilder(cel) + .addAstValidators(DurationLiteralValidator.INSTANCE) + .build(); + + CelValidationResult result = celValidator.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getAllIssues().get(0).getSeverity()).isEqualTo(Severity.ERROR); + assertThat(result.getAllIssues().get(0).toDisplayString(ast.getSource())) + .isEqualTo( + "ERROR: :1:10: duration validation failed. Reason: Expected" + + " java.time.Duration type but got java.lang.Integer instead\n" + + " | duration('1h')\n" + + " | .........^"); + } + + @Test + @TestParameters("{source: '{1: 2}'}") + @TestParameters("{source: '[1,2,3]'}") + public void parentIsNotCallExpr_doesNotThrow(String source) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + } +} diff --git a/validator/src/test/java/dev/cel/validator/validators/HomogeneousLiteralValidatorTest.java b/validator/src/test/java/dev/cel/validator/validators/HomogeneousLiteralValidatorTest.java new file mode 100644 index 000000000..baaf3f05c --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/validators/HomogeneousLiteralValidatorTest.java @@ -0,0 +1,260 @@ +// Copyright 2023 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.validator.validators; + +import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; +import static dev.cel.common.CelOverloadDecl.newMemberOverload; + +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.SimpleType; +import dev.cel.extensions.CelOptionalLibrary; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; +import java.util.List; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class HomogeneousLiteralValidatorTest { + private static final Cel CEL = + CelFactory.standardCelBuilder() + .addCompilerLibraries(CelOptionalLibrary.INSTANCE) + .addRuntimeLibraries(CelOptionalLibrary.INSTANCE) + .build(); + + private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL) + .addAstValidators(HomogeneousLiteralValidator.newInstance()) + .build(); + + @Test + @TestParameters("{source: '[1, 2, 3]'}") + @TestParameters("{source: '[dyn(1), dyn(2), dyn(3)]'}") + @TestParameters("{source: '[''hello'', ''world'', ''test'']'}") + @TestParameters("{source: '[''hello'', ?optional.ofNonZeroValue(''''), ?optional.of('''')]'}") + @TestParameters("{source: '[?optional.ofNonZeroValue(''''), ?optional.of(''''), ''hello'']'}") + public void list_containsHomogeneousLiterals(String source) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(CEL.createProgram(ast).eval()).isInstanceOf(List.class); + } + + @Test + @TestParameters("{source: '{1: false, 2: true}'}") + @TestParameters("{source: '{''hello'': false, ''world'': true}'}") + @TestParameters("{source: '{''hello'': false, ?''world'': optional.ofNonZeroValue(true)}'}") + @TestParameters("{source: '{?''hello'': optional.ofNonZeroValue(false), ''world'': true}'}") + public void map_containsHomogeneousLiterals(String source) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(CEL.createProgram(ast).eval()).isInstanceOf(Map.class); + } + + @Test + public void list_containsHeterogeneousLiterals() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[1, 2, 'hello']").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getErrorString()) + .contains( + "ERROR: :1:8: expected type 'int' but found 'string'\n" + + " | [1, 2, 'hello']\n" + + " | .......^"); + } + + @Test + public void list_containsHeterogeneousLiteralsInNestedLists() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[[1], ['hello']]").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getErrorString()) + .contains( + "ERROR: :1:7: expected type 'list(int)' but found 'list(string)'\n" + + " | [[1], ['hello']]\n" + + " | ......^"); + } + + @Test + public void list_containsHeterogeneousLiteralsInDyn() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("[1, 2, dyn(3)]").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getErrorString()) + .contains( + "ERROR: :1:11: expected type 'int' but found 'dyn'\n" + + " | [1, 2, dyn(3)]\n" + + " | ..........^"); + } + + @Test + public void mapKey_containsHeterogeneousLiterals() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("{1: true, 'hello': false}").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getErrorString()) + .contains( + "ERROR: :1:18: expected type 'int' but found 'string'\n" + + " | {1: true, 'hello': false}\n" + + " | .................^"); + } + + @Test + public void mapKey_containsHeterogeneousLiteralsInNestedMaps() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("{{'a': 1}: true, {'b': 'hello'}: false}").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getErrorString()) + .contains( + "ERROR: :1:32: expected type 'map(string, int)' but found 'map(string," + + " string)'\n" + + " | {{'a': 1}: true, {'b': 'hello'}: false}\n" + + " | ...............................^"); + } + + @Test + public void mapKey_containsHeterogeneousLiteralsInDyn() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("{1: true, dyn(2): false}").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getErrorString()) + .contains( + "ERROR: :1:17: expected type 'int' but found 'dyn'\n" + + " | {1: true, dyn(2): false}\n" + + " | ................^"); + } + + @Test + public void mapValue_containsHeterogeneousLiterals() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("{1: true, 2: 'hello'}").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getErrorString()) + .contains( + "ERROR: :1:12: expected type 'bool' but found 'string'\n" + + " | {1: true, 2: 'hello'}\n" + + " | ...........^"); + } + + @Test + public void mapValue_containsHeterogeneousLiteralsInNestedMaps() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("{1: {'a': true}, 2: {'b': 'hello'}}").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getErrorString()) + .contains( + "ERROR: :1:19: expected type 'map(string, bool)' but found 'map(string," + + " string)'\n" + + " | {1: {'a': true}, 2: {'b': 'hello'}}\n" + + " | ..................^"); + } + + @Test + public void mapValue_containsHeterogeneousLiteralsInDyn() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("{1: true, 2: dyn(false)}").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getErrorString()) + .contains( + "ERROR: :1:12: expected type 'bool' but found 'dyn'\n" + + " | {1: true, 2: dyn(false)}\n" + + " | ...........^"); + } + + @Test + @TestParameters("{source: 'exemptFunction([''a'', 2])'}") + @TestParameters("{source: 'exemptFunction({1: true, ''hello'': false})'}") + @TestParameters("{source: 'exemptFunction({1: {''a'': true, 2: false}})'}") + @TestParameters("{source: 'exemptFunction({{''a'': true, 2: false} : false})'}") + @TestParameters("{source: '''%s''.format([[1], [2.0]])'}") + @TestParameters("{source: '''%s''.format([[1, 2, [3.0, 4]]])'}") + @TestParameters("{source: '''%d''.format([[[1, 2, [3.0, 4]]].size()])'}") + @TestParameters("{source: '''%d''.format([[1, 2, size([3.0, 4])]])'}") + @TestParameters("{source: '''%s''.format([[[1, 2, [3.0, 4]]][0]])'}") + public void heterogeneousLiterals_inExemptFunction(String source) throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "exemptFunction", + newGlobalOverload("exemptFunctionOverloadId", SimpleType.BOOL, SimpleType.DYN)), + newFunctionDeclaration( + "format", + newMemberOverload( + "stringFormatOverloadId", + SimpleType.BOOL, + SimpleType.STRING, + SimpleType.DYN))) + .addFunctionBindings( + CelFunctionBinding.from("exemptFunctionOverloadId", Object.class, (arg) -> true), + CelFunctionBinding.from( + "stringFormatOverloadId", String.class, Object.class, (str, arg) -> true)) + .build(); + CelValidator validator = + CelValidatorFactory.standardCelValidatorBuilder(cel) + .addAstValidators(HomogeneousLiteralValidator.newInstance("exemptFunction", "format")) + .build(); + CelAbstractSyntaxTree ast = cel.compile(source).getAst(); + + CelValidationResult result = validator.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(cel.createProgram(ast).eval()).isInstanceOf(Boolean.class); + } +} diff --git a/validator/src/test/java/dev/cel/validator/validators/RegexLiteralValidatorTest.java b/validator/src/test/java/dev/cel/validator/validators/RegexLiteralValidatorTest.java new file mode 100644 index 000000000..a41317371 --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/validators/RegexLiteralValidatorTest.java @@ -0,0 +1,228 @@ +// Copyright 2023 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.validator.validators; + +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.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelIssue.Severity; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationResult; +import dev.cel.common.types.SimpleType; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class RegexLiteralValidatorTest { + private static final CelOptions CEL_OPTIONS = CelOptions.current().build(); + + private static final Cel CEL = CelFactory.standardCelBuilder().setOptions(CEL_OPTIONS).build(); + + private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL) + .addAstValidators(RegexLiteralValidator.INSTANCE) + .build(); + + @Test + @TestParameters("{source: 'matches(''hello'', ''h'')'}") + @TestParameters("{source: 'matches(''hello'', ''nomatch'')'}") + @TestParameters("{source: 'matches(''hello'', ''el*'')'}") + @TestParameters("{source: 'matches(''**'', ''el*'')'}") + public void regex_global_validFormat(String source) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(CEL.createProgram(ast).eval()).isInstanceOf(Boolean.class); + } + + @Test + @TestParameters("{source: '\"hello\".matches(\"h\")'}") + @TestParameters("{source: '\"hello\".matches(\"nomatch\")'}") + @TestParameters("{source: '\"hello\".matches(\"el*\")'}") + @TestParameters("{source: '\"**\".matches(\"el*\")'}") + public void regex_receiver_validFormat(String source) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(CEL.createProgram(ast).eval()).isInstanceOf(Boolean.class); + } + + @Test + public void regex_globalWithVariable_noOp() throws Exception { + Cel cel = CelFactory.standardCelBuilder().addVar("str_var", SimpleType.STRING).build(); + CelAbstractSyntaxTree ast = cel.compile("matches('test', str_var)").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + // Static AST validation cannot handle variables. This expectedly contains no errors + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + // However, the same AST fails on evaluation when a bad variable is passed in. + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> CEL.createProgram(ast).eval(ImmutableMap.of("str_var", "**"))); + assertThat(e) + .hasMessageThat() + .contains( + "evaluation error at :7: error parsing regexp: missing argument to repetition" + + " operator: `*`"); + } + + @Test + public void regex_receiverWithVariable_noOp() throws Exception { + Cel cel = CelFactory.standardCelBuilder().addVar("str_var", SimpleType.STRING).build(); + CelAbstractSyntaxTree ast = cel.compile("'test'.matches(str_var)").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + // Static AST validation cannot handle variables. This expectedly contains no errors + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + // However, the same AST fails on evaluation when a bad variable is passed in. + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> CEL.createProgram(ast).eval(ImmutableMap.of("str_var", "**"))); + assertThat(e) + .hasMessageThat() + .contains( + "evaluation error at :14: error parsing regexp: missing argument to repetition" + + " operator: `*`"); + } + + @Test + public void regex_globalWithFunction_noOp() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "testFunc", newGlobalOverload("testFuncOverloadId", SimpleType.STRING))) + .addFunctionBindings( + CelFunctionBinding.from("testFuncOverloadId", ImmutableList.of(), (args) -> "**")) + .build(); + CelAbstractSyntaxTree ast = cel.compile("matches('test', testFunc())").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + // Static AST validation cannot handle functions. This expectedly contains no errors + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + // However, the same AST fails on evaluation when the function dispatch fails. + assertThat(e) + .hasMessageThat() + .contains( + "evaluation error at :7: error parsing regexp: missing argument to repetition" + + " operator: `*`"); + } + + @Test + public void regex_receiverWithFunction_noOp() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "testFunc", newGlobalOverload("testFuncOverloadId", SimpleType.STRING))) + .addFunctionBindings( + CelFunctionBinding.from("testFuncOverloadId", ImmutableList.of(), (args) -> "**")) + .build(); + CelAbstractSyntaxTree ast = cel.compile("'test'.matches(testFunc())").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + // Static AST validation cannot handle functions. This expectedly contains no errors + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + // However, the same AST fails on evaluation when the function dispatch fails. + assertThat(e) + .hasMessageThat() + .contains( + "evaluation error at :14: error parsing regexp: missing argument to repetition" + + " operator: `*`"); + } + + @Test + public void regex_global_invalidFormat() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("matches('test', '**')").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getAllIssues().get(0).getSeverity()).isEqualTo(Severity.ERROR); + assertThat(result.getAllIssues().get(0).toDisplayString(ast.getSource())) + .isEqualTo( + "ERROR: :1:17: Regex validation failed. Reason: Dangling meta character '*' near" + + " index 0\n" + + "**\n" + + "^\n" + + " | matches('test', '**')\n" + + " | ................^"); + } + + @Test + public void regex_receiver_invalidFormat() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("'**'.matches('**')").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getAllIssues().get(0).getSeverity()).isEqualTo(Severity.ERROR); + assertThat(result.getAllIssues().get(0).toDisplayString(ast.getSource())) + .isEqualTo( + "ERROR: :1:14: Regex validation failed. Reason: Dangling meta character '*' near" + + " index 0\n" + + "**\n" + + "^\n" + + " | '**'.matches('**')\n" + + " | .............^"); + } + + @Test + @TestParameters("{source: '{1: 2}'}") + @TestParameters("{source: '[1,2,3]'}") + public void parentIsNotCallExpr_doesNotThrow(String source) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + } +} diff --git a/validator/src/test/java/dev/cel/validator/validators/TimestampLiteralValidatorTest.java b/validator/src/test/java/dev/cel/validator/validators/TimestampLiteralValidatorTest.java new file mode 100644 index 000000000..404ed7f7e --- /dev/null +++ b/validator/src/test/java/dev/cel/validator/validators/TimestampLiteralValidatorTest.java @@ -0,0 +1,221 @@ +// Copyright 2023 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.validator.validators; + +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.common.collect.ImmutableMap; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelIssue.Severity; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationResult; +import dev.cel.common.internal.ProtoTimeUtils; +import dev.cel.common.types.SimpleType; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.validator.CelValidator; +import dev.cel.validator.CelValidatorFactory; +import java.text.ParseException; +import java.time.Instant; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public class TimestampLiteralValidatorTest { + private static final CelOptions CEL_OPTIONS = CelOptions.current().build(); + + private static final Cel CEL = CelFactory.standardCelBuilder().setOptions(CEL_OPTIONS).build(); + + private static final CelValidator CEL_VALIDATOR = + CelValidatorFactory.standardCelValidatorBuilder(CEL) + .addAstValidators(TimestampLiteralValidator.INSTANCE) + .build(); + + @Test + @TestParameters("{source: timestamp(0)}") + @TestParameters("{source: timestamp(1624124124)}") + @TestParameters("{source: timestamp('2021-06-19T17:35:24Z')}") + @TestParameters("{source: timestamp('1972-01-01T10:00:20.021-05:00')}") + public void timestamp_validFormat(String source) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(CEL.createProgram(ast).eval()).isInstanceOf(Instant.class); + } + + @Test + public void timestampsInCallArgument_validFormat() throws Exception { + String source = + "string(timestamp(1524124124)) + ':' + string(timestamp('2021-06-19T17:35:24Z'))"; + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + assertThat(CEL.createProgram(ast).eval()).isInstanceOf(String.class); + } + + @Test + public void timestamp_withVariable_noOp() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addVar("str_var", SimpleType.STRING) + .setOptions(CEL_OPTIONS) + .build(); + CelAbstractSyntaxTree ast = cel.compile("timestamp(str_var)").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + // Static AST validation cannot handle variables. This expectedly contains no errors + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + // However, the same AST fails on evaluation when a bad variable is passed in. + CelEvaluationException e = + assertThrows( + CelEvaluationException.class, + () -> CEL.createProgram(ast).eval(ImmutableMap.of("str_var", "bad"))); + assertThat(e) + .hasMessageThat() + .contains("evaluation error at :9: Text 'bad' could not be parsed at index 0"); + } + + @Test + public void timestamp_withFunction_noOp() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "testFunc", + newGlobalOverload("testFuncOverloadId", SimpleType.INT, SimpleType.STRING))) + .addFunctionBindings( + CelFunctionBinding.from( + "testFuncOverloadId", + String.class, + stringArg -> { + try { + return ProtoTimeUtils.parse(stringArg).getSeconds(); + } catch (ParseException e) { + throw new RuntimeException(e); + } + })) + .setOptions(CEL_OPTIONS) + .build(); + CelAbstractSyntaxTree ast = cel.compile("timestamp(testFunc('bad'))").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + // Static AST validation cannot handle functions. This expectedly contains no errors + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + CelEvaluationException e = + assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval()); + // However, the same AST fails on evaluation when the function dispatch fails. + assertThat(e) + .hasMessageThat() + .contains( + "evaluation error at :18: Function 'testFuncOverloadId' failed with arg(s)" + + " 'bad'"); + } + + @Test + public void timestamp_invalidFormat() throws Exception { + CelAbstractSyntaxTree ast = CEL.compile("timestamp('bad')").getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getAllIssues().get(0).getSeverity()).isEqualTo(Severity.ERROR); + assertThat(result.getAllIssues().get(0).toDisplayString(ast.getSource())) + .isEqualTo( + "ERROR: :1:11: timestamp validation failed. Reason: evaluation error: Text 'bad'" + + " could not be parsed at index 0\n" + + " | timestamp('bad')\n" + + " | ..........^"); + } + + @Test + public void timestamp_unexpectedResultType_throws() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .setStandardEnvironmentEnabled(false) + .addFunctionDeclarations( + newFunctionDeclaration( + "timestamp", + newGlobalOverload("timestamp_overload", SimpleType.TIMESTAMP, SimpleType.INT))) + .addFunctionBindings( + CelFunctionBinding.from("timestamp_overload", Long.class, (arg) -> 1)) + .build(); + CelAbstractSyntaxTree ast = cel.compile("timestamp(0)").getAst(); + CelValidator celValidator = + CelValidatorFactory.standardCelValidatorBuilder(cel) + .addAstValidators(TimestampLiteralValidator.INSTANCE) + .build(); + + CelValidationResult result = celValidator.validate(ast); + + assertThat(result.hasError()).isTrue(); + assertThat(result.getAllIssues()).hasSize(1); + assertThat(result.getAllIssues().get(0).getSeverity()).isEqualTo(Severity.ERROR); + assertThat(result.getAllIssues().get(0).toDisplayString(ast.getSource())) + .isEqualTo( + "ERROR: :1:11: timestamp validation failed. Reason: Expected" + + " java.time.Instant type but got java.lang.Integer instead\n" + + " | timestamp(0)\n" + + " | ..........^"); + } + + @Test + @TestParameters("{source: '{1: 2}'}") + @TestParameters("{source: '[1,2,3]'}") + public void parentIsNotCallExpr_doesNotThrow(String source) throws Exception { + CelAbstractSyntaxTree ast = CEL.compile(source).getAst(); + + CelValidationResult result = CEL_VALIDATOR.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + } + + @Test + public void env_withSetResultType_success() throws Exception { + Cel cel = + CelFactory.standardCelBuilder() + .setOptions(CelOptions.current().build()) + .setResultType(SimpleType.BOOL) + .build(); + CelValidator validator = + CelValidatorFactory.standardCelValidatorBuilder(cel) + .addAstValidators(TimestampLiteralValidator.INSTANCE) + .build(); + CelAbstractSyntaxTree ast = cel.compile("timestamp(123) == timestamp(123)").getAst(); + + CelValidationResult result = validator.validate(ast); + + assertThat(result.hasError()).isFalse(); + assertThat(result.getAllIssues()).isEmpty(); + } +} diff --git a/validator/validators/BUILD.bazel b/validator/validators/BUILD.bazel new file mode 100644 index 000000000..8054ae092 --- /dev/null +++ b/validator/validators/BUILD.bazel @@ -0,0 +1,41 @@ +load("@rules_java//java:defs.bzl", "java_library") + +package( + default_applicable_licenses = ["//:license"], + default_visibility = ["//visibility:public"], +) + +java_library( + name = "timestamp", + exports = ["//validator/src/main/java/dev/cel/validator/validators:timestamp"], +) + +java_library( + name = "duration", + exports = ["//validator/src/main/java/dev/cel/validator/validators:duration"], +) + +java_library( + name = "regex", + exports = ["//validator/src/main/java/dev/cel/validator/validators:regex"], +) + +java_library( + name = "homogeneous_literal", + exports = ["//validator/src/main/java/dev/cel/validator/validators:homogeneous_literal"], +) + +java_library( + name = "ast_depth_limit_validator", + exports = ["//validator/src/main/java/dev/cel/validator/validators:ast_depth_limit_validator"], +) + +java_library( + name = "comprehension_nesting_limit_validator", + exports = ["//validator/src/main/java/dev/cel/validator/validators:comprehension_nesting_limit_validator"], +) + +java_library( + name = "literal_validator", + exports = ["//validator/src/main/java/dev/cel/validator/validators:literal_validator"], +)