Showing preview only (9,308K chars total). Download the full file or copy to clipboard to get everything.
Repository: google/cel-cpp
Branch: master
Commit: 9e73d93f77a1
Files: 1115
Total size: 8.7 MB
Directory structure:
gitextract_qb36pkd3/
├── .bazelrc
├── .bazelversion
├── .bcr/
│ ├── README.md
│ ├── metadata.template.json
│ ├── presubmit.yml
│ └── source.template.json
├── .github/
│ └── workflows/
│ └── publish_to_bcr.yml
├── .gitignore
├── BUILD.bazel
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Dockerfile
├── LICENSE
├── MODULE.bazel
├── README.md
├── base/
│ ├── BUILD
│ ├── ast.h
│ ├── attribute.cc
│ ├── attribute.h
│ ├── attribute_set.h
│ ├── builtins.h
│ ├── function.h
│ ├── function_adapter.h
│ ├── function_descriptor.h
│ ├── function_result.h
│ ├── function_result_set.cc
│ ├── function_result_set.h
│ ├── internal/
│ │ ├── BUILD
│ │ ├── memory_manager_testing.cc
│ │ ├── memory_manager_testing.h
│ │ ├── message_wrapper.h
│ │ ├── operators.h
│ │ ├── unknown_set.cc
│ │ └── unknown_set.h
│ ├── kind.h
│ ├── operators.cc
│ ├── operators.h
│ ├── operators_test.cc
│ └── type_provider.h
├── bazel/
│ ├── BUILD
│ ├── antlr.bzl
│ ├── antlr.patch
│ ├── cat_param_file.cc
│ ├── cel_cc_embed.bzl
│ ├── cel_cc_embed.cc
│ ├── cel_proto_transitive_descriptor_set.bzl
│ └── deps.bzl
├── checker/
│ ├── BUILD
│ ├── checker_options.h
│ ├── internal/
│ │ ├── BUILD
│ │ ├── builtins_arena.cc
│ │ ├── builtins_arena.h
│ │ ├── descriptor_pool_type_introspector.cc
│ │ ├── descriptor_pool_type_introspector.h
│ │ ├── descriptor_pool_type_introspector_test.cc
│ │ ├── format_type_name.cc
│ │ ├── format_type_name.h
│ │ ├── format_type_name_test.cc
│ │ ├── namespace_generator.cc
│ │ ├── namespace_generator.h
│ │ ├── namespace_generator_test.cc
│ │ ├── test_ast_helpers.cc
│ │ ├── test_ast_helpers.h
│ │ ├── test_ast_helpers_test.cc
│ │ ├── type_check_env.cc
│ │ ├── type_check_env.h
│ │ ├── type_checker_builder_impl.cc
│ │ ├── type_checker_builder_impl.h
│ │ ├── type_checker_builder_impl_test.cc
│ │ ├── type_checker_impl.cc
│ │ ├── type_checker_impl.h
│ │ ├── type_checker_impl_test.cc
│ │ ├── type_inference_context.cc
│ │ ├── type_inference_context.h
│ │ └── type_inference_context_test.cc
│ ├── optional.cc
│ ├── optional.h
│ ├── optional_test.cc
│ ├── standard_library.cc
│ ├── standard_library.h
│ ├── standard_library_test.cc
│ ├── type_check_issue.cc
│ ├── type_check_issue.h
│ ├── type_check_issue_test.cc
│ ├── type_checker.cc
│ ├── type_checker.h
│ ├── type_checker_builder.h
│ ├── type_checker_builder_factory.cc
│ ├── type_checker_builder_factory.h
│ ├── type_checker_builder_factory_test.cc
│ ├── type_checker_subset_factory.cc
│ ├── type_checker_subset_factory.h
│ ├── type_checker_subset_factory_test.cc
│ ├── validation_result.cc
│ ├── validation_result.h
│ └── validation_result_test.cc
├── cloudbuild.yaml
├── codelab/
│ ├── BUILD
│ ├── Dockerfile
│ ├── README.md
│ ├── cel_compiler.h
│ ├── cel_compiler_test.cc
│ ├── exercise1.cc
│ ├── exercise1.h
│ ├── exercise10.cc
│ ├── exercise10.h
│ ├── exercise10_test.cc
│ ├── exercise1_test.cc
│ ├── exercise2.cc
│ ├── exercise2.h
│ ├── exercise2_test.cc
│ ├── exercise3_test.cc
│ ├── exercise4.cc
│ ├── exercise4.h
│ ├── exercise4_test.cc
│ ├── network_functions.cc
│ ├── network_functions.h
│ ├── network_functions_test.cc
│ └── solutions/
│ ├── BUILD
│ ├── exercise1.cc
│ ├── exercise10.cc
│ ├── exercise2.cc
│ ├── exercise3_test.cc
│ └── exercise4.cc
├── common/
│ ├── BUILD
│ ├── allocator.h
│ ├── allocator_test.cc
│ ├── any.cc
│ ├── any.h
│ ├── any_test.cc
│ ├── arena.h
│ ├── arena_string.h
│ ├── arena_string_pool.h
│ ├── arena_string_pool_test.cc
│ ├── arena_string_test.cc
│ ├── arena_string_view.h
│ ├── arena_string_view_test.cc
│ ├── ast/
│ │ ├── BUILD
│ │ ├── constant_proto.cc
│ │ ├── constant_proto.h
│ │ ├── expr_proto.cc
│ │ ├── expr_proto.h
│ │ ├── expr_proto_test.cc
│ │ ├── metadata.cc
│ │ ├── metadata.h
│ │ ├── metadata_test.cc
│ │ ├── navigable_ast_internal.h
│ │ ├── navigable_ast_internal_test.cc
│ │ ├── navigable_ast_kinds.cc
│ │ ├── navigable_ast_kinds.h
│ │ ├── source_info_proto.cc
│ │ └── source_info_proto.h
│ ├── ast.cc
│ ├── ast.h
│ ├── ast_proto.cc
│ ├── ast_proto.h
│ ├── ast_proto_test.cc
│ ├── ast_rewrite.cc
│ ├── ast_rewrite.h
│ ├── ast_rewrite_test.cc
│ ├── ast_test.cc
│ ├── ast_traverse.cc
│ ├── ast_traverse.h
│ ├── ast_traverse_test.cc
│ ├── ast_visitor.h
│ ├── ast_visitor_base.h
│ ├── casting.h
│ ├── constant.cc
│ ├── constant.h
│ ├── constant_test.cc
│ ├── container.cc
│ ├── container.h
│ ├── container_test.cc
│ ├── data.h
│ ├── data_test.cc
│ ├── decl.cc
│ ├── decl.h
│ ├── decl_proto.cc
│ ├── decl_proto.h
│ ├── decl_proto_test.cc
│ ├── decl_proto_v1alpha1.cc
│ ├── decl_proto_v1alpha1.h
│ ├── decl_test.cc
│ ├── expr.cc
│ ├── expr.h
│ ├── expr_factory.h
│ ├── expr_test.cc
│ ├── function_descriptor.cc
│ ├── function_descriptor.h
│ ├── internal/
│ │ ├── BUILD
│ │ ├── byte_string.cc
│ │ ├── byte_string.h
│ │ ├── byte_string_test.cc
│ │ ├── casting.h
│ │ ├── metadata.h
│ │ ├── reference_count.cc
│ │ ├── reference_count.h
│ │ ├── reference_count_test.cc
│ │ ├── signature.cc
│ │ ├── signature.h
│ │ ├── signature_test.cc
│ │ ├── value_conversion.cc
│ │ └── value_conversion.h
│ ├── json.h
│ ├── kind.cc
│ ├── kind.h
│ ├── kind_test.cc
│ ├── legacy_value.cc
│ ├── legacy_value.h
│ ├── memory.cc
│ ├── memory.h
│ ├── memory_test.cc
│ ├── memory_testing.h
│ ├── minimal_descriptor_database.cc
│ ├── minimal_descriptor_database.h
│ ├── minimal_descriptor_database_test.cc
│ ├── minimal_descriptor_pool.cc
│ ├── minimal_descriptor_pool.h
│ ├── minimal_descriptor_pool_test.cc
│ ├── native_type.h
│ ├── navigable_ast.cc
│ ├── navigable_ast.h
│ ├── navigable_ast_test.cc
│ ├── operators.cc
│ ├── operators.h
│ ├── optional_ref.h
│ ├── reference.cc
│ ├── reference.h
│ ├── reference_count.h
│ ├── reference_test.cc
│ ├── source.cc
│ ├── source.h
│ ├── source_test.cc
│ ├── standard_definitions.h
│ ├── type.cc
│ ├── type.h
│ ├── type_introspector.cc
│ ├── type_introspector.h
│ ├── type_kind.h
│ ├── type_proto.cc
│ ├── type_proto.h
│ ├── type_proto_test.cc
│ ├── type_reflector.h
│ ├── type_reflector_test.cc
│ ├── type_test.cc
│ ├── type_testing.h
│ ├── typeinfo.cc
│ ├── typeinfo.h
│ ├── typeinfo_test.cc
│ ├── types/
│ │ ├── any_type.h
│ │ ├── any_type_test.cc
│ │ ├── basic_struct_type.cc
│ │ ├── basic_struct_type.h
│ │ ├── basic_struct_type_test.cc
│ │ ├── bool_type.h
│ │ ├── bool_type_test.cc
│ │ ├── bool_wrapper_type.h
│ │ ├── bool_wrapper_type_test.cc
│ │ ├── bytes_type.h
│ │ ├── bytes_type_test.cc
│ │ ├── bytes_wrapper_type.h
│ │ ├── bytes_wrapper_type_test.cc
│ │ ├── double_type.h
│ │ ├── double_type_test.cc
│ │ ├── double_wrapper_type.h
│ │ ├── double_wrapper_type_test.cc
│ │ ├── duration_type.h
│ │ ├── duration_type_test.cc
│ │ ├── dyn_type.h
│ │ ├── dyn_type_test.cc
│ │ ├── enum_type.cc
│ │ ├── enum_type.h
│ │ ├── enum_type_test.cc
│ │ ├── error_type.h
│ │ ├── error_type_test.cc
│ │ ├── function_type.cc
│ │ ├── function_type.h
│ │ ├── function_type_pool.cc
│ │ ├── function_type_pool.h
│ │ ├── function_type_test.cc
│ │ ├── int_type.h
│ │ ├── int_type_test.cc
│ │ ├── int_wrapper_type.h
│ │ ├── int_wrapper_type_test.cc
│ │ ├── legacy_type_introspector.h
│ │ ├── list_type.cc
│ │ ├── list_type.h
│ │ ├── list_type_pool.cc
│ │ ├── list_type_pool.h
│ │ ├── list_type_test.cc
│ │ ├── map_type.cc
│ │ ├── map_type.h
│ │ ├── map_type_pool.cc
│ │ ├── map_type_pool.h
│ │ ├── map_type_test.cc
│ │ ├── message_type.cc
│ │ ├── message_type.h
│ │ ├── message_type_test.cc
│ │ ├── null_type.h
│ │ ├── null_type_test.cc
│ │ ├── opaque_type.cc
│ │ ├── opaque_type.h
│ │ ├── opaque_type_pool.cc
│ │ ├── opaque_type_pool.h
│ │ ├── opaque_type_test.cc
│ │ ├── optional_type.cc
│ │ ├── optional_type.h
│ │ ├── optional_type_test.cc
│ │ ├── string_type.h
│ │ ├── string_type_test.cc
│ │ ├── string_wrapper_type.h
│ │ ├── string_wrapper_type_test.cc
│ │ ├── struct_type.cc
│ │ ├── struct_type.h
│ │ ├── struct_type_test.cc
│ │ ├── timestamp_type.h
│ │ ├── timestamp_type_test.cc
│ │ ├── type_param_type.h
│ │ ├── type_param_type_test.cc
│ │ ├── type_pool.cc
│ │ ├── type_pool.h
│ │ ├── type_pool_test.cc
│ │ ├── type_type.cc
│ │ ├── type_type.h
│ │ ├── type_type_pool.cc
│ │ ├── type_type_pool.h
│ │ ├── type_type_test.cc
│ │ ├── types.h
│ │ ├── uint_type.h
│ │ ├── uint_type_test.cc
│ │ ├── uint_wrapper_type.h
│ │ ├── uint_wrapper_type_test.cc
│ │ ├── unknown_type.h
│ │ └── unknown_type_test.cc
│ ├── unknown.h
│ ├── value.cc
│ ├── value.h
│ ├── value_kind.h
│ ├── value_test.cc
│ ├── value_testing.cc
│ ├── value_testing.h
│ ├── value_testing_test.cc
│ └── values/
│ ├── bool_value.cc
│ ├── bool_value.h
│ ├── bool_value_test.cc
│ ├── bytes_value.cc
│ ├── bytes_value.h
│ ├── bytes_value_input_stream.h
│ ├── bytes_value_output_stream.h
│ ├── bytes_value_test.cc
│ ├── custom_list_value.cc
│ ├── custom_list_value.h
│ ├── custom_list_value_test.cc
│ ├── custom_map_value.cc
│ ├── custom_map_value.h
│ ├── custom_map_value_test.cc
│ ├── custom_struct_value.cc
│ ├── custom_struct_value.h
│ ├── custom_struct_value_test.cc
│ ├── custom_value.h
│ ├── double_value.cc
│ ├── double_value.h
│ ├── double_value_test.cc
│ ├── duration_value.cc
│ ├── duration_value.h
│ ├── duration_value_test.cc
│ ├── enum_value.h
│ ├── error_value.cc
│ ├── error_value.h
│ ├── error_value_test.cc
│ ├── int_value.cc
│ ├── int_value.h
│ ├── int_value_test.cc
│ ├── legacy_list_value.cc
│ ├── legacy_list_value.h
│ ├── legacy_map_value.cc
│ ├── legacy_map_value.h
│ ├── legacy_struct_value.cc
│ ├── legacy_struct_value.h
│ ├── list_value.cc
│ ├── list_value.h
│ ├── list_value_builder.h
│ ├── list_value_test.cc
│ ├── list_value_variant.h
│ ├── map_value.cc
│ ├── map_value.h
│ ├── map_value_builder.h
│ ├── map_value_test.cc
│ ├── map_value_variant.h
│ ├── message_value.cc
│ ├── message_value.h
│ ├── message_value_test.cc
│ ├── mutable_list_value_test.cc
│ ├── mutable_map_value_test.cc
│ ├── null_value.cc
│ ├── null_value.h
│ ├── null_value_test.cc
│ ├── opaque_value.cc
│ ├── opaque_value.h
│ ├── optional_value.cc
│ ├── optional_value.h
│ ├── optional_value_test.cc
│ ├── parsed_json_list_value.cc
│ ├── parsed_json_list_value.h
│ ├── parsed_json_list_value_test.cc
│ ├── parsed_json_map_value.cc
│ ├── parsed_json_map_value.h
│ ├── parsed_json_map_value_test.cc
│ ├── parsed_json_value.cc
│ ├── parsed_json_value.h
│ ├── parsed_json_value_test.cc
│ ├── parsed_map_field_value.cc
│ ├── parsed_map_field_value.h
│ ├── parsed_map_field_value_test.cc
│ ├── parsed_message_value.cc
│ ├── parsed_message_value.h
│ ├── parsed_message_value_test.cc
│ ├── parsed_repeated_field_value.cc
│ ├── parsed_repeated_field_value.h
│ ├── parsed_repeated_field_value_test.cc
│ ├── string_value.cc
│ ├── string_value.h
│ ├── string_value_test.cc
│ ├── struct_value.cc
│ ├── struct_value.h
│ ├── struct_value_builder.cc
│ ├── struct_value_builder.h
│ ├── struct_value_test.cc
│ ├── struct_value_variant.h
│ ├── timestamp_value.cc
│ ├── timestamp_value.h
│ ├── timestamp_value_test.cc
│ ├── type_value.cc
│ ├── type_value.h
│ ├── type_value_test.cc
│ ├── uint_value.cc
│ ├── uint_value.h
│ ├── uint_value_test.cc
│ ├── unknown_value.cc
│ ├── unknown_value.h
│ ├── unknown_value_test.cc
│ ├── value_builder.cc
│ ├── value_builder.h
│ ├── value_variant.cc
│ ├── value_variant.h
│ ├── value_variant_test.cc
│ └── values.h
├── compiler/
│ ├── BUILD
│ ├── compiler.h
│ ├── compiler_factory.cc
│ ├── compiler_factory.h
│ ├── compiler_factory_test.cc
│ ├── compiler_library_subset_factory.cc
│ ├── compiler_library_subset_factory.h
│ ├── compiler_library_subset_factory_test.cc
│ ├── optional.cc
│ ├── optional.h
│ ├── optional_test.cc
│ ├── standard_library.cc
│ └── standard_library.h
├── conformance/
│ ├── BUILD
│ ├── run.bzl
│ ├── run.cc
│ ├── service.cc
│ ├── service.h
│ └── utils.h
├── env/
│ ├── BUILD
│ ├── config.cc
│ ├── config.h
│ ├── config_test.cc
│ ├── env.cc
│ ├── env.h
│ ├── env_runtime.cc
│ ├── env_runtime.h
│ ├── env_runtime_test.cc
│ ├── env_std_extensions.cc
│ ├── env_std_extensions.h
│ ├── env_std_extensions_test.cc
│ ├── env_test.cc
│ ├── env_yaml.cc
│ ├── env_yaml.h
│ ├── env_yaml_test.cc
│ ├── internal/
│ │ ├── BUILD
│ │ ├── ext_registry.cc
│ │ ├── ext_registry.h
│ │ ├── ext_registry_test.cc
│ │ ├── runtime_ext_registry.cc
│ │ ├── runtime_ext_registry.h
│ │ └── runtime_ext_registry_test.cc
│ ├── runtime_std_extensions.cc
│ ├── runtime_std_extensions.h
│ ├── runtime_std_extensions_test.cc
│ ├── type_info.cc
│ ├── type_info.h
│ └── type_info_test.cc
├── eval/
│ ├── BUILD
│ ├── LICENSE
│ ├── README.md
│ ├── compiler/
│ │ ├── BUILD
│ │ ├── LICENSE
│ │ ├── cel_expression_builder_flat_impl.cc
│ │ ├── cel_expression_builder_flat_impl.h
│ │ ├── cel_expression_builder_flat_impl_test.cc
│ │ ├── check_ast_extensions.cc
│ │ ├── check_ast_extensions.h
│ │ ├── check_ast_extensions_test.cc
│ │ ├── comprehension_vulnerability_check.cc
│ │ ├── comprehension_vulnerability_check.h
│ │ ├── constant_folding.cc
│ │ ├── constant_folding.h
│ │ ├── constant_folding_test.cc
│ │ ├── flat_expr_builder.cc
│ │ ├── flat_expr_builder.h
│ │ ├── flat_expr_builder_comprehensions_test.cc
│ │ ├── flat_expr_builder_extensions.cc
│ │ ├── flat_expr_builder_extensions.h
│ │ ├── flat_expr_builder_extensions_test.cc
│ │ ├── flat_expr_builder_short_circuiting_conformance_test.cc
│ │ ├── flat_expr_builder_test.cc
│ │ ├── instrumentation.cc
│ │ ├── instrumentation.h
│ │ ├── instrumentation_test.cc
│ │ ├── qualified_reference_resolver.cc
│ │ ├── qualified_reference_resolver.h
│ │ ├── qualified_reference_resolver_test.cc
│ │ ├── regex_precompilation_optimization.cc
│ │ ├── regex_precompilation_optimization.h
│ │ ├── regex_precompilation_optimization_test.cc
│ │ ├── resolver.cc
│ │ ├── resolver.h
│ │ └── resolver_test.cc
│ ├── eval/
│ │ ├── BUILD
│ │ ├── LICENSE
│ │ ├── attribute_trail.cc
│ │ ├── attribute_trail.h
│ │ ├── attribute_trail_test.cc
│ │ ├── attribute_utility.cc
│ │ ├── attribute_utility.h
│ │ ├── attribute_utility_test.cc
│ │ ├── cel_expression_flat_impl.cc
│ │ ├── cel_expression_flat_impl.h
│ │ ├── compiler_constant_step.cc
│ │ ├── compiler_constant_step.h
│ │ ├── compiler_constant_step_test.cc
│ │ ├── comprehension_slots.h
│ │ ├── comprehension_slots_test.cc
│ │ ├── comprehension_step.cc
│ │ ├── comprehension_step.h
│ │ ├── comprehension_step_test.cc
│ │ ├── const_value_step.h
│ │ ├── container_access_step.cc
│ │ ├── container_access_step.h
│ │ ├── container_access_step_test.cc
│ │ ├── create_list_step.cc
│ │ ├── create_list_step.h
│ │ ├── create_list_step_test.cc
│ │ ├── create_map_step.cc
│ │ ├── create_map_step.h
│ │ ├── create_map_step_test.cc
│ │ ├── create_struct_step.cc
│ │ ├── create_struct_step.h
│ │ ├── create_struct_step_test.cc
│ │ ├── direct_expression_step.cc
│ │ ├── direct_expression_step.h
│ │ ├── equality_steps.cc
│ │ ├── equality_steps.h
│ │ ├── equality_steps_test.cc
│ │ ├── evaluator_core.cc
│ │ ├── evaluator_core.h
│ │ ├── evaluator_core_test.cc
│ │ ├── evaluator_stack.cc
│ │ ├── evaluator_stack.h
│ │ ├── evaluator_stack_test.cc
│ │ ├── expression_step_base.h
│ │ ├── function_step.cc
│ │ ├── function_step.h
│ │ ├── function_step_test.cc
│ │ ├── ident_step.cc
│ │ ├── ident_step.h
│ │ ├── ident_step_test.cc
│ │ ├── iterator_stack.h
│ │ ├── jump_step.cc
│ │ ├── jump_step.h
│ │ ├── lazy_init_step.cc
│ │ ├── lazy_init_step.h
│ │ ├── lazy_init_step_test.cc
│ │ ├── logic_step.cc
│ │ ├── logic_step.h
│ │ ├── logic_step_test.cc
│ │ ├── optional_or_step.cc
│ │ ├── optional_or_step.h
│ │ ├── optional_or_step_test.cc
│ │ ├── regex_match_step.cc
│ │ ├── regex_match_step.h
│ │ ├── regex_match_step_test.cc
│ │ ├── select_step.cc
│ │ ├── select_step.h
│ │ ├── select_step_test.cc
│ │ ├── shadowable_value_step.cc
│ │ ├── shadowable_value_step.h
│ │ ├── shadowable_value_step_test.cc
│ │ ├── ternary_step.cc
│ │ ├── ternary_step.h
│ │ ├── ternary_step_test.cc
│ │ └── trace_step.h
│ ├── internal/
│ │ ├── BUILD
│ │ ├── adapter_activation_impl.cc
│ │ ├── adapter_activation_impl.h
│ │ ├── cel_value_equal.cc
│ │ ├── cel_value_equal.h
│ │ ├── cel_value_equal_test.cc
│ │ ├── errors.cc
│ │ ├── errors.h
│ │ └── interop.h
│ ├── public/
│ │ ├── BUILD
│ │ ├── LICENSE
│ │ ├── activation.cc
│ │ ├── activation.h
│ │ ├── activation_bind_helper.cc
│ │ ├── activation_bind_helper.h
│ │ ├── activation_bind_helper_test.cc
│ │ ├── activation_test.cc
│ │ ├── ast_rewrite.cc
│ │ ├── ast_rewrite.h
│ │ ├── ast_rewrite_test.cc
│ │ ├── ast_traverse.cc
│ │ ├── ast_traverse.h
│ │ ├── ast_traverse_test.cc
│ │ ├── ast_visitor.h
│ │ ├── ast_visitor_base.h
│ │ ├── base_activation.h
│ │ ├── builtin_func_registrar.cc
│ │ ├── builtin_func_registrar.h
│ │ ├── builtin_func_registrar_test.cc
│ │ ├── builtin_func_test.cc
│ │ ├── cel_attribute.cc
│ │ ├── cel_attribute.h
│ │ ├── cel_attribute_test.cc
│ │ ├── cel_builtins.h
│ │ ├── cel_expr_builder_factory.cc
│ │ ├── cel_expr_builder_factory.h
│ │ ├── cel_expression.h
│ │ ├── cel_function.cc
│ │ ├── cel_function.h
│ │ ├── cel_function_adapter.h
│ │ ├── cel_function_adapter_impl.h
│ │ ├── cel_function_adapter_test.cc
│ │ ├── cel_function_registry.cc
│ │ ├── cel_function_registry.h
│ │ ├── cel_function_registry_test.cc
│ │ ├── cel_number.cc
│ │ ├── cel_number.h
│ │ ├── cel_number_test.cc
│ │ ├── cel_options.cc
│ │ ├── cel_options.h
│ │ ├── cel_type_registry.cc
│ │ ├── cel_type_registry.h
│ │ ├── cel_type_registry_protobuf_reflection_test.cc
│ │ ├── cel_type_registry_test.cc
│ │ ├── cel_value.cc
│ │ ├── cel_value.h
│ │ ├── cel_value_internal.h
│ │ ├── cel_value_producer.h
│ │ ├── cel_value_test.cc
│ │ ├── comparison_functions.cc
│ │ ├── comparison_functions.h
│ │ ├── comparison_functions_test.cc
│ │ ├── container_function_registrar.cc
│ │ ├── container_function_registrar.h
│ │ ├── container_function_registrar_test.cc
│ │ ├── containers/
│ │ │ ├── BUILD
│ │ │ ├── container_backed_list_impl.h
│ │ │ ├── container_backed_map_impl.cc
│ │ │ ├── container_backed_map_impl.h
│ │ │ ├── container_backed_map_impl_test.cc
│ │ │ ├── field_access.cc
│ │ │ ├── field_access.h
│ │ │ ├── field_access_test.cc
│ │ │ ├── field_backed_list_impl.h
│ │ │ ├── field_backed_list_impl_test.cc
│ │ │ ├── field_backed_map_impl.h
│ │ │ ├── field_backed_map_impl_test.cc
│ │ │ ├── internal_field_backed_list_impl.cc
│ │ │ ├── internal_field_backed_list_impl.h
│ │ │ ├── internal_field_backed_list_impl_test.cc
│ │ │ ├── internal_field_backed_map_impl.cc
│ │ │ ├── internal_field_backed_map_impl.h
│ │ │ └── internal_field_backed_map_impl_test.cc
│ │ ├── equality_function_registrar.cc
│ │ ├── equality_function_registrar.h
│ │ ├── equality_function_registrar_test.cc
│ │ ├── extension_func_registrar.cc
│ │ ├── extension_func_registrar.h
│ │ ├── extension_func_test.cc
│ │ ├── logical_function_registrar.cc
│ │ ├── logical_function_registrar.h
│ │ ├── logical_function_registrar_test.cc
│ │ ├── message_wrapper.h
│ │ ├── message_wrapper_test.cc
│ │ ├── portable_cel_function_adapter.h
│ │ ├── set_util.cc
│ │ ├── set_util.h
│ │ ├── set_util_test.cc
│ │ ├── source_position.cc
│ │ ├── source_position.h
│ │ ├── source_position_test.cc
│ │ ├── string_extension_func_registrar.cc
│ │ ├── string_extension_func_registrar.h
│ │ ├── string_extension_func_registrar_test.cc
│ │ ├── structs/
│ │ │ ├── BUILD
│ │ │ ├── cel_proto_descriptor_pool_builder.cc
│ │ │ ├── cel_proto_descriptor_pool_builder.h
│ │ │ ├── cel_proto_descriptor_pool_builder_test.cc
│ │ │ ├── cel_proto_wrap_util.cc
│ │ │ ├── cel_proto_wrap_util.h
│ │ │ ├── cel_proto_wrap_util_test.cc
│ │ │ ├── cel_proto_wrapper.cc
│ │ │ ├── cel_proto_wrapper.h
│ │ │ ├── cel_proto_wrapper_test.cc
│ │ │ ├── dynamic_descriptor_pool_end_to_end_test.cc
│ │ │ ├── field_access_impl.cc
│ │ │ ├── field_access_impl.h
│ │ │ ├── field_access_impl_test.cc
│ │ │ ├── legacy_type_adapter.h
│ │ │ ├── legacy_type_adapter_test.cc
│ │ │ ├── legacy_type_info_apis.h
│ │ │ ├── legacy_type_provider.cc
│ │ │ ├── legacy_type_provider.h
│ │ │ ├── legacy_type_provider_test.cc
│ │ │ ├── proto_message_type_adapter.cc
│ │ │ ├── proto_message_type_adapter.h
│ │ │ ├── proto_message_type_adapter_test.cc
│ │ │ ├── protobuf_descriptor_type_provider.cc
│ │ │ ├── protobuf_descriptor_type_provider.h
│ │ │ ├── protobuf_descriptor_type_provider_test.cc
│ │ │ ├── protobuf_value_factory.h
│ │ │ ├── trivial_legacy_type_info.h
│ │ │ └── trivial_legacy_type_info_test.cc
│ │ ├── testing/
│ │ │ ├── BUILD
│ │ │ ├── matchers.cc
│ │ │ ├── matchers.h
│ │ │ └── matchers_test.cc
│ │ ├── transform_utility.cc
│ │ ├── transform_utility.h
│ │ ├── unknown_attribute_set.h
│ │ ├── unknown_attribute_set_test.cc
│ │ ├── unknown_function_result_set.cc
│ │ ├── unknown_function_result_set.h
│ │ ├── unknown_function_result_set_test.cc
│ │ ├── unknown_set.h
│ │ ├── unknown_set_test.cc
│ │ ├── value_export_util.cc
│ │ ├── value_export_util.h
│ │ └── value_export_util_test.cc
│ ├── tests/
│ │ ├── BUILD
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── allocation_benchmark_test.cc
│ │ ├── benchmark_test.cc
│ │ ├── end_to_end_test.cc
│ │ ├── expression_builder_benchmark_test.cc
│ │ ├── memory_safety_test.cc
│ │ ├── mock_cel_expression.h
│ │ ├── modern_benchmark_test.cc
│ │ ├── request_context.proto
│ │ └── unknowns_end_to_end_test.cc
│ └── testutil/
│ ├── BUILD
│ ├── test_extensions.proto
│ └── test_message.proto
├── extensions/
│ ├── BUILD
│ ├── bindings_ext.cc
│ ├── bindings_ext.h
│ ├── bindings_ext_benchmark_test.cc
│ ├── bindings_ext_test.cc
│ ├── comprehensions_v2.cc
│ ├── comprehensions_v2.h
│ ├── comprehensions_v2_functions.cc
│ ├── comprehensions_v2_functions.h
│ ├── comprehensions_v2_macros.cc
│ ├── comprehensions_v2_macros.h
│ ├── comprehensions_v2_test.cc
│ ├── encoders.cc
│ ├── encoders.h
│ ├── encoders_test.cc
│ ├── formatting.cc
│ ├── formatting.h
│ ├── formatting_test.cc
│ ├── lists_functions.cc
│ ├── lists_functions.h
│ ├── lists_functions_test.cc
│ ├── math_ext.cc
│ ├── math_ext.h
│ ├── math_ext_decls.cc
│ ├── math_ext_decls.h
│ ├── math_ext_macros.cc
│ ├── math_ext_macros.h
│ ├── math_ext_test.cc
│ ├── proto_ext.cc
│ ├── proto_ext.h
│ ├── protobuf/
│ │ ├── BUILD
│ │ ├── ast_converters.h
│ │ ├── bind_proto_to_activation.cc
│ │ ├── bind_proto_to_activation.h
│ │ ├── bind_proto_to_activation_test.cc
│ │ ├── enum_adapter.cc
│ │ ├── enum_adapter.h
│ │ ├── internal/
│ │ │ ├── BUILD
│ │ │ ├── map_reflection.cc
│ │ │ ├── map_reflection.h
│ │ │ ├── qualify.cc
│ │ │ └── qualify.h
│ │ ├── memory_manager.cc
│ │ ├── memory_manager.h
│ │ ├── memory_manager_test.cc
│ │ ├── runtime_adapter.cc
│ │ ├── runtime_adapter.h
│ │ ├── value.h
│ │ ├── value_end_to_end_test.cc
│ │ ├── value_test.cc
│ │ ├── value_testing.h
│ │ └── value_testing_test.cc
│ ├── regex_ext.cc
│ ├── regex_ext.h
│ ├── regex_ext_test.cc
│ ├── regex_functions.cc
│ ├── regex_functions.h
│ ├── regex_functions_test.cc
│ ├── select_optimization.cc
│ ├── select_optimization.h
│ ├── select_optimization_test.cc
│ ├── sets_functions.cc
│ ├── sets_functions.h
│ ├── sets_functions_benchmark_test.cc
│ ├── sets_functions_test.cc
│ ├── strings.cc
│ ├── strings.h
│ └── strings_test.cc
├── internal/
│ ├── BUILD
│ ├── align.h
│ ├── align_test.cc
│ ├── benchmark.h
│ ├── casts.h
│ ├── empty_descriptors.cc
│ ├── empty_descriptors.h
│ ├── empty_descriptors_test.cc
│ ├── equals_text_proto.cc
│ ├── equals_text_proto.h
│ ├── exceptions.h
│ ├── json.cc
│ ├── json.h
│ ├── json_test.cc
│ ├── lexis.cc
│ ├── lexis.h
│ ├── lexis_test.cc
│ ├── manual.h
│ ├── message_equality.cc
│ ├── message_equality.h
│ ├── message_equality_test.cc
│ ├── message_type_name.h
│ ├── message_type_name_test.cc
│ ├── minimal_descriptor_database.h
│ ├── minimal_descriptor_pool.h
│ ├── minimal_descriptors.cc
│ ├── names.cc
│ ├── names.h
│ ├── names_test.cc
│ ├── new.cc
│ ├── new.h
│ ├── new_test.cc
│ ├── noop_delete.h
│ ├── number.h
│ ├── number_test.cc
│ ├── overflow.cc
│ ├── overflow.h
│ ├── overflow_test.cc
│ ├── parse_text_proto.h
│ ├── proto_file_util.h
│ ├── proto_matchers.h
│ ├── proto_time_encoding.cc
│ ├── proto_time_encoding.h
│ ├── proto_time_encoding_test.cc
│ ├── proto_util.h
│ ├── proto_util_test.cc
│ ├── protobuf_runtime_version.h
│ ├── re2_options.h
│ ├── status_builder.h
│ ├── status_macros.h
│ ├── string_pool.cc
│ ├── string_pool.h
│ ├── string_pool_test.cc
│ ├── strings.cc
│ ├── strings.h
│ ├── strings_test.cc
│ ├── testing.cc
│ ├── testing.h
│ ├── testing_descriptor_pool.cc
│ ├── testing_descriptor_pool.h
│ ├── testing_descriptor_pool_test.cc
│ ├── testing_message_factory.cc
│ ├── testing_message_factory.h
│ ├── time.cc
│ ├── time.h
│ ├── time_test.cc
│ ├── to_address.h
│ ├── to_address_test.cc
│ ├── unicode.h
│ ├── utf8.cc
│ ├── utf8.h
│ ├── utf8_test.cc
│ ├── well_known_types.cc
│ ├── well_known_types.h
│ └── well_known_types_test.cc
├── parser/
│ ├── BUILD
│ ├── internal/
│ │ ├── BUILD
│ │ ├── Cel.g4
│ │ └── options.h
│ ├── macro.cc
│ ├── macro.h
│ ├── macro_expr_factory.cc
│ ├── macro_expr_factory.h
│ ├── macro_expr_factory_test.cc
│ ├── macro_registry.cc
│ ├── macro_registry.h
│ ├── macro_registry_test.cc
│ ├── options.h
│ ├── parser.cc
│ ├── parser.h
│ ├── parser_benchmarks.cc
│ ├── parser_interface.h
│ ├── parser_subset_factory.cc
│ ├── parser_subset_factory.h
│ ├── parser_test.cc
│ ├── source_factory.h
│ ├── standard_macros.cc
│ ├── standard_macros.h
│ └── standard_macros_test.cc
├── runtime/
│ ├── BUILD
│ ├── activation.cc
│ ├── activation.h
│ ├── activation_interface.h
│ ├── activation_test.cc
│ ├── comprehension_vulnerability_check.cc
│ ├── comprehension_vulnerability_check.h
│ ├── comprehension_vulnerability_check_test.cc
│ ├── constant_folding.cc
│ ├── constant_folding.h
│ ├── constant_folding_test.cc
│ ├── embedder_context.h
│ ├── embedder_context_test.cc
│ ├── function.h
│ ├── function_adapter.h
│ ├── function_adapter_test.cc
│ ├── function_overload_reference.h
│ ├── function_provider.h
│ ├── function_registry.cc
│ ├── function_registry.h
│ ├── function_registry_test.cc
│ ├── internal/
│ │ ├── BUILD
│ │ ├── activation_attribute_matcher_access.cc
│ │ ├── activation_attribute_matcher_access.h
│ │ ├── attribute_matcher.h
│ │ ├── convert_constant.cc
│ │ ├── convert_constant.h
│ │ ├── errors.cc
│ │ ├── errors.h
│ │ ├── function_adapter.h
│ │ ├── function_adapter_test.cc
│ │ ├── issue_collector.h
│ │ ├── issue_collector_test.cc
│ │ ├── legacy_runtime_type_provider.h
│ │ ├── runtime_env.cc
│ │ ├── runtime_env.h
│ │ ├── runtime_env_testing.cc
│ │ ├── runtime_env_testing.h
│ │ ├── runtime_friend_access.h
│ │ ├── runtime_impl.cc
│ │ ├── runtime_impl.h
│ │ ├── runtime_type_provider.cc
│ │ └── runtime_type_provider.h
│ ├── memory_safety_test.cc
│ ├── optional_types.cc
│ ├── optional_types.h
│ ├── optional_types_test.cc
│ ├── reference_resolver.cc
│ ├── reference_resolver.h
│ ├── reference_resolver_test.cc
│ ├── regex_precompilation.cc
│ ├── regex_precompilation.h
│ ├── regex_precompilation_test.cc
│ ├── register_function_helper.h
│ ├── runtime.h
│ ├── runtime_builder.h
│ ├── runtime_builder_factory.cc
│ ├── runtime_builder_factory.h
│ ├── runtime_issue.h
│ ├── runtime_options.h
│ ├── standard/
│ │ ├── BUILD
│ │ ├── arithmetic_functions.cc
│ │ ├── arithmetic_functions.h
│ │ ├── arithmetic_functions_test.cc
│ │ ├── comparison_functions.cc
│ │ ├── comparison_functions.h
│ │ ├── comparison_functions_test.cc
│ │ ├── container_functions.cc
│ │ ├── container_functions.h
│ │ ├── container_functions_test.cc
│ │ ├── container_membership_functions.cc
│ │ ├── container_membership_functions.h
│ │ ├── container_membership_functions_test.cc
│ │ ├── equality_functions.cc
│ │ ├── equality_functions.h
│ │ ├── equality_functions_test.cc
│ │ ├── logical_functions.cc
│ │ ├── logical_functions.h
│ │ ├── logical_functions_test.cc
│ │ ├── regex_functions.cc
│ │ ├── regex_functions.h
│ │ ├── regex_functions_test.cc
│ │ ├── string_functions.cc
│ │ ├── string_functions.h
│ │ ├── string_functions_test.cc
│ │ ├── time_functions.cc
│ │ ├── time_functions.h
│ │ ├── time_functions_test.cc
│ │ ├── type_conversion_functions.cc
│ │ ├── type_conversion_functions.h
│ │ └── type_conversion_functions_test.cc
│ ├── standard_functions.cc
│ ├── standard_functions.h
│ ├── standard_runtime_builder_factory.cc
│ ├── standard_runtime_builder_factory.h
│ ├── standard_runtime_builder_factory_test.cc
│ ├── type_registry.cc
│ └── type_registry.h
├── testing/
│ └── testrunner/
│ ├── BUILD
│ ├── cel_cc_test.bzl
│ ├── cel_expression_source.h
│ ├── cel_test_context.h
│ ├── cel_test_factories.h
│ ├── coverage_index.cc
│ ├── coverage_index.h
│ ├── coverage_index_test.cc
│ ├── coverage_reporting.cc
│ ├── coverage_reporting.h
│ ├── resources/
│ │ ├── BUILD
│ │ ├── simple_tests.textproto
│ │ ├── test.cel
│ │ └── test_environment.textproto
│ ├── runner_bin.cc
│ ├── runner_lib.cc
│ ├── runner_lib.h
│ ├── runner_lib_test.cc
│ └── user_tests/
│ ├── BUILD
│ ├── checked_expr_test.cc
│ ├── raw_expr_and_cel_file_test.cc
│ ├── raw_expression_test.cc
│ └── simple.cc
├── testutil/
│ ├── BUILD
│ ├── baseline_tests.cc
│ ├── baseline_tests.h
│ ├── baseline_tests_test.cc
│ ├── expr_printer.cc
│ ├── expr_printer.h
│ ├── expr_printer_test.cc
│ ├── test_json_names.proto
│ └── util.h
├── tools/
│ ├── BUILD
│ ├── branch_coverage.cc
│ ├── branch_coverage.h
│ ├── branch_coverage_test.cc
│ ├── cel_field_extractor.cc
│ ├── cel_field_extractor.h
│ ├── cel_field_extractor_test.cc
│ ├── cel_unparser.cc
│ ├── cel_unparser.h
│ ├── cel_unparser_test.cc
│ ├── descriptor_pool_builder.cc
│ ├── descriptor_pool_builder.h
│ ├── descriptor_pool_builder_test.cc
│ ├── flatbuffers_backed_impl.cc
│ ├── flatbuffers_backed_impl.h
│ ├── flatbuffers_backed_impl_test.cc
│ ├── navigable_ast.cc
│ ├── navigable_ast.h
│ ├── navigable_ast_test.cc
│ └── testdata/
│ ├── BUILD
│ ├── checked_expr_and.textproto
│ ├── const_str.textproto
│ ├── coverage_example.textproto
│ ├── exists_macro.textproto
│ ├── flatbuffers.fbs
│ ├── macro_multiple_references.textproto
│ ├── macro_nested_macro_call.textproto
│ ├── macro_single_reference.textproto
│ ├── msg_new_field.textproto
│ └── msg_new_field_int.textproto
└── validator/
├── BUILD
├── ast_depth_validator.cc
├── ast_depth_validator.h
├── ast_depth_validator_test.cc
├── comprehension_nesting_validator.cc
├── comprehension_nesting_validator.h
├── comprehension_nesting_validator_test.cc
├── homogeneous_literal_validator.cc
├── homogeneous_literal_validator.h
├── homogeneous_literal_validator_test.cc
├── regex_validator.cc
├── regex_validator.h
├── regex_validator_test.cc
├── timestamp_literal_validator.cc
├── timestamp_literal_validator.h
├── timestamp_literal_validator_test.cc
├── validator.cc
├── validator.h
└── validator_test.cc
================================================
FILE CONTENTS
================================================
================================================
FILE: .bazelrc
================================================
common --enable_platform_specific_config
build --enable_bzlmod
build --compilation_mode=fastbuild
build:linux --cxxopt=-std=c++17 --host_cxxopt=-std=c++17
build:linux --cxxopt=-fsized-deallocation
build:linux --copt=-Wno-deprecated-declarations
# you will typically need to spell out the compiler for local dev
# BAZEL_VC=<install directory>
# BAZEL_VC_FULL_VERSION=14.44.3520
build:msvc --cxxopt="-std:c++20" --cxxopt="-utf-8" --host_cxxopt="-std:c++20"
build:msvc --define=protobuf_allow_msvc=true
build:msvc --test_tag_filters=-benchmark,-notap,-no_test_msvc
build:msvc --build_tag_filters=-no_test_msvc
build:macos --cxxopt=-faligned-allocation
build:macos --cxxopt=-mmacosx-version-min=10.13
build:macos --linkopt=-mmacosx-version-min=10.13
# ANTLR tool requires Java 17+.
build --java_runtime_version=remotejdk_17
test --test_output=errors
# Enable matchers in googletest
build --define absl=1
build:asan --linkopt -ldl
build:asan --linkopt -fsanitize=address
build:asan --copt -fsanitize=address
build:asan --copt -DADDRESS_SANITIZER=1
build:asan --copt -D__SANITIZE_ADDRESS__
build:asan --test_env=ASAN_OPTIONS=handle_abort=1:allow_addr2line=true:check_initialization_order=true:strict_init_order=true:detect_odr_violation=1
build:asan --test_env=ASAN_SYMBOLIZER_PATH
build:asan --copt -O1
build:asan --copt -fno-optimize-sibling-calls
build:asan --linkopt=-fuse-ld=lld
try-import %workspace%/clang.bazelrc
try-import %workspace%/user.bazelrc
try-import %workspace%/local_tsan.bazelrc
================================================
FILE: .bazelversion
================================================
7.3.2
================================================
FILE: .bcr/README.md
================================================
# BCR Publishing Templates
This directory contains templates used by the
[Publish to BCR](https://github.com/bazel-contrib/publish-to-bcr) GitHub Action
to automatically publish new versions of cel-cpp to the
[Bazel Central Registry (BCR)](https://github.com/bazelbuild/bazel-central-registry).
## Files
- **metadata.template.json**: Contains repository metadata including homepage,
maintainers, and repository location
- **source.template.json**: Template for generating the source.json file that
tells BCR where to download release archives
- **presubmit.yml**: Defines build and test tasks that BCR will run to verify
each published version
## How it works
When a new tag matching the pattern `v*.*.*` is created: 1. The GitHub Actions
workflow `.github/workflows/publish_to_bcr.yml` is triggered 2. The workflow
uses these templates to generate a BCR entry 3. A pull request is automatically
created against the Bazel Central Registry 4. Once merged, the new version
becomes available to Bazel users via bzlmod
## Template Variables
The following variables are automatically substituted: - `{OWNER}`: Repository
owner (google) - `{REPO}`: Repository name (cel-cpp) - `{VERSION}`: Version
number extracted from the tag (e.g., `0.14.0` from `v0.14.0`) - `{TAG}`: Full
tag name (e.g., `v0.14.0`)
## More Information
- [Publish to BCR documentation](https://github.com/bazel-contrib/publish-to-bcr)
- [BCR documentation](https://bazel.build/external/registry)
================================================
FILE: .bcr/metadata.template.json
================================================
{
"homepage": "https://cel.dev",
"maintainers": [
{
"email": "ferstl@intrinsic.ai",
"github": "ferstlf",
"github_user_id": 64520639,
"name": "Florian Ferstl"
},
{
"email": "cel-lang-discuss@googlegroups.com",
"github": "cel-expr",
"github_user_id": 186625994,
"name": "CEL Team"
},
{
"github": "jnthntatum",
"github_user_id": 733856
},
{
"github": "jcking",
"github_user_id": 997958
},
{
"github": "tristonianjones",
"github_user_id": 483300
}
],
"repository": [
"github:google/cel-cpp"
],
"versions": [],
"yanked_versions": {}
}
================================================
FILE: .bcr/presubmit.yml
================================================
matrix:
platform:
- debian11
- ubuntu2004
bazel:
- 8.x
- 7.x
tasks:
verify_targets:
name: Verify build targets
platform: ${{ platform }}
bazel: ${{ bazel }}
build_flags:
- '--cxxopt=-std=c++17'
- '--host_cxxopt=-std=c++17'
- '--copt=-Wno-deprecated-declarations'
- '--define=absl=1'
build_targets:
- '@cel-cpp//...'
================================================
FILE: .bcr/source.template.json
================================================
{
"integrity": "",
"strip_prefix": "cel-cpp-{VERSION}",
"url": "https://github.com/{OWNER}/{REPO}/archive/refs/tags/{TAG}.tar.gz"
}
================================================
FILE: .github/workflows/publish_to_bcr.yml
================================================
name: Publish to BCR
on:
push:
tags:
- "v*.*.*"
permissions:
id-token: write
attestations: write
contents: write
jobs:
publish:
uses: bazel-contrib/publish-to-bcr/.github/workflows/publish.yaml@v1.0.0
with:
tag_name: ${{ github.ref_name }}
secrets:
publish_token: ${{ secrets.BCR_PUBLISH_TOKEN }}
================================================
FILE: .gitignore
================================================
bazel-bin
bazel-eval
bazel-genfiles
bazel-out
bazel-testlogs
bazel-cel-cpp
*~
clang.bazelrc
user.bazelrc
local_tsan.bazelrc
MODULE.bazel.lock
================================================
FILE: BUILD.bazel
================================================
package(default_visibility = ["//visibility:public"])
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Code of Conduct
## Version 0.1.1 (adapted from 0.3b-angular)
As contributors and maintainers of the Common Expression Language
(CEL) project, we pledge to respect everyone who contributes by
posting issues, updating documentation, submitting pull requests,
providing feedback in comments, and any other activities.
Communication through any of CEL's channels (GitHub, Gitter, IRC,
mailing lists, Google+, Twitter, etc.) must be constructive and never
resort to personal attacks, trolling, public or private harassment,
insults, or other unprofessional conduct.
We promise to extend courtesy and respect to everyone involved in this
project regardless of gender, gender identity, sexual orientation,
disability, age, race, ethnicity, religion, or level of experience. We
expect anyone contributing to the project to do the same.
If any member of the community violates this code of conduct, the
maintainers of the CEL project may take action, removing issues,
comments, and PRs or blocking accounts as deemed appropriate.
If you are subject to or witness unacceptable behavior, or have any
other concerns, please email us at
[cel-conduct@google.com](mailto:cel-conduct@google.com).
================================================
FILE: CONTRIBUTING.md
================================================
# How to Contribute
We'd love to accept your patches and contributions to this project. There are
a few guidelines you need to follow.
## Contributor License Agreement
Contributions to this project must be accompanied by a Contributor License
Agreement. 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. Head over to <https://cla.developers.google.com/> to see
your current agreements on file or to sign a new one.
You generally only need to submit a CLA once, so if you've already submitted one
(even if it was for a different project), you probably don't need to do it
again.
## 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.
## What to expect from maintainers
Expect maintainers to respond to new issues or pull requests within a week.
For outstanding and ongoing issues and particularly for long-running
pull requests, expect the maintainers to review within a week of a
contributor asking for a new review. There is no commitment to resolution --
merging or closing a pull request, or fixing or closing an issue -- because some
issues will require more discussion than others.
================================================
FILE: Dockerfile
================================================
# This Dockerfile is used to create a container around gcc9 and bazel for
# building the CEL C++ library on GitHub.
#
# To update a new version of this container, use gcloud. You may need to run
# `gcloud auth login` and `gcloud auth configure-docker` first.
#
# Note, if you need to run docker using `sudo` use the following commands
# instead:
#
# sudo gcloud auth login --no-launch-browser
# sudo gcloud auth configure-docker
#
# Run the following command from the root of the CEL repository:
#
# gcloud builds submit --region=us -t gcr.io/cel-analysis/gcc9 .
#
# Once complete get the sha256 digest from the output using the following
# command:
#
# gcloud artifacts versions list --package=gcc9 --repository=gcr.io \
# --location=us
#
# The cloudbuild.yaml file must be updated to use the new digest like so:
#
# - name: 'gcr.io/cel-analysis/gcc9@<SHA256>'
FROM gcc:9
# Install Bazel prerequesites and required tools.
# See https://docs.bazel.build/versions/master/install-ubuntu.html
RUN apt-get update && \
apt-get upgrade -y && \
apt-get install -y --no-install-recommends \
ca-certificates \
git \
libssl-dev \
make \
pkg-config \
python3 \
unzip \
wget \
zip \
zlib1g-dev \
default-jdk-headless \
clang-11 && \
apt-get clean
# Install Bazel.
# https://github.com/bazelbuild/bazel/releases
ARG BAZEL_VERSION="7.3.2"
ADD https://github.com/bazelbuild/bazel/releases/download/${BAZEL_VERSION}/bazel-${BAZEL_VERSION}-installer-linux-x86_64.sh /tmp/install_bazel.sh
RUN /bin/bash /tmp/install_bazel.sh && rm /tmp/install_bazel.sh
RUN mkdir -p /workspace
RUN mkdir -p /bazel
ENTRYPOINT ["/usr/local/bin/bazel"]
================================================
FILE: LICENSE
================================================
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.
================================================
FILE: MODULE.bazel
================================================
module(
name = "cel-cpp",
)
bazel_dep(
name = "bazel_skylib",
version = "1.9.0",
)
bazel_dep(
name = "googleapis",
version = "0.0.0-20241220-5e258e33.bcr.1",
repo_name = "com_google_googleapis",
)
bazel_dep(
name = "googleapis-cc",
version = "1.0.0",
)
bazel_dep(
name = "rules_cc",
version = "0.2.14",
)
bazel_dep(
name = "rules_java",
version = "8.6.1",
)
bazel_dep(
name = "rules_proto",
version = "7.1.0",
)
bazel_dep(
name = "rules_python",
version = "1.6.3",
)
bazel_dep(
name = "protobuf",
version = "33.4",
repo_name = "com_google_protobuf",
)
bazel_dep(
name = "abseil-cpp",
version = "20260107.0",
repo_name = "com_google_absl",
)
bazel_dep(
name = "googletest",
version = "1.17.0.bcr.2",
dev_dependency = True,
repo_name = "com_google_googletest",
)
bazel_dep(
name = "google_benchmark",
version = "1.9.2",
dev_dependency = True,
repo_name = "com_github_google_benchmark",
)
bazel_dep(
name = "re2",
version = "2025-11-05.bcr.1",
repo_name = "com_googlesource_code_re2",
)
bazel_dep(
name = "flatbuffers",
version = "25.9.23",
repo_name = "com_github_google_flatbuffers",
)
bazel_dep(
name = "cel-spec",
version = "0.25.1",
repo_name = "com_google_cel_spec",
)
bazel_dep(
name = "platforms",
version = "1.0.0",
)
ANTLR4_VERSION = "4.13.2"
bazel_dep(
name = "antlr4-cpp-runtime",
version = ANTLR4_VERSION,
)
single_version_override(
module_name = "antlr4-cpp-runtime",
patches = ["//bazel:antlr.patch"],
)
python = use_extension("@rules_python//python/extensions:python.bzl", "python")
python.toolchain(
configure_coverage_tool = False,
ignore_root_user_error = True,
python_version = "3.11",
)
http_jar = use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl", "http_jar")
http_jar(
name = "antlr4_jar",
sha256 = "eae2dfa119a64327444672aff63e9ec35a20180dc5b8090b7a6ab85125df4d76",
urls = ["https://www.antlr.org/download/antlr-" + ANTLR4_VERSION + "-complete.jar"],
)
bazel_dep(
name = "yaml-cpp",
version = "0.9.0",
)
================================================
FILE: README.md
================================================
# C++ Implementations of the Common Expression Language
For background on the Common Expression Language see the [cel-spec][1] repo.
This is a C++ implementation of a [Common Expression Language][1] runtime,
parser, and type checker.
Released under the [Apache License](LICENSE).
[1]: https://github.com/google/cel-spec
================================================
FILE: base/BUILD
================================================
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
load("@rules_cc//cc:cc_library.bzl", "cc_library")
load("@rules_cc//cc:cc_test.bzl", "cc_test")
package(
# Under active development, not yet being released.
default_visibility = ["//visibility:public"],
)
licenses(["notice"])
cc_library(
name = "attributes",
srcs = [
"attribute.cc",
],
hdrs = [
"attribute.h",
"attribute_set.h",
],
deps = [
":kind",
"//internal:status_macros",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/container:btree",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/types:optional",
"@com_google_absl//absl/types:span",
"@com_google_absl//absl/types:variant",
],
)
cc_library(
name = "kind",
hdrs = ["kind.h"],
deps = [
"//common:kind",
"//common:type_kind",
"//common:value_kind",
],
)
cc_library(
name = "operators",
srcs = ["operators.cc"],
hdrs = ["operators.h"],
deps = [
"//base/internal:operators",
"@com_google_absl//absl/base",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/types:optional",
],
)
cc_test(
name = "operators_test",
srcs = ["operators_test.cc"],
deps = [
":operators",
"//base/internal:operators",
"//internal:testing",
"@com_google_absl//absl/hash:hash_testing",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/types:optional",
],
)
# Build target encompassing cel::Type, cel::Value, and their related classes.
cc_library(
name = "data",
hdrs = [
"type_provider.h",
],
deps = [
"//common:value",
],
)
cc_library(
name = "function",
hdrs = [
"function.h",
],
deps = [
"//runtime:function",
],
)
cc_library(
name = "function_descriptor",
hdrs = [
"function_descriptor.h",
],
deps = [
"//common:function_descriptor",
],
)
cc_library(
name = "function_result",
hdrs = [
"function_result.h",
],
deps = [":function_descriptor"],
)
cc_library(
name = "function_result_set",
srcs = [
"function_result_set.cc",
],
hdrs = [
"function_result_set.h",
],
deps = [
":function_result",
"@com_google_absl//absl/container:btree",
],
)
cc_library(
name = "ast",
hdrs = ["ast.h"],
deps = ["//common:ast"],
)
cc_library(
name = "function_adapter",
hdrs = ["function_adapter.h"],
deps = [
"//runtime:function_adapter",
],
)
cc_library(
name = "builtins",
hdrs = ["builtins.h"],
)
================================================
FILE: base/ast.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_AST_H_
#define THIRD_PARTY_CEL_CPP_BASE_AST_H_
#include "common/ast.h" // IWYU pragma: export
#endif // THIRD_PARTY_CEL_CPP_BASE_AST_H_
================================================
FILE: base/attribute.cc
================================================
// 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.
#include "base/attribute.h"
#include <cstddef>
#include <cstdint>
#include <string>
#include "absl/base/macros.h"
#include "absl/base/nullability.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "absl/types/variant.h"
#include "base/kind.h"
#include "internal/status_macros.h"
namespace cel {
namespace {
// Visitor for appending string representation for different qualifier kinds.
class AttributeStringPrinter {
public:
// String representation for the given qualifier is appended to output.
// output must be non-null.
explicit AttributeStringPrinter(std::string* output, Kind type)
: output_(*output), type_(type) {}
absl::Status operator()(const Kind& ignored) const {
// Attributes are represented as a variant, with illegal attribute
// qualifiers represented with their type as the first alternative.
return absl::InvalidArgumentError(
absl::StrCat("Unsupported attribute qualifier ", KindToString(type_)));
}
absl::Status operator()(int64_t index) {
absl::StrAppend(&output_, "[", index, "]");
return absl::OkStatus();
}
absl::Status operator()(uint64_t index) {
absl::StrAppend(&output_, "[", index, "]");
return absl::OkStatus();
}
absl::Status operator()(bool bool_key) {
absl::StrAppend(&output_, "[", (bool_key) ? "true" : "false", "]");
return absl::OkStatus();
}
absl::Status operator()(const std::string& field) {
absl::StrAppend(&output_, ".", field);
return absl::OkStatus();
}
private:
std::string& output_;
Kind type_;
};
// Visitor for appending string representation for different qualifier kinds.
class AttributeQualifierStringPrinter {
public:
// String representation for the given qualifier is appended to output.
explicit AttributeQualifierStringPrinter(std::string* absl_nonnull output,
Kind type)
: output_(*output), type_(type) {}
absl::Status operator()(const Kind& ignored) const {
// Attributes are represented as a variant, with illegal attribute
// qualifiers represented with their type as the first alternative.
return absl::InvalidArgumentError(
absl::StrCat("Unsupported attribute qualifier ", KindToString(type_)));
}
absl::Status operator()(int64_t index) {
absl::StrAppend(&output_, index);
return absl::OkStatus();
}
absl::Status operator()(uint64_t index) {
absl::StrAppend(&output_, index);
return absl::OkStatus();
}
absl::Status operator()(bool bool_key) {
absl::StrAppend(&output_, (bool_key) ? "true" : "false");
return absl::OkStatus();
}
absl::Status operator()(const std::string& field) {
absl::StrAppend(&output_, field);
return absl::OkStatus();
}
private:
std::string& output_;
Kind type_;
};
struct AttributeQualifierTypeVisitor final {
Kind operator()(const Kind& type) const { return type; }
Kind operator()(int64_t ignored) const {
static_cast<void>(ignored);
return Kind::kInt64;
}
Kind operator()(uint64_t ignored) const {
static_cast<void>(ignored);
return Kind::kUint64;
}
Kind operator()(const std::string& ignored) const {
static_cast<void>(ignored);
return Kind::kString;
}
Kind operator()(bool ignored) const {
static_cast<void>(ignored);
return Kind::kBool;
}
};
struct AttributeQualifierTypeComparator final {
const Kind lhs;
bool operator()(const Kind& rhs) const {
return static_cast<int>(lhs) < static_cast<int>(rhs);
}
bool operator()(int64_t) const { return false; }
bool operator()(uint64_t other) const { return false; }
bool operator()(const std::string&) const { return false; }
bool operator()(bool other) const { return false; }
};
struct AttributeQualifierIntComparator final {
const int64_t lhs;
bool operator()(const Kind&) const { return true; }
bool operator()(int64_t rhs) const { return lhs < rhs; }
bool operator()(uint64_t) const { return true; }
bool operator()(const std::string&) const { return true; }
bool operator()(bool) const { return false; }
};
struct AttributeQualifierUintComparator final {
const uint64_t lhs;
bool operator()(const Kind&) const { return true; }
bool operator()(int64_t) const { return false; }
bool operator()(uint64_t rhs) const { return lhs < rhs; }
bool operator()(const std::string&) const { return true; }
bool operator()(bool) const { return false; }
};
struct AttributeQualifierStringComparator final {
const std::string& lhs;
bool operator()(const Kind&) const { return true; }
bool operator()(int64_t) const { return false; }
bool operator()(uint64_t) const { return false; }
bool operator()(const std::string& rhs) const { return lhs < rhs; }
bool operator()(bool) const { return false; }
};
struct AttributeQualifierBoolComparator final {
const bool lhs;
bool operator()(const Kind&) const { return true; }
bool operator()(int64_t) const { return true; }
bool operator()(uint64_t) const { return true; }
bool operator()(const std::string&) const { return true; }
bool operator()(bool rhs) const { return lhs < rhs; }
};
} // namespace
struct AttributeQualifier::ComparatorVisitor final {
const AttributeQualifier::Variant& rhs;
bool operator()(const Kind& lhs) const {
return absl::visit(AttributeQualifierTypeComparator{lhs}, rhs);
}
bool operator()(int64_t lhs) const {
return absl::visit(AttributeQualifierIntComparator{lhs}, rhs);
}
bool operator()(uint64_t lhs) const {
return absl::visit(AttributeQualifierUintComparator{lhs}, rhs);
}
bool operator()(const std::string& lhs) const {
return absl::visit(AttributeQualifierStringComparator{lhs}, rhs);
}
bool operator()(bool lhs) const {
return absl::visit(AttributeQualifierBoolComparator{lhs}, rhs);
}
};
Kind AttributeQualifier::kind() const {
return absl::visit(AttributeQualifierTypeVisitor{}, value_);
}
bool AttributeQualifier::operator<(const AttributeQualifier& other) const {
// The order is not publicly documented because it is subject to change.
// Currently we sort in the following order, with each type being sorted
// against itself: bool, int, uint, string, type.
return absl::visit(ComparatorVisitor{other.value_}, value_);
}
bool Attribute::operator==(const Attribute& other) const {
// We cannot check pointer equality as a short circuit because we have to
// treat all invalid AttributeQualifier as not equal to each other.
// TODO(issues/41) we only support Ident-rooted attributes at the moment.
if (variable_name() != other.variable_name()) {
return false;
}
if (qualifier_path().size() != other.qualifier_path().size()) {
return false;
}
for (size_t i = 0; i < qualifier_path().size(); i++) {
if (!(qualifier_path()[i] == other.qualifier_path()[i])) {
return false;
}
}
return true;
}
bool Attribute::operator<(const Attribute& other) const {
if (impl_.get() == other.impl_.get()) {
return false;
}
auto lhs_begin = qualifier_path().begin();
auto lhs_end = qualifier_path().end();
auto rhs_begin = other.qualifier_path().begin();
auto rhs_end = other.qualifier_path().end();
while (lhs_begin != lhs_end && rhs_begin != rhs_end) {
if (*lhs_begin < *rhs_begin) {
return true;
}
if (!(*lhs_begin == *rhs_begin)) {
return false;
}
lhs_begin++;
rhs_begin++;
}
if (lhs_begin == lhs_end && rhs_begin == rhs_end) {
// Neither has any elements left, they are equal. Compare variable names.
return variable_name() < other.variable_name();
}
if (lhs_begin == lhs_end) {
// Left has no more elements. Right is greater.
return true;
}
// Right has no more elements. Left is greater.
ABSL_ASSERT(rhs_begin == rhs_end);
return false;
}
const absl::StatusOr<std::string> Attribute::AsString() const {
if (variable_name().empty()) {
return absl::InvalidArgumentError(
"Only ident rooted attributes are supported.");
}
std::string result = std::string(variable_name());
for (const auto& qualifier : qualifier_path()) {
CEL_RETURN_IF_ERROR(absl::visit(
AttributeStringPrinter(&result, qualifier.kind()), qualifier.value_));
}
return result;
}
bool AttributeQualifier::IsMatch(const AttributeQualifier& other) const {
if (absl::holds_alternative<Kind>(value_) ||
absl::holds_alternative<Kind>(other.value_)) {
return false;
}
return value_ == other.value_;
}
absl::StatusOr<std::string> AttributeQualifier::AsString() const {
std::string result;
CEL_RETURN_IF_ERROR(
absl::visit(AttributeQualifierStringPrinter(&result, kind()), value_));
return result;
}
} // namespace cel
================================================
FILE: base/attribute.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_ATTRIBUTE_H_
#define THIRD_PARTY_CEL_CPP_BASE_ATTRIBUTE_H_
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "absl/types/span.h"
#include "absl/types/variant.h"
#include "base/kind.h"
namespace cel {
// AttributeQualifier represents a segment in
// attribute resolutuion path. A segment can be qualified by values of
// following types: string/int64_t/uint64_t/bool.
class AttributeQualifier final {
private:
struct ComparatorVisitor;
using Variant = absl::variant<Kind, int64_t, uint64_t, std::string, bool>;
public:
static AttributeQualifier OfInt(int64_t value) {
return AttributeQualifier(absl::in_place_type<int64_t>, std::move(value));
}
static AttributeQualifier OfUint(uint64_t value) {
return AttributeQualifier(absl::in_place_type<uint64_t>, std::move(value));
}
static AttributeQualifier OfString(std::string value) {
return AttributeQualifier(absl::in_place_type<std::string>,
std::move(value));
}
static AttributeQualifier OfBool(bool value) {
return AttributeQualifier(absl::in_place_type<bool>, std::move(value));
}
AttributeQualifier() = default;
AttributeQualifier(const AttributeQualifier&) = default;
AttributeQualifier(AttributeQualifier&&) = default;
AttributeQualifier& operator=(const AttributeQualifier&) = default;
AttributeQualifier& operator=(AttributeQualifier&&) = default;
Kind kind() const;
// Family of Get... methods. Return values if requested type matches the
// stored one.
absl::optional<int64_t> GetInt64Key() const {
return absl::holds_alternative<int64_t>(value_)
? absl::optional<int64_t>(absl::get<1>(value_))
: absl::nullopt;
}
absl::optional<uint64_t> GetUint64Key() const {
return absl::holds_alternative<uint64_t>(value_)
? absl::optional<uint64_t>(absl::get<2>(value_))
: absl::nullopt;
}
absl::optional<absl::string_view> GetStringKey() const {
return absl::holds_alternative<std::string>(value_)
? absl::optional<absl::string_view>(absl::get<3>(value_))
: absl::nullopt;
}
absl::optional<bool> GetBoolKey() const {
return absl::holds_alternative<bool>(value_)
? absl::optional<bool>(absl::get<4>(value_))
: absl::nullopt;
}
bool operator==(const AttributeQualifier& other) const {
return IsMatch(other);
}
bool operator<(const AttributeQualifier& other) const;
bool IsMatch(absl::string_view other_key) const {
absl::optional<absl::string_view> key = GetStringKey();
return (key.has_value() && key.value() == other_key);
}
absl::StatusOr<std::string> AsString() const;
private:
friend class Attribute;
friend struct ComparatorVisitor;
template <typename T>
AttributeQualifier(absl::in_place_type_t<T> in_place_type, T&& value)
: value_(in_place_type, std::forward<T>(value)) {}
bool IsMatch(const AttributeQualifier& other) const;
// The previous implementation of Attribute preserved all value
// instances, regardless of whether they are supported in this context or not.
// We represented unsupported types by using the first alternative and thus
// preserve backwards compatibility with the result of `type()` above.
Variant value_;
};
// AttributeQualifierPattern matches a segment in
// attribute resolutuion path. AttributeQualifierPattern is capable of
// matching path elements of types string/int64/uint64/bool.
class AttributeQualifierPattern final {
private:
// Qualifier value. If not set, treated as wildcard.
std::optional<AttributeQualifier> value_;
explicit AttributeQualifierPattern(std::optional<AttributeQualifier> value)
: value_(std::move(value)) {}
public:
static AttributeQualifierPattern OfInt(int64_t value) {
return AttributeQualifierPattern(AttributeQualifier::OfInt(value));
}
static AttributeQualifierPattern OfUint(uint64_t value) {
return AttributeQualifierPattern(AttributeQualifier::OfUint(value));
}
static AttributeQualifierPattern OfString(std::string value) {
return AttributeQualifierPattern(
AttributeQualifier::OfString(std::move(value)));
}
static AttributeQualifierPattern OfBool(bool value) {
return AttributeQualifierPattern(AttributeQualifier::OfBool(value));
}
static AttributeQualifierPattern CreateWildcard() {
return AttributeQualifierPattern(std::nullopt);
}
explicit AttributeQualifierPattern(AttributeQualifier qualifier)
: AttributeQualifierPattern(
std::optional<AttributeQualifier>(std::move(qualifier))) {}
bool IsWildcard() const { return !value_.has_value(); }
bool IsMatch(const AttributeQualifier& qualifier) const {
if (IsWildcard()) return true;
return value_.value() == qualifier;
}
bool IsMatch(absl::string_view other_key) const {
if (!value_.has_value()) return true;
return value_->IsMatch(other_key);
}
};
// Attribute represents resolved attribute path.
class Attribute final {
public:
explicit Attribute(std::string variable_name)
: Attribute(std::move(variable_name), {}) {}
Attribute(std::string variable_name,
std::vector<AttributeQualifier> qualifier_path)
: impl_(std::make_shared<Impl>(std::move(variable_name),
std::move(qualifier_path))) {}
absl::string_view variable_name() const { return impl_->variable_name; }
bool has_variable_name() const { return !impl_->variable_name.empty(); }
absl::Span<const AttributeQualifier> qualifier_path() const {
return impl_->qualifier_path;
}
bool operator==(const Attribute& other) const;
bool operator<(const Attribute& other) const;
const absl::StatusOr<std::string> AsString() const;
private:
struct Impl final {
Impl(std::string variable_name,
std::vector<AttributeQualifier> qualifier_path)
: variable_name(std::move(variable_name)),
qualifier_path(std::move(qualifier_path)) {}
std::string variable_name;
std::vector<AttributeQualifier> qualifier_path;
};
std::shared_ptr<const Impl> impl_;
};
// AttributePattern is a fully-qualified absolute attribute path pattern.
// Supported segments steps in the path are:
// - field selection;
// - map lookup by key;
// - list access by index.
class AttributePattern final {
public:
// MatchType enum specifies how closely pattern is matching the attribute:
enum class MatchType {
NONE, // Pattern does not match attribute itself nor its children
PARTIAL, // Pattern matches an entity nested within attribute;
FULL // Pattern matches an attribute itself.
};
AttributePattern(std::string variable,
std::vector<AttributeQualifierPattern> qualifier_path)
: variable_(std::move(variable)),
qualifier_path_(std::move(qualifier_path)) {}
absl::string_view variable() const { return variable_; }
absl::Span<const AttributeQualifierPattern> qualifier_path() const {
return qualifier_path_;
}
// Matches the pattern to an attribute.
// Distinguishes between no-match, partial match and full match cases.
MatchType IsMatch(const Attribute& attribute) const {
MatchType result = MatchType::NONE;
if (attribute.variable_name() != variable_) {
return result;
}
auto max_index = qualifier_path().size();
result = MatchType::FULL;
if (qualifier_path().size() > attribute.qualifier_path().size()) {
max_index = attribute.qualifier_path().size();
result = MatchType::PARTIAL;
}
for (size_t i = 0; i < max_index; i++) {
if (!(qualifier_path()[i].IsMatch(attribute.qualifier_path()[i]))) {
return MatchType::NONE;
}
}
return result;
}
private:
std::string variable_;
std::vector<AttributeQualifierPattern> qualifier_path_;
};
struct FieldSpecifier {
int64_t number;
std::string name;
};
using SelectQualifier = absl::variant<FieldSpecifier, AttributeQualifier>;
} // namespace cel
#endif // THIRD_PARTY_CEL_CPP_BASE_ATTRIBUTE_H_
================================================
FILE: base/attribute_set.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_ATTRIBUTE_SET_H_
#define THIRD_PARTY_CEL_CPP_BASE_ATTRIBUTE_SET_H_
#include "absl/container/btree_set.h"
#include "absl/types/span.h"
#include "base/attribute.h"
namespace google::api::expr::runtime {
class AttributeUtility;
} // namespace google::api::expr::runtime
namespace cel {
class UnknownValue;
namespace base_internal {
class UnknownSet;
}
// AttributeSet is a container for CEL attributes that are identified as
// unknown during expression evaluation.
class AttributeSet final {
private:
using Container = absl::btree_set<Attribute>;
public:
using value_type = typename Container::value_type;
using size_type = typename Container::size_type;
using iterator = typename Container::const_iterator;
using const_iterator = typename Container::const_iterator;
AttributeSet() = default;
AttributeSet(const AttributeSet&) = default;
AttributeSet(AttributeSet&&) = default;
AttributeSet& operator=(const AttributeSet&) = default;
AttributeSet& operator=(AttributeSet&&) = default;
explicit AttributeSet(absl::Span<const Attribute> attributes) {
for (const auto& attr : attributes) {
Add(attr);
}
}
AttributeSet(const AttributeSet& set1, const AttributeSet& set2)
: attributes_(set1.attributes_) {
for (const auto& attr : set2.attributes_) {
Add(attr);
}
}
iterator begin() const { return attributes_.begin(); }
const_iterator cbegin() const { return attributes_.cbegin(); }
iterator end() const { return attributes_.end(); }
const_iterator cend() const { return attributes_.cend(); }
size_type size() const { return attributes_.size(); }
bool empty() const { return attributes_.empty(); }
bool operator==(const AttributeSet& other) const {
return this == &other || attributes_ == other.attributes_;
}
bool operator!=(const AttributeSet& other) const {
return !operator==(other);
}
static AttributeSet Merge(const AttributeSet& set1,
const AttributeSet& set2) {
return AttributeSet(set1, set2);
}
private:
friend class google::api::expr::runtime::AttributeUtility;
friend class UnknownValue;
friend class base_internal::UnknownSet;
void Add(const Attribute& attribute) { attributes_.insert(attribute); }
void Add(const AttributeSet& other) {
for (const auto& attribute : other) {
Add(attribute);
}
}
// Attribute container.
Container attributes_;
};
} // namespace cel
#endif // THIRD_PARTY_CEL_CPP_BASE_ATTRIBUTE_SET_H_
================================================
FILE: base/builtins.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_BUILTINS_H_
#define THIRD_PARTY_CEL_CPP_BASE_BUILTINS_H_
namespace cel {
// Constants specifying names for CEL builtins.
//
// Prefer to use the constants in `common/standard_definitions.h`.
namespace builtin {
// Comparison
constexpr char kEqual[] = "_==_";
constexpr char kInequal[] = "_!=_";
constexpr char kLess[] = "_<_";
constexpr char kLessOrEqual[] = "_<=_";
constexpr char kGreater[] = "_>_";
constexpr char kGreaterOrEqual[] = "_>=_";
// Logical
constexpr char kAnd[] = "_&&_";
constexpr char kOr[] = "_||_";
constexpr char kNot[] = "!_";
// Strictness
constexpr char kNotStrictlyFalse[] = "@not_strictly_false";
// Deprecated '__not_strictly_false__' function. Preserved for backwards
// compatibility with stored expressions.
constexpr char kNotStrictlyFalseDeprecated[] = "__not_strictly_false__";
// Arithmetical
constexpr char kAdd[] = "_+_";
constexpr char kSubtract[] = "_-_";
constexpr char kNeg[] = "-_";
constexpr char kMultiply[] = "_*_";
constexpr char kDivide[] = "_/_";
constexpr char kModulo[] = "_%_";
// String operations
constexpr char kRegexMatch[] = "matches";
constexpr char kStringContains[] = "contains";
constexpr char kStringEndsWith[] = "endsWith";
constexpr char kStringStartsWith[] = "startsWith";
// Container operations
constexpr char kIn[] = "@in";
// Deprecated '_in_' operator. Preserved for backwards compatibility with stored
// expressions.
constexpr char kInDeprecated[] = "_in_";
// Deprecated 'in()' function. Preserved for backwards compatibility with stored
// expressions.
constexpr char kInFunction[] = "in";
constexpr char kIndex[] = "_[_]";
constexpr char kSize[] = "size";
constexpr char kTernary[] = "_?_:_";
// Timestamp and Duration
constexpr char kDuration[] = "duration";
constexpr char kTimestamp[] = "timestamp";
constexpr char kFullYear[] = "getFullYear";
constexpr char kMonth[] = "getMonth";
constexpr char kDayOfYear[] = "getDayOfYear";
constexpr char kDayOfMonth[] = "getDayOfMonth";
constexpr char kDate[] = "getDate";
constexpr char kDayOfWeek[] = "getDayOfWeek";
constexpr char kHours[] = "getHours";
constexpr char kMinutes[] = "getMinutes";
constexpr char kSeconds[] = "getSeconds";
constexpr char kMilliseconds[] = "getMilliseconds";
// Type conversions
constexpr char kBool[] = "bool";
constexpr char kBytes[] = "bytes";
constexpr char kDouble[] = "double";
constexpr char kDyn[] = "dyn";
constexpr char kInt[] = "int";
constexpr char kString[] = "string";
constexpr char kType[] = "type";
constexpr char kUint[] = "uint";
// Runtime-only functions.
// The convention for runtime-only functions where only the runtime needs to
// differentiate behavior is to prefix the function with `#`.
// Note, this is a different convention from CEL internal functions where the
// whole stack needs to be aware of the function id.
constexpr char kRuntimeListAppend[] = "#list_append";
} // namespace builtin
} // namespace cel
#endif // THIRD_PARTY_CEL_CPP_BASE_BUILTINS_H_
================================================
FILE: base/function.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_FUNCTION_H_
#define THIRD_PARTY_CEL_CPP_BASE_FUNCTION_H_
#include "runtime/function.h" // IWYU pragma: export
#endif // THIRD_PARTY_CEL_CPP_BASE_FUNCTION_H_
================================================
FILE: base/function_adapter.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_FUNCTION_ADAPTER_H_
#define THIRD_PARTY_CEL_CPP_BASE_FUNCTION_ADAPTER_H_
#include "runtime/function_adapter.h" // IWYU pragma: export
#endif // THIRD_PARTY_CEL_CPP_BASE_FUNCTION_ADAPTER_H_
================================================
FILE: base/function_descriptor.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_FUNCTION_DESCRIPTOR_H_
#define THIRD_PARTY_CEL_CPP_BASE_FUNCTION_DESCRIPTOR_H_
#include "common/function_descriptor.h" // IWYU pragma: export
#endif // THIRD_PARTY_CEL_CPP_BASE_FUNCTION_DESCRIPTOR_H_
================================================
FILE: base/function_result.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_FUNCTION_RESULT_H_
#define THIRD_PARTY_CEL_CPP_BASE_FUNCTION_RESULT_H_
#include <cstdint>
#include <utility>
#include "base/function_descriptor.h"
namespace cel {
// Represents a function result that is unknown at the time of execution. This
// allows for lazy evaluation of expensive functions.
class FunctionResult final {
public:
FunctionResult() = delete;
FunctionResult(const FunctionResult&) = default;
FunctionResult(FunctionResult&&) = default;
FunctionResult& operator=(const FunctionResult&) = default;
FunctionResult& operator=(FunctionResult&&) = default;
FunctionResult(FunctionDescriptor descriptor, int64_t expr_id)
: descriptor_(std::move(descriptor)), expr_id_(expr_id) {}
// The descriptor of the called function that return Unknown.
const FunctionDescriptor& descriptor() const { return descriptor_; }
// The id of the |Expr| that triggered the function call step. Provided
// informationally -- if two different |Expr|s generate the same unknown call,
// they will be treated as the same unknown function result.
int64_t call_expr_id() const { return expr_id_; }
// Equality operator provided for testing. Compatible with set less-than
// comparator.
// Compares descriptor then arguments elementwise.
bool IsEqualTo(const FunctionResult& other) const {
return descriptor() == other.descriptor();
}
// TODO(uncreated-issue/5): re-implement argument capture
private:
FunctionDescriptor descriptor_;
int64_t expr_id_;
};
inline bool operator==(const FunctionResult& lhs, const FunctionResult& rhs) {
return lhs.IsEqualTo(rhs);
}
inline bool operator<(const FunctionResult& lhs, const FunctionResult& rhs) {
return lhs.descriptor() < rhs.descriptor();
}
} // namespace cel
#endif // THIRD_PARTY_CEL_CPP_BASE_FUNCTION_RESULT_H_
================================================
FILE: base/function_result_set.cc
================================================
// 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.
#include "base/function_result_set.h"
namespace cel {
// Implementation for merge constructor.
FunctionResultSet::FunctionResultSet(const FunctionResultSet& lhs,
const FunctionResultSet& rhs)
: function_results_(lhs.function_results_) {
for (const auto& function_result : rhs) {
function_results_.insert(function_result);
}
}
} // namespace cel
================================================
FILE: base/function_result_set.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_FUNCTION_RESULT_SET_H_
#define THIRD_PARTY_CEL_CPP_BASE_FUNCTION_RESULT_SET_H_
#include <initializer_list>
#include <utility>
#include "absl/container/btree_set.h"
#include "base/function_result.h"
namespace google::api::expr::runtime {
class AttributeUtility;
} // namespace google::api::expr::runtime
namespace cel {
class UnknownValue;
namespace base_internal {
class UnknownSet;
}
// Represents a collection of unknown function results at a particular point in
// execution. Execution should advance further if this set of unknowns are
// provided. It may not advance if only a subset are provided.
// Set semantics use |IsEqualTo()| defined on |FunctionResult|.
class FunctionResultSet final {
private:
using Container = absl::btree_set<FunctionResult>;
public:
using value_type = typename Container::value_type;
using size_type = typename Container::size_type;
using iterator = typename Container::const_iterator;
using const_iterator = typename Container::const_iterator;
FunctionResultSet() = default;
FunctionResultSet(const FunctionResultSet&) = default;
FunctionResultSet(FunctionResultSet&&) = default;
FunctionResultSet& operator=(const FunctionResultSet&) = default;
FunctionResultSet& operator=(FunctionResultSet&&) = default;
// Merge constructor -- effectively union(lhs, rhs).
FunctionResultSet(const FunctionResultSet& lhs, const FunctionResultSet& rhs);
// Initialize with a single FunctionResult.
explicit FunctionResultSet(FunctionResult initial)
: function_results_{std::move(initial)} {}
FunctionResultSet(std::initializer_list<FunctionResult> il)
: function_results_(il) {}
iterator begin() const { return function_results_.begin(); }
const_iterator cbegin() const { return function_results_.cbegin(); }
iterator end() const { return function_results_.end(); }
const_iterator cend() const { return function_results_.cend(); }
size_type size() const { return function_results_.size(); }
bool empty() const { return function_results_.empty(); }
bool operator==(const FunctionResultSet& other) const {
return this == &other || function_results_ == other.function_results_;
}
bool operator!=(const FunctionResultSet& other) const {
return !operator==(other);
}
private:
friend class google::api::expr::runtime::AttributeUtility;
friend class UnknownValue;
friend class base_internal::UnknownSet;
void Add(const FunctionResult& function_result) {
function_results_.insert(function_result);
}
void Add(const FunctionResultSet& other) {
for (const auto& function_result : other) {
Add(function_result);
}
}
Container function_results_;
};
} // namespace cel
#endif // THIRD_PARTY_CEL_CPP_BASE_FUNCTION_RESULT_SET_H_
================================================
FILE: base/internal/BUILD
================================================
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
load("@rules_cc//cc:cc_library.bzl", "cc_library")
package(default_visibility = ["//visibility:public"])
licenses(["notice"])
cc_library(
name = "memory_manager_testing",
testonly = True,
srcs = ["memory_manager_testing.cc"],
hdrs = ["memory_manager_testing.h"],
deps = [
"//internal:testing",
],
)
cc_library(
name = "message_wrapper",
hdrs = ["message_wrapper.h"],
)
cc_library(
name = "operators",
hdrs = ["operators.h"],
deps = [
"@com_google_absl//absl/strings",
],
)
cc_library(
name = "unknown_set",
srcs = ["unknown_set.cc"],
hdrs = ["unknown_set.h"],
deps = [
"//base:attributes",
"//base:function_result_set",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/base:no_destructor",
],
)
================================================
FILE: base/internal/memory_manager_testing.cc
================================================
// 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.
#include "base/internal/memory_manager_testing.h"
#include <string>
namespace cel::base_internal {
std::string MemoryManagerTestModeToString(MemoryManagerTestMode mode) {
switch (mode) {
case MemoryManagerTestMode::kGlobal:
return "Global";
case MemoryManagerTestMode::kArena:
return "Arena";
}
}
} // namespace cel::base_internal
================================================
FILE: base/internal/memory_manager_testing.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_INTERNAL_MEMORY_MANAGER_TESTING_H_
#define THIRD_PARTY_CEL_CPP_BASE_INTERNAL_MEMORY_MANAGER_TESTING_H_
#include <string>
#include <utility>
#include "internal/testing.h"
namespace cel::base_internal {
enum class MemoryManagerTestMode {
kGlobal = 0,
kArena,
};
std::string MemoryManagerTestModeToString(MemoryManagerTestMode mode);
template <typename S>
void AbslStringify(S& sink, MemoryManagerTestMode mode) {
sink.Append(MemoryManagerTestModeToString(mode));
}
inline auto MemoryManagerTestModeAll() {
return testing::Values(MemoryManagerTestMode::kGlobal,
MemoryManagerTestMode::kArena);
}
inline std::string MemoryManagerTestModeName(
const testing::TestParamInfo<MemoryManagerTestMode>& info) {
return MemoryManagerTestModeToString(info.param);
}
inline std::string MemoryManagerTestModeTupleName(
const testing::TestParamInfo<std::tuple<MemoryManagerTestMode>>& info) {
return MemoryManagerTestModeToString(std::get<0>(info.param));
}
} // namespace cel::base_internal
#endif // THIRD_PARTY_CEL_CPP_BASE_INTERNAL_MEMORY_MANAGER_TESTING_H_
================================================
FILE: base/internal/message_wrapper.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_INTERNAL_MESSAGE_WRAPPER_H_
#define THIRD_PARTY_CEL_CPP_BASE_INTERNAL_MESSAGE_WRAPPER_H_
#include <cstdint>
namespace cel::base_internal {
inline constexpr uintptr_t kMessageWrapperTagMask = 0b1;
inline constexpr uintptr_t kMessageWrapperPtrMask = ~kMessageWrapperTagMask;
inline constexpr int kMessageWrapperTagSize = 1;
inline constexpr uintptr_t kMessageWrapperTagTypeInfoValue = 0b0;
inline constexpr uintptr_t kMessageWrapperTagMessageValue = 0b1;
} // namespace cel::base_internal
#endif // THIRD_PARTY_CEL_CPP_BASE_INTERNAL_MESSAGE_WRAPPER_H_
================================================
FILE: base/internal/operators.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_INTERNAL_OPERATORS_H_
#define THIRD_PARTY_CEL_CPP_BASE_INTERNAL_OPERATORS_H_
#include "absl/strings/string_view.h"
namespace cel {
enum class OperatorId;
namespace base_internal {
struct OperatorData final {
OperatorData() = delete;
OperatorData(const OperatorData&) = delete;
OperatorData(OperatorData&&) = delete;
OperatorData& operator=(const OperatorData&) = delete;
OperatorData& operator=(OperatorData&&) = delete;
constexpr OperatorData(cel::OperatorId id, absl::string_view name,
absl::string_view display_name, int precedence,
int arity)
: id(id),
name(name),
display_name(display_name),
precedence(precedence),
arity(arity) {}
const cel::OperatorId id;
const absl::string_view name;
const absl::string_view display_name;
const int precedence;
const int arity;
};
#define CEL_INTERNAL_UNARY_OPERATORS_ENUM(XX) \
XX(LogicalNot, "!", "!_", 2, 1) \
XX(Negate, "-", "-_", 2, 1) \
XX(NotStrictlyFalse, "", "@not_strictly_false", 0, 1) \
XX(OldNotStrictlyFalse, "", "__not_strictly_false__", 0, 1)
#define CEL_INTERNAL_BINARY_OPERATORS_ENUM(XX) \
XX(Equals, "==", "_==_", 5, 2) \
XX(NotEquals, "!=", "_!=_", 5, 2) \
XX(Less, "<", "_<_", 5, 2) \
XX(LessEquals, "<=", "_<=_", 5, 2) \
XX(Greater, ">", "_>_", 5, 2) \
XX(GreaterEquals, ">=", "_>=_", 5, 2) \
XX(In, "in", "@in", 5, 2) \
XX(OldIn, "in", "_in_", 5, 2) \
XX(Index, "", "_[_]", 1, 2) \
XX(LogicalOr, "||", "_||_", 7, 2) \
XX(LogicalAnd, "&&", "_&&_", 6, 2) \
XX(Add, "+", "_+_", 4, 2) \
XX(Subtract, "-", "_-_", 4, 2) \
XX(Multiply, "*", "_*_", 3, 2) \
XX(Divide, "/", "_/_", 3, 2) \
XX(Modulo, "%", "_%_", 3, 2)
#define CEL_INTERNAL_TERNARY_OPERATORS_ENUM(XX) \
XX(Conditional, "", "_?_:_", 8, 3)
// Macro definining all the operators and their properties.
// (1) - The identifier.
// (2) - The display name if applicable, otherwise an empty string.
// (3) - The name.
// (4) - The precedence if applicable, otherwise 0.
// (5) - The arity.
#define CEL_INTERNAL_OPERATORS_ENUM(XX) \
CEL_INTERNAL_TERNARY_OPERATORS_ENUM(XX) \
CEL_INTERNAL_BINARY_OPERATORS_ENUM(XX) \
CEL_INTERNAL_UNARY_OPERATORS_ENUM(XX)
} // namespace base_internal
} // namespace cel
#endif // THIRD_PARTY_CEL_CPP_BASE_INTERNAL_OPERATORS_H_
================================================
FILE: base/internal/unknown_set.cc
================================================
// 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.
#include "base/internal/unknown_set.h"
#include "absl/base/no_destructor.h"
namespace cel::base_internal {
const AttributeSet& EmptyAttributeSet() {
static const absl::NoDestructor<AttributeSet> empty_attribute_set;
return *empty_attribute_set;
}
const FunctionResultSet& EmptyFunctionResultSet() {
static const absl::NoDestructor<FunctionResultSet> empty_function_result_set;
return *empty_function_result_set;
}
} // namespace cel::base_internal
================================================
FILE: base/internal/unknown_set.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_INTERNAL_UNKNOWN_SET_H_
#define THIRD_PARTY_CEL_CPP_BASE_INTERNAL_UNKNOWN_SET_H_
#include <memory>
#include <utility>
#include "absl/base/attributes.h"
#include "base/attribute_set.h"
#include "base/function_result_set.h"
namespace cel::base_internal {
// For compatibility with the old API and to avoid unnecessary copying when
// converting between the old and new representations, we store the historical
// members of google::api::expr::runtime::UnknownSet in this struct for use with
// std::shared_ptr.
struct UnknownSetRep final {
UnknownSetRep() = default;
UnknownSetRep(AttributeSet attributes, FunctionResultSet function_results)
: attributes(std::move(attributes)),
function_results(std::move(function_results)) {}
explicit UnknownSetRep(AttributeSet attributes)
: attributes(std::move(attributes)) {}
explicit UnknownSetRep(FunctionResultSet function_results)
: function_results(std::move(function_results)) {}
AttributeSet attributes;
FunctionResultSet function_results;
};
const AttributeSet& EmptyAttributeSet();
const FunctionResultSet& EmptyFunctionResultSet();
struct UnknownSetAccess;
class UnknownSet final {
private:
using Rep = UnknownSetRep;
public:
// Construct the empty set.
// Uses singletons instead of allocating new containers.
UnknownSet() = default;
UnknownSet(const UnknownSet&) = default;
UnknownSet(UnknownSet&&) = default;
UnknownSet& operator=(const UnknownSet&) = default;
UnknownSet& operator=(UnknownSet&&) = default;
// Initialization specifying subcontainers
explicit UnknownSet(AttributeSet attributes)
: rep_(std::make_shared<Rep>(std::move(attributes))) {}
explicit UnknownSet(FunctionResultSet function_results)
: rep_(std::make_shared<Rep>(std::move(function_results))) {}
UnknownSet(AttributeSet attributes, FunctionResultSet function_results)
: rep_(std::make_shared<Rep>(std::move(attributes),
std::move(function_results))) {}
// Merge constructor
UnknownSet(const UnknownSet& set1, const UnknownSet& set2)
: UnknownSet(
AttributeSet(set1.unknown_attributes(), set2.unknown_attributes()),
FunctionResultSet(set1.unknown_function_results(),
set2.unknown_function_results())) {}
const AttributeSet& unknown_attributes() const {
return rep_ != nullptr ? rep_->attributes : EmptyAttributeSet();
}
const FunctionResultSet& unknown_function_results() const {
return rep_ != nullptr ? rep_->function_results : EmptyFunctionResultSet();
}
bool operator==(const UnknownSet& other) const {
return this == &other ||
(unknown_attributes() == other.unknown_attributes() &&
unknown_function_results() == other.unknown_function_results());
}
bool operator!=(const UnknownSet& other) const { return !operator==(other); }
private:
friend struct UnknownSetAccess;
explicit UnknownSet(std::shared_ptr<Rep> impl) : rep_(std::move(impl)) {}
void Add(const UnknownSet& other) {
if (rep_ == nullptr) {
rep_ = std::make_shared<Rep>();
}
rep_->attributes.Add(other.unknown_attributes());
rep_->function_results.Add(other.unknown_function_results());
}
std::shared_ptr<Rep> rep_;
};
struct UnknownSetAccess final {
static UnknownSet Construct(std::shared_ptr<UnknownSetRep> rep) {
return UnknownSet(std::move(rep));
}
static void Add(UnknownSet& dest, const UnknownSet& src) { dest.Add(src); }
static const std::shared_ptr<UnknownSetRep>& Rep(const UnknownSet& value) {
return value.rep_;
}
};
} // namespace cel::base_internal
#endif // THIRD_PARTY_CEL_CPP_BASE_INTERNAL_UNKNOWN_SET_H_
================================================
FILE: base/kind.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_KIND_H_
#define THIRD_PARTY_CEL_CPP_BASE_KIND_H_
// This header exists for compatibility and should be removed once all includes
// have been updated.
#include "common/kind.h" // IWYU pragma: export
#include "common/type_kind.h" // IWYU pragma: export
#include "common/value_kind.h" // IWYU pragma: export
#endif // THIRD_PARTY_CEL_CPP_BASE_KIND_H_
================================================
FILE: base/operators.cc
================================================
// 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.
#include "base/operators.h"
#include <algorithm>
#include <array>
#include "absl/base/attributes.h"
#include "absl/base/call_once.h"
#include "absl/log/absl_check.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "base/internal/operators.h"
namespace cel {
namespace {
using base_internal::OperatorData;
struct OperatorDataNameComparer {
using is_transparent = void;
bool operator()(const OperatorData* lhs, const OperatorData* rhs) const {
return lhs->name < rhs->name;
}
bool operator()(const OperatorData* lhs, absl::string_view rhs) const {
return lhs->name < rhs;
}
bool operator()(absl::string_view lhs, const OperatorData* rhs) const {
return lhs < rhs->name;
}
};
struct OperatorDataDisplayNameComparer {
using is_transparent = void;
bool operator()(const OperatorData* lhs, const OperatorData* rhs) const {
return lhs->display_name < rhs->display_name;
}
bool operator()(const OperatorData* lhs, absl::string_view rhs) const {
return lhs->display_name < rhs;
}
bool operator()(absl::string_view lhs, const OperatorData* rhs) const {
return lhs < rhs->display_name;
}
};
#define CEL_OPERATORS_DATA(id, symbol, name, precedence, arity) \
ABSL_CONST_INIT const OperatorData id##_storage = { \
OperatorId::k##id, name, symbol, precedence, arity};
CEL_INTERNAL_OPERATORS_ENUM(CEL_OPERATORS_DATA)
#undef CEL_OPERATORS_DATA
#define CEL_OPERATORS_COUNT(id, symbol, name, precedence, arity) +1
using OperatorsArray =
std::array<const OperatorData*,
0 + CEL_INTERNAL_OPERATORS_ENUM(CEL_OPERATORS_COUNT)>;
using UnaryOperatorsArray =
std::array<const OperatorData*,
0 + CEL_INTERNAL_UNARY_OPERATORS_ENUM(CEL_OPERATORS_COUNT)>;
using BinaryOperatorsArray =
std::array<const OperatorData*,
0 + CEL_INTERNAL_BINARY_OPERATORS_ENUM(CEL_OPERATORS_COUNT)>;
using TernaryOperatorsArray =
std::array<const OperatorData*,
0 + CEL_INTERNAL_TERNARY_OPERATORS_ENUM(CEL_OPERATORS_COUNT)>;
#undef CEL_OPERATORS_COUNT
ABSL_CONST_INIT absl::once_flag operators_once_flag;
#define CEL_OPERATORS_DO(id, symbol, name, precedence, arity) &id##_storage,
OperatorsArray operators_by_name = {
CEL_INTERNAL_OPERATORS_ENUM(CEL_OPERATORS_DO)};
OperatorsArray operators_by_display_name = {
CEL_INTERNAL_OPERATORS_ENUM(CEL_OPERATORS_DO)};
UnaryOperatorsArray unary_operators_by_name = {
CEL_INTERNAL_UNARY_OPERATORS_ENUM(CEL_OPERATORS_DO)};
UnaryOperatorsArray unary_operators_by_display_name = {
CEL_INTERNAL_UNARY_OPERATORS_ENUM(CEL_OPERATORS_DO)};
BinaryOperatorsArray binary_operators_by_name = {
CEL_INTERNAL_BINARY_OPERATORS_ENUM(CEL_OPERATORS_DO)};
BinaryOperatorsArray binary_operators_by_display_name = {
CEL_INTERNAL_BINARY_OPERATORS_ENUM(CEL_OPERATORS_DO)};
TernaryOperatorsArray ternary_operators_by_name = {
CEL_INTERNAL_TERNARY_OPERATORS_ENUM(CEL_OPERATORS_DO)};
TernaryOperatorsArray ternary_operators_by_display_name = {
CEL_INTERNAL_TERNARY_OPERATORS_ENUM(CEL_OPERATORS_DO)};
#undef CEL_OPERATORS_DO
void InitializeOperators() {
std::stable_sort(operators_by_name.begin(), operators_by_name.end(),
OperatorDataNameComparer{});
std::stable_sort(operators_by_display_name.begin(),
operators_by_display_name.end(),
OperatorDataDisplayNameComparer{});
std::stable_sort(unary_operators_by_name.begin(),
unary_operators_by_name.end(), OperatorDataNameComparer{});
std::stable_sort(unary_operators_by_display_name.begin(),
unary_operators_by_display_name.end(),
OperatorDataDisplayNameComparer{});
std::stable_sort(binary_operators_by_name.begin(),
binary_operators_by_name.end(), OperatorDataNameComparer{});
std::stable_sort(binary_operators_by_display_name.begin(),
binary_operators_by_display_name.end(),
OperatorDataDisplayNameComparer{});
std::stable_sort(ternary_operators_by_name.begin(),
ternary_operators_by_name.end(), OperatorDataNameComparer{});
std::stable_sort(ternary_operators_by_display_name.begin(),
ternary_operators_by_display_name.end(),
OperatorDataDisplayNameComparer{});
}
} // namespace
UnaryOperator::UnaryOperator(Operator op) : data_(op.data_) {
ABSL_CHECK(op.arity() == Arity::kUnary); // Crask OK
}
BinaryOperator::BinaryOperator(Operator op) : data_(op.data_) {
ABSL_CHECK(op.arity() == Arity::kBinary); // Crask OK
}
TernaryOperator::TernaryOperator(Operator op) : data_(op.data_) {
ABSL_CHECK(op.arity() == Arity::kTernary); // Crask OK
}
#define CEL_UNARY_OPERATOR(id, symbol, name, precedence, arity) \
UnaryOperator Operator::id() { return UnaryOperator(&id##_storage); }
CEL_INTERNAL_UNARY_OPERATORS_ENUM(CEL_UNARY_OPERATOR)
#undef CEL_UNARY_OPERATOR
#define CEL_BINARY_OPERATOR(id, symbol, name, precedence, arity) \
BinaryOperator Operator::id() { return BinaryOperator(&id##_storage); }
CEL_INTERNAL_BINARY_OPERATORS_ENUM(CEL_BINARY_OPERATOR)
#undef CEL_BINARY_OPERATOR
#define CEL_TERNARY_OPERATOR(id, symbol, name, precedence, arity) \
TernaryOperator Operator::id() { return TernaryOperator(&id##_storage); }
CEL_INTERNAL_TERNARY_OPERATORS_ENUM(CEL_TERNARY_OPERATOR)
#undef CEL_TERNARY_OPERATOR
absl::optional<Operator> Operator::FindByName(absl::string_view input) {
absl::call_once(operators_once_flag, InitializeOperators);
if (input.empty()) {
return absl::nullopt;
}
auto it =
std::lower_bound(operators_by_name.cbegin(), operators_by_name.cend(),
input, OperatorDataNameComparer{});
if (it == operators_by_name.cend() || (*it)->name != input) {
return absl::nullopt;
}
return Operator(*it);
}
absl::optional<Operator> Operator::FindByDisplayName(absl::string_view input) {
absl::call_once(operators_once_flag, InitializeOperators);
if (input.empty()) {
return absl::nullopt;
}
auto it = std::lower_bound(operators_by_display_name.cbegin(),
operators_by_display_name.cend(), input,
OperatorDataDisplayNameComparer{});
if (it == operators_by_name.cend() || (*it)->display_name != input) {
return absl::nullopt;
}
return Operator(*it);
}
absl::optional<UnaryOperator> UnaryOperator::FindByName(
absl::string_view input) {
absl::call_once(operators_once_flag, InitializeOperators);
if (input.empty()) {
return absl::nullopt;
}
auto it = std::lower_bound(unary_operators_by_name.cbegin(),
unary_operators_by_name.cend(), input,
OperatorDataNameComparer{});
if (it == unary_operators_by_name.cend() || (*it)->name != input) {
return absl::nullopt;
}
return UnaryOperator(*it);
}
absl::optional<UnaryOperator> UnaryOperator::FindByDisplayName(
absl::string_view input) {
absl::call_once(operators_once_flag, InitializeOperators);
if (input.empty()) {
return absl::nullopt;
}
auto it = std::lower_bound(unary_operators_by_display_name.cbegin(),
unary_operators_by_display_name.cend(), input,
OperatorDataDisplayNameComparer{});
if (it == unary_operators_by_display_name.cend() ||
(*it)->display_name != input) {
return absl::nullopt;
}
return UnaryOperator(*it);
}
absl::optional<BinaryOperator> BinaryOperator::FindByName(
absl::string_view input) {
absl::call_once(operators_once_flag, InitializeOperators);
if (input.empty()) {
return absl::nullopt;
}
auto it = std::lower_bound(binary_operators_by_name.cbegin(),
binary_operators_by_name.cend(), input,
OperatorDataNameComparer{});
if (it == binary_operators_by_name.cend() || (*it)->name != input) {
return absl::nullopt;
}
return BinaryOperator(*it);
}
absl::optional<BinaryOperator> BinaryOperator::FindByDisplayName(
absl::string_view input) {
absl::call_once(operators_once_flag, InitializeOperators);
if (input.empty()) {
return absl::nullopt;
}
auto it = std::lower_bound(binary_operators_by_display_name.cbegin(),
binary_operators_by_display_name.cend(), input,
OperatorDataDisplayNameComparer{});
if (it == binary_operators_by_display_name.cend() ||
(*it)->display_name != input) {
return absl::nullopt;
}
return BinaryOperator(*it);
}
absl::optional<TernaryOperator> TernaryOperator::FindByName(
absl::string_view input) {
absl::call_once(operators_once_flag, InitializeOperators);
if (input.empty()) {
return absl::nullopt;
}
auto it = std::lower_bound(ternary_operators_by_name.cbegin(),
ternary_operators_by_name.cend(), input,
OperatorDataNameComparer{});
if (it == ternary_operators_by_name.cend() || (*it)->name != input) {
return absl::nullopt;
}
return TernaryOperator(*it);
}
absl::optional<TernaryOperator> TernaryOperator::FindByDisplayName(
absl::string_view input) {
absl::call_once(operators_once_flag, InitializeOperators);
if (input.empty()) {
return absl::nullopt;
}
auto it = std::lower_bound(ternary_operators_by_display_name.cbegin(),
ternary_operators_by_display_name.cend(), input,
OperatorDataDisplayNameComparer{});
if (it == ternary_operators_by_display_name.cend() ||
(*it)->display_name != input) {
return absl::nullopt;
}
return TernaryOperator(*it);
}
} // namespace cel
================================================
FILE: base/operators.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_OPERATORS_H_
#define THIRD_PARTY_CEL_CPP_BASE_OPERATORS_H_
#include <utility>
#include "absl/base/attributes.h"
#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "base/internal/operators.h"
namespace cel {
enum class Arity {
kUnary = 1,
kBinary = 2,
kTernary = 3,
};
enum class OperatorId {
kConditional = 1,
kLogicalAnd,
kLogicalOr,
kLogicalNot,
kEquals,
kNotEquals,
kLess,
kLessEquals,
kGreater,
kGreaterEquals,
kAdd,
kSubtract,
kMultiply,
kDivide,
kModulo,
kNegate,
kIndex,
kIn,
kNotStrictlyFalse,
kOldIn,
kOldNotStrictlyFalse,
};
enum class UnaryOperatorId {
kLogicalNot = static_cast<int>(OperatorId::kLogicalNot),
kNegate = static_cast<int>(OperatorId::kNegate),
kNotStrictlyFalse = static_cast<int>(OperatorId::kNotStrictlyFalse),
kOldNotStrictlyFalse = static_cast<int>(OperatorId::kOldNotStrictlyFalse),
};
enum class BinaryOperatorId {
kLogicalAnd = static_cast<int>(OperatorId::kLogicalAnd),
kLogicalOr = static_cast<int>(OperatorId::kLogicalOr),
kEquals = static_cast<int>(OperatorId::kEquals),
kNotEquals = static_cast<int>(OperatorId::kNotEquals),
kLess = static_cast<int>(OperatorId::kLess),
kLessEquals = static_cast<int>(OperatorId::kLessEquals),
kGreater = static_cast<int>(OperatorId::kGreater),
kGreaterEquals = static_cast<int>(OperatorId::kGreaterEquals),
kAdd = static_cast<int>(OperatorId::kAdd),
kSubtract = static_cast<int>(OperatorId::kSubtract),
kMultiply = static_cast<int>(OperatorId::kMultiply),
kDivide = static_cast<int>(OperatorId::kDivide),
kModulo = static_cast<int>(OperatorId::kModulo),
kIndex = static_cast<int>(OperatorId::kIndex),
kIn = static_cast<int>(OperatorId::kIn),
kOldIn = static_cast<int>(OperatorId::kOldIn),
};
enum class TernaryOperatorId {
kConditional = static_cast<int>(OperatorId::kConditional),
};
class UnaryOperator;
class BinaryOperator;
class TernaryOperator;
class Operator final {
public:
ABSL_ATTRIBUTE_PURE_FUNCTION static TernaryOperator Conditional();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator LogicalAnd();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator LogicalOr();
ABSL_ATTRIBUTE_PURE_FUNCTION static UnaryOperator LogicalNot();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Equals();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator NotEquals();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Less();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator LessEquals();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Greater();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator GreaterEquals();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Add();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Subtract();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Multiply();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Divide();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Modulo();
ABSL_ATTRIBUTE_PURE_FUNCTION static UnaryOperator Negate();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Index();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator In();
ABSL_ATTRIBUTE_PURE_FUNCTION static UnaryOperator NotStrictlyFalse();
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator OldIn();
ABSL_ATTRIBUTE_PURE_FUNCTION static UnaryOperator OldNotStrictlyFalse();
ABSL_ATTRIBUTE_PURE_FUNCTION static absl::optional<Operator> FindByName(
absl::string_view input);
ABSL_ATTRIBUTE_PURE_FUNCTION static absl::optional<Operator>
FindByDisplayName(absl::string_view input);
Operator() = delete;
Operator(const Operator&) = default;
Operator(Operator&&) = default;
Operator& operator=(const Operator&) = default;
Operator& operator=(Operator&&) = default;
constexpr OperatorId id() const { return data_->id; }
// Returns the name of the operator. This is the managed representation of the
// operator, for example "_&&_".
constexpr absl::string_view name() const { return data_->name; }
// Returns the source text representation of the operator. This is the
// unmanaged text representation of the operator, for example "&&".
//
// Note that this will be empty for operators like Conditional() and Index().
constexpr absl::string_view display_name() const {
return data_->display_name;
}
constexpr int precedence() const { return data_->precedence; }
constexpr Arity arity() const { return static_cast<Arity>(data_->arity); }
private:
friend class UnaryOperator;
friend class BinaryOperator;
friend class TernaryOperator;
constexpr explicit Operator(const base_internal::OperatorData* data)
: data_(data) {}
const base_internal::OperatorData* data_;
};
constexpr bool operator==(const Operator& lhs, const Operator& rhs) {
return lhs.id() == rhs.id();
}
constexpr bool operator==(OperatorId lhs, const Operator& rhs) {
return lhs == rhs.id();
}
constexpr bool operator==(const Operator& lhs, OperatorId rhs) {
return operator==(rhs, lhs);
}
constexpr bool operator!=(const Operator& lhs, const Operator& rhs) {
return !operator==(lhs, rhs);
}
constexpr bool operator!=(OperatorId lhs, const Operator& rhs) {
return !operator==(lhs, rhs);
}
constexpr bool operator!=(const Operator& lhs, OperatorId rhs) {
return !operator==(lhs, rhs);
}
template <typename H>
H AbslHashValue(H state, const Operator& op) {
return H::combine(std::move(state), static_cast<int>(op.id()));
}
class UnaryOperator final {
public:
ABSL_ATTRIBUTE_PURE_FUNCTION static UnaryOperator LogicalNot() {
return Operator::LogicalNot();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static UnaryOperator Negate() {
return Operator::Negate();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static UnaryOperator NotStrictlyFalse() {
return Operator::NotStrictlyFalse();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static UnaryOperator OldNotStrictlyFalse() {
return Operator::OldNotStrictlyFalse();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static absl::optional<UnaryOperator> FindByName(
absl::string_view input);
ABSL_ATTRIBUTE_PURE_FUNCTION static absl::optional<UnaryOperator>
FindByDisplayName(absl::string_view input);
UnaryOperator() = delete;
UnaryOperator(const UnaryOperator&) = default;
UnaryOperator(UnaryOperator&&) = default;
UnaryOperator& operator=(const UnaryOperator&) = default;
UnaryOperator& operator=(UnaryOperator&&) = default;
// Support for explicit casting of Operator to UnaryOperator.
// `Operator::arity()` must return `Arity::kUnary`, or this will crash.
explicit UnaryOperator(Operator op);
constexpr UnaryOperatorId id() const {
return static_cast<UnaryOperatorId>(data_->id);
}
// Returns the name of the operator. This is the managed representation of the
// operator, for example "_&&_".
constexpr absl::string_view name() const { return data_->name; }
// Returns the source text representation of the operator. This is the
// unmanaged text representation of the operator, for example "&&".
//
// Note that this will be empty for operators like Conditional() and Index().
constexpr absl::string_view display_name() const {
return data_->display_name;
}
constexpr int precedence() const { return data_->precedence; }
constexpr Arity arity() const {
ABSL_ASSERT(data_->arity == 1);
return Arity::kUnary;
}
constexpr operator Operator() const { // NOLINT(google-explicit-constructor)
return Operator(data_);
}
private:
friend class Operator;
constexpr explicit UnaryOperator(const base_internal::OperatorData* data)
: data_(data) {}
const base_internal::OperatorData* data_;
};
constexpr bool operator==(const UnaryOperator& lhs, const UnaryOperator& rhs) {
return lhs.id() == rhs.id();
}
constexpr bool operator==(UnaryOperatorId lhs, const UnaryOperator& rhs) {
return lhs == rhs.id();
}
constexpr bool operator==(const UnaryOperator& lhs, UnaryOperatorId rhs) {
return operator==(rhs, lhs);
}
constexpr bool operator!=(const UnaryOperator& lhs, const UnaryOperator& rhs) {
return !operator==(lhs, rhs);
}
constexpr bool operator!=(UnaryOperatorId lhs, const UnaryOperator& rhs) {
return !operator==(lhs, rhs);
}
constexpr bool operator!=(const UnaryOperator& lhs, UnaryOperatorId rhs) {
return !operator==(lhs, rhs);
}
template <typename H>
H AbslHashValue(H state, const UnaryOperator& op) {
return H::combine(std::move(state), static_cast<int>(op.id()));
}
class BinaryOperator final {
public:
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator LogicalAnd() {
return Operator::LogicalAnd();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator LogicalOr() {
return Operator::LogicalOr();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Equals() {
return Operator::Equals();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator NotEquals() {
return Operator::NotEquals();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Less() {
return Operator::Less();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator LessEquals() {
return Operator::LessEquals();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Greater() {
return Operator::Greater();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator GreaterEquals() {
return Operator::GreaterEquals();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Add() {
return Operator::Add();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Subtract() {
return Operator::Subtract();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Multiply() {
return Operator::Multiply();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Divide() {
return Operator::Divide();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Modulo() {
return Operator::Modulo();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator Index() {
return Operator::Index();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator In() {
return Operator::In();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static BinaryOperator OldIn() {
return Operator::OldIn();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static absl::optional<BinaryOperator> FindByName(
absl::string_view input);
ABSL_ATTRIBUTE_PURE_FUNCTION static absl::optional<BinaryOperator>
FindByDisplayName(absl::string_view input);
BinaryOperator() = delete;
BinaryOperator(const BinaryOperator&) = default;
BinaryOperator(BinaryOperator&&) = default;
BinaryOperator& operator=(const BinaryOperator&) = default;
BinaryOperator& operator=(BinaryOperator&&) = default;
// Support for explicit casting of Operator to BinaryOperator.
// `Operator::arity()` must return `Arity::kBinary`, or this will crash.
explicit BinaryOperator(Operator op);
constexpr BinaryOperatorId id() const {
return static_cast<BinaryOperatorId>(data_->id);
}
// Returns the name of the operator. This is the managed representation of the
// operator, for example "_&&_".
constexpr absl::string_view name() const { return data_->name; }
// Returns the source text representation of the operator. This is the
// unmanaged text representation of the operator, for example "&&".
//
// Note that this will be empty for operators like Conditional() and Index().
constexpr absl::string_view display_name() const {
return data_->display_name;
}
constexpr int precedence() const { return data_->precedence; }
constexpr Arity arity() const {
ABSL_ASSERT(data_->arity == 2);
return Arity::kBinary;
}
constexpr operator Operator() const { // NOLINT(google-explicit-constructor)
return Operator(data_);
}
private:
friend class Operator;
constexpr explicit BinaryOperator(const base_internal::OperatorData* data)
: data_(data) {}
const base_internal::OperatorData* data_;
};
constexpr bool operator==(const BinaryOperator& lhs,
const BinaryOperator& rhs) {
return lhs.id() == rhs.id();
}
constexpr bool operator==(BinaryOperatorId lhs, const BinaryOperator& rhs) {
return lhs == rhs.id();
}
constexpr bool operator==(const BinaryOperator& lhs, BinaryOperatorId rhs) {
return operator==(rhs, lhs);
}
constexpr bool operator!=(const BinaryOperator& lhs,
const BinaryOperator& rhs) {
return !operator==(lhs, rhs);
}
constexpr bool operator!=(BinaryOperatorId lhs, const BinaryOperator& rhs) {
return !operator==(lhs, rhs);
}
constexpr bool operator!=(const BinaryOperator& lhs, BinaryOperatorId rhs) {
return !operator==(lhs, rhs);
}
template <typename H>
H AbslHashValue(H state, const BinaryOperator& op) {
return H::combine(std::move(state), static_cast<int>(op.id()));
}
class TernaryOperator final {
public:
ABSL_ATTRIBUTE_PURE_FUNCTION static TernaryOperator Conditional() {
return Operator::Conditional();
}
ABSL_ATTRIBUTE_PURE_FUNCTION static absl::optional<TernaryOperator>
FindByName(absl::string_view input);
ABSL_ATTRIBUTE_PURE_FUNCTION static absl::optional<TernaryOperator>
FindByDisplayName(absl::string_view input);
TernaryOperator() = delete;
TernaryOperator(const TernaryOperator&) = default;
TernaryOperator(TernaryOperator&&) = default;
TernaryOperator& operator=(const TernaryOperator&) = default;
TernaryOperator& operator=(TernaryOperator&&) = default;
// Support for explicit casting of Operator to TernaryOperator.
// `Operator::arity()` must return `Arity::kTernary`, or this will crash.
explicit TernaryOperator(Operator op);
constexpr TernaryOperatorId id() const {
return static_cast<TernaryOperatorId>(data_->id);
}
// Returns the name of the operator. This is the managed representation of the
// operator, for example "_&&_".
constexpr absl::string_view name() const { return data_->name; }
// Returns the source text representation of the operator. This is the
// unmanaged text representation of the operator, for example "&&".
//
// Note that this will be empty for operators like Conditional() and Index().
constexpr absl::string_view display_name() const {
return data_->display_name;
}
constexpr int precedence() const { return data_->precedence; }
constexpr Arity arity() const {
ABSL_ASSERT(data_->arity == 3);
return Arity::kTernary;
}
constexpr operator Operator() const { // NOLINT(google-explicit-constructor)
return Operator(data_);
}
private:
friend class Operator;
constexpr explicit TernaryOperator(const base_internal::OperatorData* data)
: data_(data) {}
const base_internal::OperatorData* data_;
};
constexpr bool operator==(const TernaryOperator& lhs,
const TernaryOperator& rhs) {
return lhs.id() == rhs.id();
}
constexpr bool operator==(TernaryOperatorId lhs, const TernaryOperator& rhs) {
return lhs == rhs.id();
}
constexpr bool operator==(const TernaryOperator& lhs, TernaryOperatorId rhs) {
return operator==(rhs, lhs);
}
constexpr bool operator!=(const TernaryOperator& lhs,
const TernaryOperator& rhs) {
return !operator==(lhs, rhs);
}
constexpr bool operator!=(TernaryOperatorId lhs, const TernaryOperator& rhs) {
return !operator==(lhs, rhs);
}
constexpr bool operator!=(const TernaryOperator& lhs, TernaryOperatorId rhs) {
return !operator==(lhs, rhs);
}
template <typename H>
H AbslHashValue(H state, const TernaryOperator& op) {
return H::combine(std::move(state), static_cast<int>(op.id()));
}
} // namespace cel
#endif // THIRD_PARTY_CEL_CPP_BASE_OPERATORS_H_
================================================
FILE: base/operators_test.cc
================================================
// 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.
#include "base/operators.h"
#include <type_traits>
#include "absl/hash/hash_testing.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "base/internal/operators.h"
#include "internal/testing.h"
namespace cel {
namespace {
using ::testing::Eq;
using ::testing::Optional;
template <typename Op, typename OpId>
void TestOperator(Op op, OpId id, absl::string_view name,
absl::string_view display_name, int precedence, Arity arity) {
EXPECT_EQ(op.id(), id);
EXPECT_EQ(Operator(op).id(), static_cast<OperatorId>(id));
EXPECT_EQ(op.name(), name);
EXPECT_EQ(op.display_name(), display_name);
EXPECT_EQ(op.precedence(), precedence);
EXPECT_EQ(op.arity(), arity);
EXPECT_EQ(Operator(op).arity(), arity);
EXPECT_EQ(Op(Operator(op)), op);
}
void TestUnaryOperator(UnaryOperator op, UnaryOperatorId id,
absl::string_view name, absl::string_view display_name,
int precedence) {
TestOperator(op, id, name, display_name, precedence, Arity::kUnary);
}
void TestBinaryOperator(BinaryOperator op, BinaryOperatorId id,
absl::string_view name, absl::string_view display_name,
int precedence) {
TestOperator(op, id, name, display_name, precedence, Arity::kBinary);
}
void TestTernaryOperator(TernaryOperator op, TernaryOperatorId id,
absl::string_view name, absl::string_view display_name,
int precedence) {
TestOperator(op, id, name, display_name, precedence, Arity::kTernary);
}
TEST(Operator, TypeTraits) {
EXPECT_FALSE(std::is_default_constructible_v<Operator>);
EXPECT_TRUE(std::is_copy_constructible_v<Operator>);
EXPECT_TRUE(std::is_move_constructible_v<Operator>);
EXPECT_TRUE(std::is_copy_assignable_v<Operator>);
EXPECT_TRUE(std::is_move_assignable_v<Operator>);
EXPECT_FALSE((std::is_convertible_v<Operator, UnaryOperator>));
EXPECT_FALSE((std::is_convertible_v<Operator, BinaryOperator>));
EXPECT_FALSE((std::is_convertible_v<Operator, TernaryOperator>));
}
TEST(UnaryOperator, TypeTraits) {
EXPECT_FALSE(std::is_default_constructible_v<UnaryOperator>);
EXPECT_TRUE(std::is_copy_constructible_v<UnaryOperator>);
EXPECT_TRUE(std::is_move_constructible_v<UnaryOperator>);
EXPECT_TRUE(std::is_copy_assignable_v<UnaryOperator>);
EXPECT_TRUE(std::is_move_assignable_v<UnaryOperator>);
EXPECT_TRUE((std::is_convertible_v<UnaryOperator, Operator>));
}
TEST(BinaryOperator, TypeTraits) {
EXPECT_FALSE(std::is_default_constructible_v<BinaryOperator>);
EXPECT_TRUE(std::is_copy_constructible_v<BinaryOperator>);
EXPECT_TRUE(std::is_move_constructible_v<BinaryOperator>);
EXPECT_TRUE(std::is_copy_assignable_v<BinaryOperator>);
EXPECT_TRUE(std::is_move_assignable_v<BinaryOperator>);
EXPECT_TRUE((std::is_convertible_v<BinaryOperator, Operator>));
}
TEST(TernaryOperator, TypeTraits) {
EXPECT_FALSE(std::is_default_constructible_v<TernaryOperator>);
EXPECT_TRUE(std::is_copy_constructible_v<TernaryOperator>);
EXPECT_TRUE(std::is_move_constructible_v<TernaryOperator>);
EXPECT_TRUE(std::is_copy_assignable_v<TernaryOperator>);
EXPECT_TRUE(std::is_move_assignable_v<TernaryOperator>);
EXPECT_TRUE((std::is_convertible_v<TernaryOperator, Operator>));
}
#define CEL_UNARY_OPERATOR(id, symbol, name, precedence, arity) \
TEST(UnaryOperator, id) { \
TestUnaryOperator(UnaryOperator::id(), UnaryOperatorId::k##id, name, \
symbol, precedence); \
}
CEL_INTERNAL_UNARY_OPERATORS_ENUM(CEL_UNARY_OPERATOR)
#undef CEL_UNARY_OPERATOR
#define CEL_BINARY_OPERATOR(id, symbol, name, precedence, arity) \
TEST(BinaryOperator, id) { \
TestBinaryOperator(BinaryOperator::id(), BinaryOperatorId::k##id, name, \
symbol, precedence); \
}
CEL_INTERNAL_BINARY_OPERATORS_ENUM(CEL_BINARY_OPERATOR)
#undef CEL_BINARY_OPERATOR
#define CEL_TERNARY_OPERATOR(id, symbol, name, precedence, arity) \
TEST(TernaryOperator, id) { \
TestTernaryOperator(TernaryOperator::id(), TernaryOperatorId::k##id, name, \
symbol, precedence); \
}
CEL_INTERNAL_TERNARY_OPERATORS_ENUM(CEL_TERNARY_OPERATOR)
#undef CEL_TERNARY_OPERATOR
TEST(Operator, FindByName) {
EXPECT_THAT(Operator::FindByName("@in"), Optional(Eq(Operator::In())));
EXPECT_THAT(Operator::FindByName("_in_"), Optional(Eq(Operator::OldIn())));
EXPECT_THAT(Operator::FindByName("in"), Eq(absl::nullopt));
EXPECT_THAT(Operator::FindByName(""), Eq(absl::nullopt));
}
TEST(Operator, FindByDisplayName) {
EXPECT_THAT(Operator::FindByDisplayName("-"),
Optional(Eq(Operator::Subtract())));
EXPECT_THAT(Operator::FindByDisplayName("@in"), Eq(absl::nullopt));
EXPECT_THAT(Operator::FindByDisplayName(""), Eq(absl::nullopt));
}
TEST(UnaryOperator, FindByName) {
EXPECT_THAT(UnaryOperator::FindByName("-_"),
Optional(Eq(Operator::Negate())));
EXPECT_THAT(UnaryOperator::FindByName("_-_"), Eq(absl::nullopt));
EXPECT_THAT(UnaryOperator::FindByName(""), Eq(absl::nullopt));
}
TEST(UnaryOperator, FindByDisplayName) {
EXPECT_THAT(UnaryOperator::FindByDisplayName("-"),
Optional(Eq(Operator::Negate())));
EXPECT_THAT(UnaryOperator::FindByDisplayName("&&"), Eq(absl::nullopt));
EXPECT_THAT(UnaryOperator::FindByDisplayName(""), Eq(absl::nullopt));
}
TEST(BinaryOperator, FindByName) {
EXPECT_THAT(BinaryOperator::FindByName("_-_"),
Optional(Eq(Operator::Subtract())));
EXPECT_THAT(BinaryOperator::FindByName("-_"), Eq(absl::nullopt));
EXPECT_THAT(BinaryOperator::FindByName(""), Eq(absl::nullopt));
}
TEST(BinaryOperator, FindByDisplayName) {
EXPECT_THAT(BinaryOperator::FindByDisplayName("-"),
Optional(Eq(Operator::Subtract())));
EXPECT_THAT(BinaryOperator::FindByDisplayName("!"), Eq(absl::nullopt));
EXPECT_THAT(BinaryOperator::FindByDisplayName(""), Eq(absl::nullopt));
}
TEST(TernaryOperator, FindByName) {
EXPECT_THAT(TernaryOperator::FindByName("_?_:_"),
Optional(Eq(TernaryOperator::Conditional())));
EXPECT_THAT(TernaryOperator::FindByName("-_"), Eq(absl::nullopt));
EXPECT_THAT(TernaryOperator::FindByName(""), Eq(absl::nullopt));
}
TEST(TernaryOperator, FindByDisplayName) {
EXPECT_THAT(TernaryOperator::FindByDisplayName(""), Eq(absl::nullopt));
EXPECT_THAT(TernaryOperator::FindByDisplayName("!"), Eq(absl::nullopt));
}
TEST(Operator, SupportsAbslHash) {
#define CEL_OPERATOR(id, symbol, name, precedence, arity) \
Operator(Operator::id()),
EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
{CEL_INTERNAL_OPERATORS_ENUM(CEL_OPERATOR)}));
#undef CEL_OPERATOR
}
TEST(UnaryOperator, SupportsAbslHash) {
#define CEL_UNARY_OPERATOR(id, symbol, name, precedence, arity) \
UnaryOperator::id(),
EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
{CEL_INTERNAL_UNARY_OPERATORS_ENUM(CEL_UNARY_OPERATOR)}));
#undef CEL_UNARY_OPERATOR
}
TEST(BinaryOperator, SupportsAbslHash) {
#define CEL_BINARY_OPERATOR(id, symbol, name, precedence, arity) \
BinaryOperator::id(),
EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
{CEL_INTERNAL_BINARY_OPERATORS_ENUM(CEL_BINARY_OPERATOR)}));
#undef CEL_BINARY_OPERATOR
}
} // namespace
} // namespace cel
================================================
FILE: base/type_provider.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_BASE_TYPE_PROVIDER_H_
#define THIRD_PARTY_CEL_CPP_BASE_TYPE_PROVIDER_H_
#include "common/type_reflector.h" // IWYU pragma: export
namespace cel {
using TypeProvider = TypeReflector;
}
#endif // THIRD_PARTY_CEL_CPP_BASE_TYPE_PROVIDER_H_
================================================
FILE: bazel/BUILD
================================================
load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
load("@rules_java//java:defs.bzl", "java_binary")
java_binary(
name = "antlr4_tool",
main_class = "org.antlr.v4.Tool",
runtime_deps = ["@antlr4_jar//jar"],
)
package(default_visibility = ["//visibility:public"])
exports_files(
srcs = [
"antlr.patch",
],
visibility = ["//:__subpackages__"],
)
cc_binary(
name = "cel_cc_embed",
srcs = ["cel_cc_embed.cc"],
visibility = ["//:__subpackages__"],
deps = [
"@com_google_absl//absl/flags:flag",
"@com_google_absl//absl/flags:parse",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/log:initialize",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/types:span",
],
)
cc_binary(
name = "cat_param_file",
srcs = ["cat_param_file.cc"],
visibility = ["//:__subpackages__"],
deps = [
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/log:absl_log",
"@com_google_absl//absl/log:initialize",
],
)
================================================
FILE: bazel/antlr.bzl
================================================
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Generate C++ parser and lexer from a grammar file.
"""
load("@rules_cc//cc:cc_library.bzl", "cc_library")
load("@rules_cc//cc/common:cc_common.bzl", "cc_common")
load("@rules_cc//cc/common:cc_info.bzl", "CcInfo")
def antlr_cc_library(name, src, package):
"""Creates a C++ lexer and parser from a source grammar.
Args:
name: Base name for the lexer and the parser rules.
src: source ANTLR grammar file
package: The namespace for the generated code
"""
generated = name + "_grammar"
antlr_library(
name = generated,
src = src,
package = package,
shell = select(
{
"@platforms//os:windows": "PowerShell.exe",
"//conditions:default": "bash",
},
),
genfiles_prefixed = select(
{
"@platforms//os:windows": False,
"//conditions:default": True,
},
),
)
cc_library(
name = name + "_cc_parser",
srcs = [generated],
defines = [
"ANTLR4CPP_STATIC",
],
deps = [
generated,
"@antlr4-cpp-runtime//:antlr4-cpp-runtime",
],
linkstatic = 1,
)
def _antlr_library(ctx):
output = ctx.actions.declare_directory(ctx.attr.name)
antlr_args = ctx.actions.args()
antlr_args.add("-Dlanguage=Cpp")
antlr_args.add("-no-listener")
antlr_args.add("-visitor")
antlr_args.add("-o", output.path)
antlr_args.add("-package", ctx.attr.package)
antlr_args.add(ctx.file.src)
# Strip ".g4" extension.
basename = ctx.file.src.basename[:-3]
suffixes = ["Lexer", "Parser", "BaseVisitor", "Visitor"]
ctx.actions.run(
mnemonic = "GenAntlr",
arguments = [antlr_args],
inputs = [ctx.file.src],
outputs = [output],
executable = ctx.executable._tool,
progress_message = "Processing ANTLR grammar. -o " + output.path,
)
files = []
for suffix in suffixes:
header = ctx.actions.declare_file(basename + suffix + ".h")
source = ctx.actions.declare_file(basename + suffix + ".cpp")
prefix = ctx.file.src.path[:-3] if ctx.attr.genfiles_prefixed else basename
generated = output.path + "/" + prefix + suffix
executable = ctx.attr.shell
ctx.actions.run(
mnemonic = "CopyHeader" + suffix,
inputs = [output],
outputs = [header],
executable = executable,
arguments = [
"-c",
'cp "{generated}" "{out}"'.format(generated = generated + ".h", out = header.path),
],
)
ctx.actions.run(
mnemonic = "CopySource" + suffix,
inputs = [output],
outputs = [source],
executable = executable,
arguments = [
"-c",
'cp "{generated}" "{out}"'.format(generated = generated + ".cpp", out = source.path),
],
)
files.append(header)
files.append(source)
compilation_context = cc_common.create_compilation_context(headers = depset(files))
return [DefaultInfo(files = depset(files)), CcInfo(compilation_context = compilation_context)]
antlr_library = rule(
implementation = _antlr_library,
attrs = {
"src": attr.label(allow_single_file = [".g4"], mandatory = True),
"package": attr.string(),
"_tool": attr.label(
executable = True,
cfg = "exec", # buildifier: disable=attr-cfg
default = Label("//bazel:antlr4_tool"),
),
"shell": attr.string(
mandatory = True,
),
"genfiles_prefixed": attr.bool(
mandatory = True,
),
},
)
================================================
FILE: bazel/antlr.patch
================================================
--- BUILD.bazel
+++ BUILD.bazel
@@ -17,21 +17,21 @@
cc_library(
name = "antlr4-cpp-runtime",
srcs = glob(["runtime/src/**/*.cpp"]),
hdrs = ["runtime/src/antlr4-runtime.h"],
copts = ["-fexceptions"],
- defines = ["ANTLR4CPP_USING_ABSEIL"],
+ defines = ["ANTLR4CPP_USING_ABSEIL", "ANTLR4CPP_STATIC"],
features = ["-use_header_modules"],
includes = ["runtime/src"],
textual_hdrs = glob(
["runtime/src/**/*.h"],
exclude = ["runtime/src/antlr4-runtime.h"],
),
visibility = ["//visibility:public"],
deps = [
"@com_google_absl//absl/base",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/container:flat_hash_set",
"@com_google_absl//absl/synchronization",
],
)
--- VERSION
+++ /dev/null
@@ -1,1 +1,0 @@
-4.13.2
================================================
FILE: bazel/cat_param_file.cc
================================================
// 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.
#include <cstddef>
#include <fstream>
#include <iostream>
#include <string>
#include "absl/log/absl_check.h"
#include "absl/log/absl_log.h"
#include "absl/log/initialize.h"
// Read a bazel param file and concatenate the inputs.
// The param file is line delimited with each line a file to concat.
int main(int argc, char** argv) {
absl::InitializeLog();
if (argc != 3) {
std::cerr << "usage: cat_param_file <param_file> <out>" << std::endl;
std::cerr << "args " << argc << std::endl;
return 2;
}
const char* param_file = argv[1];
const char* out_file = argv[2];
std::ifstream ifs(param_file, std::ios::binary);
std::ofstream ofs(out_file, std::ios::binary);
ABSL_QCHECK(ifs.good()) << "failed to open param file " << param_file;
ABSL_QCHECK(ofs.good()) << "failed to open out file " << out_file;
for (std::string line; std::getline(ifs, line);) {
std::ifstream in(line, std::ios::binary);
if (!in.good()) {
ABSL_LOG(ERROR) << "failed to open input file " << line;
continue;
}
constexpr size_t kBufSize = 256;
char buf[kBufSize];
while (true) {
in.read(buf, kBufSize);
size_t read = in.gcount();
if (read == 0) {
break;
}
ofs.write(buf, read);
}
}
ofs.flush();
return 0;
}
================================================
FILE: bazel/cel_cc_embed.bzl
================================================
# 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.
"""
Provides the `cel_cc_embed` build rule.
"""
def _cel_cc_embed(ctx):
output = ctx.actions.declare_file(ctx.attr.name + ".inc")
args = ctx.actions.args()
src = ctx.file.src
args.add("--in", src)
args.add("--out", output.path)
ctx.actions.run(
mnemonic = "GenerateEmbedTextualHeader",
outputs = [output],
inputs = [src],
progress_message = "generating embed textual header",
executable = ctx.executable.gen_tool,
arguments = [args],
)
return DefaultInfo(
files = depset([output]),
)
cel_cc_embed = rule(
implementation = _cel_cc_embed,
attrs = {
"src": attr.label(allow_single_file = True, mandatory = True),
"gen_tool": attr.label(
executable = True,
cfg = "exec",
allow_files = True,
default = Label("//bazel:cel_cc_embed"),
),
},
)
================================================
FILE: bazel/cel_cc_embed.cc
================================================
// 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.
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <fstream>
#include <string>
#include <vector>
#include "absl/flags/flag.h"
#include "absl/flags/parse.h"
#include "absl/log/absl_check.h"
#include "absl/log/initialize.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "absl/types/span.h"
ABSL_FLAG(std::string, in, "", "");
ABSL_FLAG(std::string, out, "", "");
namespace {
std::vector<uint8_t> ReadFile(const std::string& path) {
ABSL_CHECK(!path.empty()) << "--in is required";
std::ifstream file(path, std::ifstream::binary);
ABSL_CHECK(file.is_open()) << path;
file.seekg(0, file.end);
ABSL_CHECK(file.good());
size_t size = static_cast<size_t>(file.tellg());
file.seekg(0, file.beg);
ABSL_CHECK(file.good());
std::vector<uint8_t> buffer;
buffer.resize(size);
file.read(reinterpret_cast<char*>(buffer.data()), size);
ABSL_CHECK(file.good());
return buffer;
}
void WriteFile(const std::string& path, absl::Span<const char> data) {
ABSL_CHECK(!path.empty()) << "--out is required";
std::ofstream file(path);
ABSL_CHECK(file.is_open()) << path;
file.write(data.data(), data.size());
ABSL_CHECK(file.good());
file.flush();
ABSL_CHECK(file.good());
}
} // namespace
int main(int argc, char** argv) {
{
auto args = absl::ParseCommandLine(argc, argv);
ABSL_CHECK(args.empty() || args.size() == 1)
<< "unexpected positional args: " << absl::StrJoin(args, ", ");
}
absl::InitializeLog();
auto in_buffer = ReadFile(absl::GetFlag(FLAGS_in));
std::string out_buffer;
out_buffer.reserve(in_buffer.size() * 6);
for (const auto& in_byte : in_buffer) {
absl::StrAppend(&out_buffer, "0x",
absl::Hex(in_byte, absl::PadSpec::kZeroPad2), ", ");
}
if (!in_buffer.empty()) {
// Replace last space with newline.
out_buffer.back() = '\n';
}
WriteFile(absl::GetFlag(FLAGS_out), out_buffer);
return EXIT_SUCCESS;
}
================================================
FILE: bazel/cel_proto_transitive_descriptor_set.bzl
================================================
# 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.
"""
Provides the `cel_proto_transitive_descriptor_set` build rule.
"""
load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo")
def _cel_proto_transitive_descriptor_set(ctx):
output = ctx.actions.declare_file(ctx.attr.name + ".binarypb")
transitive_descriptor_sets = depset(transitive = [dep[ProtoInfo].transitive_descriptor_sets for dep in ctx.attr.deps])
args = ctx.actions.args()
args.use_param_file(param_file_arg = "%s", use_always = True)
args.add_all(transitive_descriptor_sets)
ctx.actions.run(
mnemonic = "CelProtoTransitiveDescriptorSet",
outputs = [output],
inputs = transitive_descriptor_sets,
progress_message = "Joining descriptors.",
executable = ctx.executable.cat_tool,
arguments = [args] + [output.path],
)
return DefaultInfo(
files = depset([output]),
runfiles = ctx.runfiles(files = [output]),
)
cel_proto_transitive_descriptor_set = rule(
attrs = {
"deps": attr.label_list(providers = [[ProtoInfo]]),
"cat_tool": attr.label(
executable = True,
cfg = "exec",
allow_files = True,
default = Label("//bazel:cat_param_file"),
),
},
outputs = {
"out": "%{name}.binarypb",
},
implementation = _cel_proto_transitive_descriptor_set,
)
================================================
FILE: bazel/deps.bzl
================================================
"""
Legacy workspace dependencies of cel-cpp.
Dependencies are now managed by MODULE.bazel. The values here are not updated, but this file is
retained for clients that referenced it directly.
"""
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive", "http_jar")
def base_deps():
"""Base evaluator and test dependencies."""
# Abseil LTS 20240722.0
ABSL_SHA1 = "4447c7562e3bc702ade25105912dce503f0c4010"
ABSL_SHA256 = "d8342ad77aa9e16103c486b615460c24a695a1f04cdb760eb02fef780df99759"
http_archive(
name = "com_google_absl",
urls = ["https://github.com/abseil/abseil-cpp/archive/" + ABSL_SHA1 + ".zip"],
strip_prefix = "abseil-cpp-" + ABSL_SHA1,
sha256 = ABSL_SHA256,
)
# v1.15.2
GOOGLETEST_SHA1 = "b514bdc898e2951020cbdca1304b75f5950d1f59"
GOOGLETEST_SHA256 = "8c0ceafa3ea24bf78e3519b7846d99e76c45899aa4dac4d64e7dd62e495de9fd"
http_archive(
name = "com_google_googletest",
urls = ["https://github.com/google/googletest/archive/" + GOOGLETEST_SHA1 + ".zip"],
strip_prefix = "googletest-" + GOOGLETEST_SHA1,
sha256 = GOOGLETEST_SHA256,
)
# v1.6.0
BENCHMARK_SHA1 = "f91b6b42b1b9854772a90ae9501464a161707d1e"
BENCHMARK_SHA256 = "00bd0837db9266c758a087cdf0831a0d3e337c6bb9e3fad75d2be4f9bf480d95"
http_archive(
name = "com_github_google_benchmark",
urls = ["https://github.com/google/benchmark/archive/" + BENCHMARK_SHA1 + ".zip"],
strip_prefix = "benchmark-" + BENCHMARK_SHA1,
sha256 = BENCHMARK_SHA256,
)
# 2024-02-01
RE2_SHA1 = "9665465b69ab699279ef9fb9454559d90fed1d76"
RE2_SHA256 = "dcd82922c7a1d3b7c2a147c045585a9f76066f9c0269a06b857eccbbf6f96dba"
http_archive(
name = "com_googlesource_code_re2",
urls = ["https://github.com/google/re2/archive/" + RE2_SHA1 + ".zip"],
strip_prefix = "re2-" + RE2_SHA1,
sha256 = RE2_SHA256,
)
# v28.0
PROTOBUF_SHA1 = "439c42c735ae1efed57ab7771986f2a3c0b99319"
PROTOBUF_SHA256 = "495b76871df8d102e5c539f9d43f990f5ca53ac183702f5ed90070ba8c8759d1"
http_archive(
name = "com_google_protobuf",
sha256 = PROTOBUF_SHA256,
strip_prefix = "protobuf-" + PROTOBUF_SHA1,
urls = ["https://github.com/protocolbuffers/protobuf/archive/" + PROTOBUF_SHA1 + ".zip"],
)
GOOGLEAPIS_GIT_SHA = "6eb56cdf5f54f70d0dbfce051add28a35c1203ce" # June 26, 2024
GOOGLEAPIS_SHA = "6321a7eac9e5280e7abca07ddf2cab9179cbd49a6828c26f4c7c73d5a45f39ad"
http_archive(
name = "com_google_googleapis",
sha256 = GOOGLEAPIS_SHA,
strip_prefix = "googleapis-" + GOOGLEAPIS_GIT_SHA,
urls = ["https://github.com/googleapis/googleapis/archive/" + GOOGLEAPIS_GIT_SHA + ".tar.gz"],
)
http_archive(
name = "rules_cc",
urls = ["https://github.com/bazelbuild/rules_cc/releases/download/0.0.10-rc1/rules_cc-0.0.10-rc1.tar.gz"],
sha256 = "d75a040c32954da0d308d3f2ea2ba735490f49b3a7aa3e4b40259ca4b814f825",
)
http_archive(
name = "rules_proto",
sha256 = "6fb6767d1bef535310547e03247f7518b03487740c11b6c6adb7952033fe1295",
strip_prefix = "rules_proto-6.0.2",
url = "https://github.com/bazelbuild/rules_proto/releases/download/6.0.2/rules_proto-6.0.2.tar.gz",
)
def parser_deps():
"""ANTLR dependency for the parser."""
# Sept 4, 2023
ANTLR4_VERSION = "4.13.1"
http_archive(
name = "antlr4_runtimes",
build_file_content = """
package(default_visibility = ["//visibility:public"])
cc_library(
name = "cpp",
srcs = glob(["runtime/Cpp/runtime/src/**/*.cpp"]),
hdrs = glob(["runtime/Cpp/runtime/src/**/*.h"]),
defines = ["ANTLR4CPP_USING_ABSEIL"],
includes = ["runtime/Cpp/runtime/src"],
deps = [
"@com_google_absl//absl/base",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/container:flat_hash_set",
"@com_google_absl//absl/synchronization",
],
)
""",
sha256 = "365ff6aec0b1612fb964a763ca73748d80e0b3379cbdd9f82d86333eb8ae4638",
strip_prefix = "antlr4-" + ANTLR4_VERSION,
urls = ["https://github.com/antlr/antlr4/archive/refs/tags/" + ANTLR4_VERSION + ".zip"],
)
http_jar(
name = "antlr4_jar",
urls = ["https://www.antlr.org/download/antlr-" + ANTLR4_VERSION + "-complete.jar"],
sha256 = "bc13a9c57a8dd7d5196888211e5ede657cb64a3ce968608697e4f668251a8487",
)
def flatbuffers_deps():
"""FlatBuffers support."""
FLAT_BUFFERS_SHA = "a83caf5910644ba1c421c002ef68e42f21c15f9f"
http_archive(
name = "com_github_google_flatbuffers",
sha256 = "b8efbc25721e76780752bad775a97c3f77a0250271e2db37fc747b20e8b0f24a",
strip_prefix = "flatbuffers-" + FLAT_BUFFERS_SHA,
url = "https://github.com/google/flatbuffers/archive/" + FLAT_BUFFERS_SHA + ".tar.gz",
)
def cel_spec_deps():
"""CEL Spec conformance testing."""
http_archive(
name = "io_bazel_rules_go",
sha256 = "b2038e2de2cace18f032249cb4bb0048abf583a36369fa98f687af1b3f880b26",
urls = [
"https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.48.1/rules_go-v0.48.1.zip",
"https://github.com/bazelbuild/rules_go/releases/download/v0.48.1/rules_go-v0.48.1.zip",
],
)
http_archive(
name = "rules_python",
sha256 = "e3f1cc7a04d9b09635afb3130731ed82b5f58eadc8233d4efb59944d92ffc06f",
strip_prefix = "rules_python-0.33.2",
url = "https://github.com/bazelbuild/rules_python/releases/download/0.33.2/rules_python-0.33.2.tar.gz",
)
CEL_SPEC_GIT_SHA = "afa18f9bd5a83f5960ca06c1f9faea406ab34ccc" # Dec 2, 2024
http_archive(
name = "com_google_cel_spec",
sha256 = "19b4084ba33cc8da7a640d999e46731efbec585ad2995951dc61a7af24f059cb",
strip_prefix = "cel-spec-" + CEL_SPEC_GIT_SHA,
urls = ["https://github.com/google/cel-spec/archive/" + CEL_SPEC_GIT_SHA + ".zip"],
)
_ICU4C_VERSION_MAJOR = "76"
_ICU4C_VERSION_MINOR = "1"
_ICU4C_BUILD = """
load("@rules_foreign_cc//foreign_cc:configure.bzl", "configure_make")
filegroup(
name = "all",
srcs = glob(["**"]),
visibility = ["//visibility:private"],
)
config_setting(
name = "dbg",
values = {{
"compilation_mode": "dbg",
}},
visibility = ["//visibility:private"],
)
configure_make(
name = "icu4c",
configure_command = "source/configure",
configure_in_place = True,
configure_options = [
"--enable-shared",
"--enable-static",
"--disable-extras",
"--disable-icuio",
"--disable-layoutex",
"--disable-icu-config",
] + select({{
":dbg": ["--enable-debug"],
"//conditions:default": [],
}}),
lib_source = ":all",
out_shared_libs = [
"libicudata.so",
"libicudata.so.{version_major}",
"libicudata.so.{version_major}.{version_minor}",
"libicui18n.so",
"libicui18n.so.{version_major}",
"libicui18n.so.{version_major}.{version_minor}",
"libicutu.so",
"libicutu.so.{version_major}",
"libicutu.so.{version_major}.{version_minor}",
"libicuuc.so",
"libicuuc.so.{version_major}",
"libicuuc.so.{version_major}.{version_minor}",
],
out_static_libs = [
"libicudata.a",
"libicui18n.a",
"libicutu.a",
"libicuuc.a",
],
args = ["-j 8"],
visibility = ["//visibility:public"],
)
""".format(version_major = _ICU4C_VERSION_MAJOR, version_minor = _ICU4C_VERSION_MINOR)
def cel_cpp_extensions_deps():
http_archive(
name = "rules_foreign_cc",
sha256 = "8e5605dc2d16a4229cb8fbe398514b10528553ed4f5f7737b663fdd92f48e1c2",
strip_prefix = "rules_foreign_cc-0.13.0",
url = "https://github.com/bazel-contrib/rules_foreign_cc/releases/download/0.13.0/rules_foreign_cc-0.13.0.tar.gz",
)
http_archive(
name = "icu4c",
sha256 = "dfacb46bfe4747410472ce3e1144bf28a102feeaa4e3875bac9b4c6cf30f4f3e",
url = "https://github.com/unicode-org/icu/releases/download/release-{version_major}-{version_minor}/icu4c-{version_major}_{version_minor}-src.tgz".format(version_major = _ICU4C_VERSION_MAJOR, version_minor = _ICU4C_VERSION_MINOR),
strip_prefix = "icu",
patch_cmds = [
"rm -f source/common/BUILD.bazel",
"rm -f source/i18n/BUILD.bazel",
"rm -f source/stubdata/BUILD.bazel",
"rm -f source/tools/gennorm2/BUILD.bazel",
"rm -f source/tools/toolutil/BUILD.bazel",
"rm -f source/tools/unicode/c/genprops/BUILD.bazel",
"rm -f source/tools/unicode/c/genuca/BUILD.bazel",
"rm -f source/vendor/double-conversion/upstream/WORKSPACE",
],
build_file_content = _ICU4C_BUILD,
)
def cel_cpp_deps():
"""All core dependencies of cel-cpp."""
base_deps()
parser_deps()
flatbuffers_deps()
cel_spec_deps()
================================================
FILE: checker/BUILD
================================================
load("@rules_cc//cc:cc_library.bzl", "cc_library")
load("@rules_cc//cc:cc_test.bzl", "cc_test")
# 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(default_visibility = ["//visibility:public"])
cc_library(
name = "checker_options",
hdrs = ["checker_options.h"],
)
cc_library(
name = "type_check_issue",
srcs = ["type_check_issue.cc"],
hdrs = ["type_check_issue.h"],
deps = [
"//common:source",
"@com_google_absl//absl/strings:str_format",
"@com_google_absl//absl/strings:string_view",
],
)
cc_test(
name = "type_check_issue_test",
srcs = ["type_check_issue_test.cc"],
deps = [
":type_check_issue",
"//common:source",
"//internal:testing",
],
)
cc_library(
name = "validation_result",
srcs = ["validation_result.cc"],
hdrs = ["validation_result.h"],
deps = [
":type_check_issue",
"//common:ast",
"//common:source",
"//common:type",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/types:span",
],
)
cc_test(
name = "validation_result_test",
srcs = ["validation_result_test.cc"],
deps = [
":type_check_issue",
":validation_result",
"//common:ast",
"//common:source",
"//internal:testing",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:status_matchers",
],
)
cc_library(
name = "type_checker",
srcs = ["type_checker.cc"],
hdrs = ["type_checker.h"],
deps = [
":validation_result",
"//common:ast",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/status:statusor",
"@com_google_protobuf//:protobuf",
],
)
cc_library(
name = "type_checker_builder",
hdrs = ["type_checker_builder.h"],
deps = [
":checker_options",
":type_checker",
"//common:container",
"//common:decl",
"//common:type",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/functional:any_invocable",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/strings",
"@com_google_protobuf//:protobuf",
],
)
cc_library(
name = "type_checker_builder_factory",
srcs = ["type_checker_builder_factory.cc"],
hdrs = ["type_checker_builder_factory.h"],
deps = [
":checker_options",
":type_checker_builder",
"//checker/internal:type_checker_impl",
"//internal:noop_delete",
"//internal:status_macros",
"//internal:well_known_types",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/status:statusor",
"@com_google_protobuf//:protobuf",
],
)
cc_test(
name = "type_checker_builder_factory_test",
srcs = ["type_checker_builder_factory_test.cc"],
deps = [
":checker_options",
":optional",
":standard_library",
":type_checker",
":type_checker_builder",
":type_checker_builder_factory",
":validation_result",
"//checker/internal:test_ast_helpers",
"//common:ast",
"//common:decl",
"//common:type",
"//internal:status_macros",
"//internal:testing",
"//internal:testing_descriptor_pool",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:status_matchers",
"@com_google_absl//absl/strings:string_view",
],
)
cc_library(
name = "standard_library",
srcs = ["standard_library.cc"],
hdrs = ["standard_library.h"],
deps = [
":type_checker_builder",
"//checker/internal:builtins_arena",
"//common:constant",
"//common:decl",
"//common:standard_definitions",
"//common:type",
"//internal:status_macros",
"@com_google_absl//absl/base:no_destructor",
"@com_google_absl//absl/status",
],
)
cc_test(
name = "standard_library_test",
srcs = ["standard_library_test.cc"],
deps = [
":checker_options",
":standard_library",
":type_checker",
":type_checker_builder",
":type_checker_builder_factory",
":validation_result",
"//checker/internal:test_ast_helpers",
"//common:ast",
"//common:constant",
"//common:decl",
"//common:type",
"//internal:testing",
"//internal:testing_descriptor_pool",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:status_matchers",
"@com_google_protobuf//:protobuf",
],
)
cc_library(
name = "optional",
srcs = ["optional.cc"],
hdrs = ["optional.h"],
deps = [
":type_checker_builder",
"//base:builtins",
"//checker/internal:builtins_arena",
"//common:decl",
"//common:type",
"//internal:status_macros",
"@com_google_absl//absl/base:no_destructor",
"@com_google_absl//absl/status",
],
)
cc_test(
name = "optional_test",
srcs = ["optional_test.cc"],
deps = [
":checker_options",
":optional",
":standard_library",
":type_check_issue",
":type_checker",
":type_checker_builder",
":type_checker_builder_factory",
"//checker/internal:test_ast_helpers",
"//common:ast",
"//internal:testing",
"//internal:testing_descriptor_pool",
"@com_google_absl//absl/status:status_matchers",
"@com_google_absl//absl/strings",
],
)
cc_library(
name = "type_checker_subset_factory",
srcs = ["type_checker_subset_factory.cc"],
hdrs = ["type_checker_subset_factory.h"],
deps = [
":type_checker_builder",
"@com_google_absl//absl/container:flat_hash_set",
"@com_google_absl//absl/strings:string_view",
"@com_google_absl//absl/types:span",
],
)
cc_test(
name = "type_checker_subset_factory_test",
srcs = ["type_checker_subset_factory_test.cc"],
deps = [
":type_checker_subset_factory",
":validation_result",
"//common:standard_definitions",
"//compiler",
"//compiler:compiler_factory",
"//compiler:standard_library",
"//internal:testing",
"//internal:testing_descriptor_pool",
"@com_google_absl//absl/status:status_matchers",
"@com_google_absl//absl/strings:string_view",
],
)
================================================
FILE: checker/checker_options.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_CHECKER_CHECKER_OPTIONS_H_
#define THIRD_PARTY_CEL_CPP_CHECKER_CHECKER_OPTIONS_H_
namespace cel {
// Options for enabling core type checker features.
struct CheckerOptions {
// Enable overloads for numeric comparisons across types.
// For example, 1.0 < 2 will resolve to lt_double_int.
//
// By default, this is disabled and expressions must explicitly cast to dyn or
// the same type to compare.
bool enable_cross_numeric_comparisons = false;
// Enable legacy behavior for null assignment.
//
// Historically, CEL has allowed null to be assigned to structs, abstract
// types, durations, timestamps, and any types. This is inconsistent with
// CEL's usual interpretation of null as a literal JSON null.
//
// TODO(uncreated-issue/75): Need a concrete plan for updating existing CEL
// expressions that depend on the old behavior.
bool enable_legacy_null_assignment = true;
// Enable updating parsed struct type names to the fully qualified type name
// when resolved.
//
// Enabled by default, but can be disabled to preserve the original type name
// as parsed.
bool update_struct_type_names = true;
// Temporary flag to enable type parameter name validation.
//
// When enabled, the TypeCheckerBuilder will validate that type parameter
// names are simple identifiers when declared.
bool enable_type_parameter_name_validation = true;
// Well-known types defined by protobuf are treated specially in CEL, and
// generally don't behave like other messages as runtime values. When used as
// context declarations, this introduces some ambiguity about the intended
// types of the field declarations, so it is disallowed by default.
//
// When enabled, the well-known types are treated like a normal message type
// for the purposes for declaring context bindings (i.e no unpacking or
// adapting), and use the Descriptor that is assumed by CEL.
//
// E.g. for google.protobuf.Any, the type checker will add a context binding
// with `type_url: string` and `value: bytes` as top level variables.
bool allow_well_known_type_context_declarations = false;
// Maximum number (inclusive) of expression nodes to check for an input
// expression.
//
// If exceeded, the checker should return a status with code InvalidArgument.
int max_expression_node_count = 100000;
// Maximum number (inclusive) of error-level issues to tolerate for an input
// ast.
//
// If exceeded, the checker will stop processing the ast and return
// the current set of issues.
int max_error_issues = 20;
// Maximum amount of nesting allowed for type declarations in function
// signatures and variable declarations.
//
// If exceeded, the TypeCheckerBuilder will report an error when adding the
// declaration.
//
// For untrusted declarations, the caller should set a lower limit to mitigate
// expressions that compound nesting e.g.
// type5(T)->type(type(type(type(type(T)))))); type5(type5(T)) -> type10(T)
int max_type_decl_nesting = 13;
// If true, the checker will include the resolved function name in the
// reference map for the function call expr.
//
// If false, the function name will be empty and implied by the overload id
// set. This matches the behavior in cel-go and cel-java.
//
// Temporary flag to allow rolling out the change. No functional changes to
// evaluation behavior in either mode.
bool enable_function_name_in_reference = true;
// If true, the checker will use the proto json field names for protobuf
// messages. Unlike protojson parsers, it will not accept the standard proto
// field names as valid json field names.
//
// Note: The checked AST will contain the json field names and an extension
// tag, but will require runtime support for resolving the json field names.
bool use_json_field_names = false;
};
} // namespace cel
#endif // THIRD_PARTY_CEL_CPP_CHECKER_CHECKER_OPTIONS_H_
================================================
FILE: checker/internal/BUILD
================================================
# 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.
load("@rules_cc//cc:cc_library.bzl", "cc_library")
load("@rules_cc//cc:cc_test.bzl", "cc_test")
package(
# Implementation details for the checker library.
default_visibility = ["//visibility:public"],
)
cc_library(
name = "test_ast_helpers",
testonly = 1,
srcs = ["test_ast_helpers.cc"],
hdrs = ["test_ast_helpers.h"],
deps = [
"//common:ast",
"//internal:status_macros",
"//parser",
"//parser:options",
"//parser:parser_interface",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/strings:string_view",
],
)
cc_test(
name = "test_ast_helpers_test",
srcs = ["test_ast_helpers_test.cc"],
deps = [
":test_ast_helpers",
"//common:ast",
"//internal:testing",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:status_matchers",
],
)
cc_library(
name = "builtins_arena",
srcs = ["builtins_arena.cc"],
hdrs = ["builtins_arena.h"],
deps = [
"@com_google_absl//absl/base:no_destructor",
"@com_google_absl//absl/base:nullability",
"@com_google_protobuf//:protobuf",
],
)
cc_library(
name = "type_check_env",
srcs = ["type_check_env.cc"],
hdrs = ["type_check_env.h"],
deps = [
":descriptor_pool_type_introspector",
"//common:constant",
"//common:container",
"//common:decl",
"//common:type",
"//internal:status_macros",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/memory",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/strings:string_view",
"@com_google_absl//absl/types:optional",
"@com_google_absl//absl/types:span",
"@com_google_protobuf//:protobuf",
],
)
cc_library(
name = "namespace_generator",
srcs = ["namespace_generator.cc"],
hdrs = ["namespace_generator.h"],
deps = [
"//common:container",
"//internal:lexis",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/functional:function_ref",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/strings:string_view",
"@com_google_absl//absl/types:span",
],
)
cc_test(
name = "namespace_generator_test",
srcs = ["namespace_generator_test.cc"],
deps = [
":namespace_generator",
"//common:container",
"//internal:testing",
"@com_google_absl//absl/status",
"@com_google_absl//absl/strings:string_view",
],
)
cc_library(
name = "type_checker_impl",
srcs = [
"type_checker_builder_impl.cc",
"type_checker_impl.cc",
],
hdrs = [
"type_checker_builder_impl.h",
"type_checker_impl.h",
],
deps = [
":format_type_name",
":namespace_generator",
":type_check_env",
":type_inference_context",
"//checker:checker_options",
"//checker:type_check_issue",
"//checker:type_checker",
"//checker:type_checker_builder",
"//checker:validation_result",
"//common:ast",
"//common:ast_rewrite",
"//common:ast_traverse",
"//common:ast_visitor",
"//common:ast_visitor_base",
"//common:constant",
"//common:container",
"//common:decl",
"//common:expr",
"//common:type",
"//common:type_kind",
"//internal:lexis",
"//internal:status_macros",
"//parser:macro",
"@com_google_absl//absl/base:no_destructor",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/cleanup",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/container:flat_hash_set",
"@com_google_absl//absl/log:absl_log",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/strings:string_view",
"@com_google_absl//absl/time",
"@com_google_absl//absl/types:optional",
"@com_google_absl//absl/types:span",
"@com_google_protobuf//:protobuf",
],
)
cc_test(
name = "type_checker_impl_test",
srcs = ["type_checker_impl_test.cc"],
deps = [
":test_ast_helpers",
":type_check_env",
":type_checker_impl",
"//checker:checker_options",
"//checker:type_check_issue",
"//checker:type_checker_builder",
"//checker:validation_result",
"//common:ast",
"//common:container",
"//common:decl",
"//common:expr",
"//common:source",
"//common:type",
"//internal:status_macros",
"//internal:testing",
"//internal:testing_descriptor_pool",
"//testutil:baseline_tests",
"@com_google_absl//absl/base:no_destructor",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/container:flat_hash_set",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:status_matchers",
"@com_google_absl//absl/strings",
"@com_google_cel_spec//proto/cel/expr/conformance/proto2:test_all_types_cc_proto",
"@com_google_cel_spec//proto/cel/expr/conformance/proto3:test_all_types_cc_proto",
"@com_google_protobuf//:protobuf",
],
)
cc_test(
name = "type_checker_builder_impl_test",
srcs = ["type_checker_builder_impl_test.cc"],
deps = [
":test_ast_helpers",
":type_checker_impl",
"//checker:checker_options",
"//checker:type_checker",
"//checker:type_checker_builder",
"//checker:validation_result",
"//common:ast",
"//common:decl",
"//common:type",
"//internal:testing",
"//internal:testing_descriptor_pool",
"@com_google_absl//absl/status",
"@com_google_absl//absl/status:status_matchers",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/strings:string_view",
"@com_google_absl//absl/types:optional",
"@com_google_protobuf//:protobuf",
],
)
cc_library(
name = "type_inference_context",
srcs = ["type_inference_context.cc"],
hdrs = ["type_inference_context.h"],
deps = [
":format_type_name",
"//common:decl",
"//common:type",
"//common:type_kind",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/container:node_hash_map",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/log:absl_log",
"@com_google_absl//absl/strings",
"@com_google_absl//absl/strings:string_view",
"@com_google_absl//absl/types:optional",
"@com_google_absl//absl/types:span",
"@com_google_protobuf//:protobuf",
],
)
cc_test(
name = "type_inference_context_test",
srcs = ["type_inference_context_test.cc"],
deps = [
":type_inference_context",
"//common:decl",
"//common:type",
"//common:type_kind",
"//internal:testing",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/types:optional",
"@com_google_protobuf//:protobuf",
],
)
cc_library(
name = "format_type_name",
srcs = ["format_type_name.cc"],
hdrs = ["format_type_name.h"],
deps = [
"//common:type",
"//common:type_kind",
"@com_google_absl//absl/strings",
],
)
cc_library(
name = "descriptor_pool_type_introspector",
srcs = ["descriptor_pool_type_introspector.cc"],
hdrs = ["descriptor_pool_type_introspector.h"],
deps = [
"//common:type",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/log:absl_check",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/strings:string_view",
"@com_google_absl//absl/synchronization",
"@com_google_absl//absl/types:optional",
"@com_google_absl//absl/types:span",
"@com_google_protobuf//:protobuf",
],
)
cc_test(
name = "descriptor_pool_type_introspector_test",
srcs = ["descriptor_pool_type_introspector_test.cc"],
deps = [
":descriptor_pool_type_introspector",
"//common:type",
"//internal:testing",
"//internal:testing_descriptor_pool",
"@com_google_absl//absl/status:status_matchers",
"@com_google_absl//absl/status:statusor",
"@com_google_absl//absl/types:optional",
],
)
================================================
FILE: checker/internal/builtins_arena.cc
================================================
// 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.
#include "checker/internal/builtins_arena.h"
#include "absl/base/no_destructor.h"
#include "absl/base/nullability.h"
#include "google/protobuf/arena.h"
namespace cel::checker_internal {
google::protobuf::Arena* absl_nonnull BuiltinsArena() {
static absl::NoDestructor<google::protobuf::Arena> kArena;
return &(*kArena);
}
} // namespace cel::checker_internal
================================================
FILE: checker/internal/builtins_arena.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_CHECKER_INTERNAL_BUILTINS_ARENA_H_
#define THIRD_PARTY_CEL_CPP_CHECKER_INTERNAL_BUILTINS_ARENA_H_
#include "absl/base/nullability.h"
#include "google/protobuf/arena.h"
namespace cel::checker_internal {
// Shared arena for builtin types that are shared across all type checker
// instances.
google::protobuf::Arena* absl_nonnull BuiltinsArena();
} // namespace cel::checker_internal
#endif // THIRD_PARTY_CEL_CPP_CHECKER_INTERNAL_BUILTINS_ARENA_H_
================================================
FILE: checker/internal/descriptor_pool_type_introspector.cc
================================================
// 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.
#include "checker/internal/descriptor_pool_type_introspector.h"
#include <memory>
#include <utility>
#include <vector>
#include "absl/base/nullability.h"
#include "absl/container/flat_hash_map.h"
#include "absl/log/absl_check.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/synchronization/mutex.h"
#include "absl/types/optional.h"
#include "absl/types/span.h"
#include "common/type.h"
#include "common/type_introspector.h"
#include "google/protobuf/descriptor.h"
namespace cel::checker_internal {
namespace {
// Standard implementation for field lookups.
// Avoids building a FieldTable and just checks the DescriptorPool directly.
absl::StatusOr<absl::optional<StructTypeField>>
FindStructTypeFieldByNameDirectly(
const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
absl::string_view type, absl::string_view name) {
const google::protobuf::Descriptor* absl_nullable descriptor =
descriptor_pool->FindMessageTypeByName(type);
if (descriptor == nullptr) {
return absl::nullopt;
}
const google::protobuf::FieldDescriptor* absl_nullable field =
descriptor->FindFieldByName(name);
if (field != nullptr) {
return StructTypeField(MessageTypeField(field));
}
field = descriptor_pool->FindExtensionByPrintableName(descriptor, name);
if (field != nullptr) {
return StructTypeField(MessageTypeField(field));
}
return absl::nullopt;
}
// Standard implementation for listing fields.
// Avoids building a FieldTable and just checks the DescriptorPool directly.
absl::StatusOr<
absl::optional<std::vector<TypeIntrospector::StructTypeFieldListing>>>
ListStructTypeFieldsDirectly(
const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
absl::string_view type) {
const google::protobuf::Descriptor* absl_nullable descriptor =
descriptor_pool->FindMessageTypeByName(type);
if (descriptor == nullptr) {
return absl::nullopt;
}
std::vector<const google::protobuf::FieldDescriptor*> extensions;
descriptor_pool->FindAllExtensions(descriptor, &extensions);
std::vector<TypeIntrospector::StructTypeFieldListing> fields;
fields.reserve(descriptor->field_count() + extensions.size());
for (int i = 0; i < descriptor->field_count(); ++i) {
const google::protobuf::FieldDescriptor* field = descriptor->field(i);
fields.push_back({field->name(), StructTypeField(MessageTypeField(field))});
}
return fields;
}
} // namespace
using Field = DescriptorPoolTypeIntrospector::Field;
absl::StatusOr<absl::optional<Type>>
DescriptorPoolTypeIntrospector::FindTypeImpl(absl::string_view name) const {
const google::protobuf::Descriptor* absl_nullable descriptor =
descriptor_pool_->FindMessageTypeByName(name);
if (descriptor != nullptr) {
return Type::Message(descriptor);
}
const google::protobuf::EnumDescriptor* absl_nullable enum_descriptor =
descriptor_pool_->FindEnumTypeByName(name);
if (enum_descriptor != nullptr) {
return Type::Enum(enum_descriptor);
}
return absl::nullopt;
}
absl::StatusOr<absl::optional<TypeIntrospector::EnumConstant>>
DescriptorPoolTypeIntrospector::FindEnumConstantImpl(
absl::string_view type, absl::string_view value) const {
const google::protobuf::EnumDescriptor* absl_nullable enum_descriptor =
descriptor_pool_->FindEnumTypeByName(type);
if (enum_descriptor != nullptr) {
const google::protobuf::EnumValueDescriptor* absl_nullable enum_value_descriptor =
enum_descriptor->FindValueByName(value);
if (enum_value_descriptor == nullptr) {
return absl::nullopt;
}
return EnumConstant{
.type = Type::Enum(enum_descriptor),
.type_full_name = enum_descriptor->full_name(),
.value_name = enum_value_descriptor->name(),
.number = enum_value_descriptor->number(),
};
}
return absl::nullopt;
}
absl::StatusOr<absl::optional<StructTypeField>>
DescriptorPoolTypeIntrospector::FindStructTypeFieldByNameImpl(
absl::string_view type, absl::string_view name) const {
if (!use_json_name_) {
return FindStructTypeFieldByNameDirectly(descriptor_pool_, type, name);
}
const FieldTable* field_table = GetFieldTable(type);
if (field_table == nullptr) {
return absl::nullopt;
}
if (auto it = field_table->json_name_map.find(name);
it != field_table->json_name_map.end()) {
return field_table->fields[it->second].field;
}
if (auto it = field_table->extension_name_map.find(name);
it != field_table->extension_name_map.end()) {
return field_table->fields[it->second].field;
}
return absl::nullopt;
}
absl::StatusOr<
absl::optional<std::vector<TypeIntrospector::StructTypeFieldListing>>>
DescriptorPoolTypeIntrospector::ListFieldsForStructTypeImpl(
absl::string_view type) const {
if (!use_json_name_) {
return ListStructTypeFieldsDirectly(descriptor_pool_, type);
}
const FieldTable* field_table = GetFieldTable(type);
if (field_table == nullptr) {
return absl::nullopt;
}
std::vector<TypeIntrospector::StructTypeFieldListing> fields;
fields.reserve(field_table->non_extensions.size());
for (const auto& field : field_table->non_extensions) {
fields.push_back({field.json_name, field.field});
}
return fields;
}
const DescriptorPoolTypeIntrospector::FieldTable*
DescriptorPoolTypeIntrospector::GetFieldTable(
absl::string_view type_name) const {
absl::MutexLock lock(mu_);
if (auto it = field_tables_.find(type_name); it != field_tables_.end()) {
return it->second.get();
}
if (cel::IsWellKnownMessageType(type_name)) {
return nullptr;
}
const google::protobuf::Descriptor* absl_nullable descriptor =
descriptor_pool_->FindMessageTypeByName(type_name);
if (descriptor == nullptr) {
return nullptr;
}
absl::string_view stable_type_name = descriptor->full_name();
ABSL_DCHECK(stable_type_name == type_name);
std::unique_ptr<FieldTable> field_table = CreateFieldTable(descriptor);
const FieldTable* field_table_ptr = field_table.get();
field_tables_[stable_type_name] = std::move(field_table);
return field_table_ptr;
}
std::unique_ptr<DescriptorPoolTypeIntrospector::FieldTable>
DescriptorPoolTypeIntrospector::CreateFieldTable(
const google::protobuf::Descriptor* absl_nonnull descriptor) const {
ABSL_DCHECK(!IsWellKnownMessageType(descriptor));
std::vector<Field> fields;
absl::flat_hash_map<absl::string_view, int> json_name_map;
absl::flat_hash_map<absl::string_view, int> field_name_map;
absl::flat_hash_map<absl::string_view, int> extension_name_map;
std::vector<const google::protobuf::FieldDescriptor*> extensions;
descriptor_pool_->FindAllExtensions(descriptor, &extensions);
fields.reserve(descriptor->field_count() + extensions.size());
for (int i = 0; i < descriptor->field_count(); i++) {
const google::protobuf::FieldDescriptor* field = descriptor->field(i);
fields.push_back(Field{
.field = StructTypeField(MessageTypeField(field)),
.json_name = field->json_name(),
.is_extension = false,
});
field_name_map[field->name()] = fields.size() - 1;
if (use_json_name_ && !field->json_name().empty()) {
json_name_map[field->json_name()] = fields.size() - 1;
}
}
int non_extension_count = fields.size();
for (const google::protobuf::FieldDescriptor* extension : extensions) {
fields.push_back(Field{
.field = StructTypeField(MessageTypeField(extension)),
.json_name = "",
.is_extension = true,
});
extension_name_map[extension->full_name()] = fields.size() - 1;
}
int extension_count = fields.size() - non_extension_count;
auto result = std::make_unique<FieldTable>();
result->descriptor = descriptor;
result->fields = std::move(fields);
result->non_extensions =
absl::MakeConstSpan(result->fields).subspan(0, non_extension_count);
result->extensions = absl::MakeConstSpan(result->fields)
.subspan(non_extension_count, extension_count);
result->json_name_map = std::move(json_name_map);
result->field_name_map = std::move(field_name_map);
result->extension_name_map = std::move(extension_name_map);
return result;
}
} // namespace cel::checker_internal
================================================
FILE: checker/internal/descriptor_pool_type_introspector.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_CHECKER_INTERNAL_DESCRIPTOR_POOL_TYPE_INTROSPECTOR_H_
#define THIRD_PARTY_CEL_CPP_CHECKER_INTERNAL_DESCRIPTOR_POOL_TYPE_INTROSPECTOR_H_
#include <memory>
#include <vector>
#include "absl/base/nullability.h"
#include "absl/base/thread_annotations.h"
#include "absl/container/flat_hash_map.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/synchronization/mutex.h"
#include "absl/types/optional.h"
#include "absl/types/span.h"
#include "common/type.h"
#include "common/type_introspector.h"
#include "google/protobuf/descriptor.h"
namespace cel::checker_internal {
// Implementation of `TypeIntrospector` that uses a `google::protobuf::DescriptorPool`.
//
// This is used by the type checker to resolve protobuf types and their fields
// and apply any options like using JSON names.
//
// Neither copyable nor movable. Should be managed by a TypeCheckEnv.
class DescriptorPoolTypeIntrospector : public TypeIntrospector {
public:
struct Field {
StructTypeField field;
absl::string_view json_name;
bool is_extension = false;
};
DescriptorPoolTypeIntrospector() = delete;
explicit DescriptorPoolTypeIntrospector(
const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool)
: descriptor_pool_(descriptor_pool) {}
DescriptorPoolTypeIntrospector(const DescriptorPoolTypeIntrospector&) =
delete;
DescriptorPoolTypeIntrospector& operator=(
const DescriptorPoolTypeIntrospector&) = delete;
DescriptorPoolTypeIntrospector(DescriptorPoolTypeIntrospector&&) = delete;
DescriptorPoolTypeIntrospector& operator=(DescriptorPoolTypeIntrospector&&) =
delete;
void set_use_json_name(bool use_json_name) { use_json_name_ = use_json_name; }
bool use_json_name() const { return use_json_name_; }
private:
struct FieldTable {
const google::protobuf::Descriptor* absl_nonnull descriptor;
std::vector<Field> fields;
absl::Span<const Field> non_extensions;
absl::Span<const Field> extensions;
absl::flat_hash_map<absl::string_view, int> json_name_map;
absl::flat_hash_map<absl::string_view, int> field_name_map;
absl::flat_hash_map<absl::string_view, int> extension_name_map;
};
absl::StatusOr<absl::optional<Type>> FindTypeImpl(
absl::string_view name) const final;
absl::StatusOr<absl::optional<EnumConstant>> FindEnumConstantImpl(
absl::string_view type, absl::string_view value) const final;
absl::StatusOr<absl::optional<StructTypeField>> FindStructTypeFieldByNameImpl(
absl::string_view type, absl::string_view name) const final;
absl::StatusOr<absl::optional<std::vector<StructTypeFieldListing>>>
ListFieldsForStructTypeImpl(absl::string_view type) const final;
std::unique_ptr<FieldTable> CreateFieldTable(
const google::protobuf::Descriptor* absl_nonnull descriptor) const;
const FieldTable* GetFieldTable(absl::string_view type_name) const;
// Cached map of type to field table.
mutable absl::flat_hash_map<absl::string_view, std::unique_ptr<FieldTable>>
field_tables_ ABSL_GUARDED_BY(mu_);
mutable absl::Mutex mu_;
bool use_json_name_ = false;
const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool_;
};
} // namespace cel::checker_internal
#endif // THIRD_PARTY_CEL_CPP_CHECKER_INTERNAL_DESCRIPTOR_POOL_TYPE_INTROSPECTOR_H_
================================================
FILE: checker/internal/descriptor_pool_type_introspector_test.cc
================================================
// 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.
#include "checker/internal/descriptor_pool_type_introspector.h"
#include <vector>
#include "absl/status/status_matchers.h"
#include "absl/status/statusor.h"
#include "absl/types/optional.h"
#include "common/type.h"
#include "common/type_introspector.h"
#include "internal/testing.h"
#include "internal/testing_descriptor_pool.h"
namespace cel::checker_internal {
namespace {
using ::absl_testing::IsOkAndHolds;
using ::testing::AllOf;
using ::testing::Contains;
using ::testing::Eq;
using ::testing::Not;
using ::testing::Optional;
using ::testing::Property;
using ::testing::SizeIs;
using ::testing::Truly;
TEST(DescriptorPoolTypeIntrospectorTest, FindType) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
EXPECT_THAT(introspector.FindType("cel.expr.conformance.proto3.TestAllTypes"),
IsOkAndHolds(Optional(Property(&Type::IsMessage, true))));
EXPECT_THAT(introspector.FindType(
"cel.expr.conformance.proto3.TestAllTypes.NestedEnum"),
IsOkAndHolds(Optional(Property(&Type::IsEnum, true))));
EXPECT_THAT(introspector.FindType("non.existent.Type"),
IsOkAndHolds(Eq(absl::nullopt)));
}
TEST(DescriptorPoolTypeIntrospectorTest, FindEnumConstant) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
auto result = introspector.FindEnumConstant(
"cel.expr.conformance.proto3.TestAllTypes.NestedEnum", "FOO");
ASSERT_THAT(result, IsOkAndHolds(Optional(AllOf(
Truly([](const TypeIntrospector::EnumConstant& v) {
return v.value_name == "FOO" && v.number == 0;
})))));
}
TEST(DescriptorPoolTypeIntrospectorTest, FindStructTypeFieldByName) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
auto field = introspector.FindStructTypeFieldByName(
"cel.expr.conformance.proto3.TestAllTypes", "single_int64");
introspector.set_use_json_name(false);
ASSERT_THAT(field,
IsOkAndHolds(Optional(Property(&StructTypeField::GetType,
Property(&Type::IsInt, true)))));
}
TEST(DescriptorPoolTypeIntrospectorTest,
FindStructTypeFieldByNameJsonNameIgnored) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
introspector.set_use_json_name(false);
auto field = introspector.FindStructTypeFieldByName(
"cel.expr.conformance.proto3.TestAllTypes", "singleInt64");
EXPECT_THAT(field, IsOkAndHolds(Eq(absl::nullopt)));
}
TEST(DescriptorPoolTypeIntrospectorTest, FindExtension) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
auto field = introspector.FindStructTypeFieldByName(
"cel.expr.conformance.proto2.TestAllTypes",
"cel.expr.conformance.proto2.int32_ext");
ASSERT_THAT(field,
IsOkAndHolds(Optional(Property(&StructTypeField::GetType,
Property(&Type::IsInt, true)))));
}
TEST(DescriptorPoolTypeIntrospectorTest, FindStructTypeFieldByNameWithJsonOpt) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
introspector.set_use_json_name(true);
auto field = introspector.FindStructTypeFieldByName(
"cel.expr.conformance.proto3.TestAllTypes", "single_int64");
ASSERT_THAT(field, IsOkAndHolds(Eq(absl::nullopt)));
}
TEST(DescriptorPoolTypeIntrospectorTest,
FindStructTypeFieldByNameWithJsonNameOpt) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
introspector.set_use_json_name(true);
absl::StatusOr<absl::optional<StructTypeField>> field =
introspector.FindStructTypeFieldByName(
"cel.expr.conformance.proto3.TestAllTypes", "singleInt64");
ASSERT_THAT(field,
IsOkAndHolds(Optional(Property(&StructTypeField::GetType,
Property(&Type::IsInt, true)))));
}
MATCHER_P(FieldListingIs, field_name, "") { return arg.name == field_name; }
TEST(DescriptorPoolTypeIntrospectorTest, ListFieldsForStructType) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
absl::StatusOr<
absl::optional<std::vector<TypeIntrospector::StructTypeFieldListing>>>
fields = introspector.ListFieldsForStructType(
"cel.expr.conformance.proto3.TestAllTypes");
ASSERT_THAT(fields, IsOkAndHolds(Optional(SizeIs(260))));
EXPECT_THAT(*fields, Optional(Contains(FieldListingIs("single_int64"))));
}
TEST(DescriptorPoolTypeIntrospectorTest, ListFieldsForStructTypeExtensions) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
auto fields = introspector.ListFieldsForStructType(
"cel.expr.conformance.proto2.TestAllTypes");
ASSERT_THAT(fields, IsOkAndHolds(Optional(SizeIs(259))));
EXPECT_THAT(**fields, Contains(FieldListingIs("single_int64")));
EXPECT_THAT(
**fields,
Not(Contains(FieldListingIs("cel.expr.conformance.proto2.int32_ext"))));
}
TEST(DescriptorPoolTypeIntrospectorTest,
ListFieldsForStructTypeWithJsonNameOpt) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
introspector.set_use_json_name(true);
auto fields = introspector.ListFieldsForStructType(
"cel.expr.conformance.proto3.TestAllTypes");
ASSERT_THAT(fields, IsOkAndHolds(Optional(SizeIs(260))));
EXPECT_THAT(**fields, Contains(FieldListingIs("singleInt64")));
EXPECT_THAT(**fields, Not(Contains(FieldListingIs("single_int64"))));
}
TEST(DescriptorPoolTypeIntrospectorTest, ListFieldsForStructTypeNotFound) {
DescriptorPoolTypeIntrospector introspector(
internal::GetTestingDescriptorPool());
auto fields = introspector.ListFieldsForStructType(
"cel.expr.conformance.proto3.SomeOtherType");
EXPECT_THAT(fields, IsOkAndHolds(Eq(absl::nullopt)));
}
} // namespace
} // namespace cel::checker_internal
================================================
FILE: checker/internal/format_type_name.cc
================================================
// 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.
#include "checker/internal/format_type_name.h"
#include <string>
#include <vector>
#include "absl/strings/str_cat.h"
#include "common/type.h"
#include "common/type_kind.h"
namespace cel::checker_internal {
namespace {
struct FormatImplRecord {
Type type;
int offset;
};
// Parameterized types can be arbitrarily nested, so we use a vector as
// a stack to avoid overflow. Practically, we don't expect nesting
// to ever be very deep, but fuzzers and pathological inputs can easily
// trigger stack overflow with a recursive implementation.
void FormatImpl(const Type& cur, int offset,
std::vector<FormatImplRecord>& stack, std::string* out) {
switch (cur.kind()) {
case TypeKind::kDyn:
absl::StrAppend(out, "dyn");
return;
case TypeKind::kAny:
absl::StrAppend(out, "any");
return;
case TypeKind::kBool:
absl::StrAppend(out, "bool");
return;
case TypeKind::kBoolWrapper:
absl::StrAppend(out, "wrapper(bool)");
return;
case TypeKind::kBytes:
absl::StrAppend(out, "bytes");
return;
case TypeKind::kBytesWrapper:
absl::StrAppend(out, "wrapper(bytes)");
return;
case TypeKind::kDouble:
absl::StrAppend(out, "double");
return;
case TypeKind::kDoubleWrapper:
absl::StrAppend(out, "wrapper(double)");
return;
case TypeKind::kDuration:
absl::StrAppend(out, "google.protobuf.Duration");
return;
case TypeKind::kEnum:
absl::StrAppend(out, "int");
return;
case TypeKind::kInt:
absl::StrAppend(out, "int");
return;
case TypeKind::kIntWrapper:
absl::StrAppend(out, "wrapper(int)");
return;
case TypeKind::kList:
if (offset == 0) {
absl::StrAppend(out, "list(");
stack.push_back({cur, 1});
stack.push_back({cur.AsList()->GetElement(), 0});
} else {
absl::StrAppend(out, ")");
}
return;
case TypeKind::kMap:
if (offset == 0) {
absl::StrAppend(out, "map(");
stack.push_back({cur, 1});
stack.push_back({cur.AsMap()->GetKey(), 0});
return;
}
if (offset == 1) {
absl::StrAppend(out, ", ");
stack.push_back({cur, 2});
stack.push_back({cur.AsMap()->GetValue(), 0});
return;
}
absl::StrAppend(out, ")");
return;
case TypeKind::kNull:
absl::StrAppend(out, "null_type");
return;
case TypeKind::kOpaque: {
OpaqueType opaque = *cur.AsOpaque();
if (offset == 0) {
absl::StrAppend(out, cur.AsOpaque()->name());
if (!opaque.GetParameters().empty()) {
absl::StrAppend(out, "(");
stack.push_back({cur, 1});
stack.push_back({cur.AsOpaque()->GetParameters()[0], 0});
}
return;
}
if (offset >= opaque.GetParameters().size()) {
absl::StrAppend(out, ")");
return;
}
absl::StrAppend(out, ", ");
stack.push_back({cur, offset + 1});
stack.push_back({cur.AsOpaque()->GetParameters()[offset], 0});
return;
}
case TypeKind::kString:
absl::StrAppend(out, "string");
return;
case TypeKind::kStringWrapper:
absl::StrAppend(out, "wrapper(string)");
return;
case TypeKind::kStruct:
absl::StrAppend(out, cur.AsStruct()->name());
return;
case TypeKind::kTimestamp:
absl::StrAppend(out, "google.protobuf.Timestamp");
return;
case TypeKind::kType: {
TypeType type_type = *cur.AsType();
if (offset == 0) {
absl::StrAppend(out, type_type.name());
if (!type_type.GetParameters().empty()) {
absl::StrAppend(out, "(");
stack.push_back({cur, 1});
stack.push_back({cur.AsType()->GetParameters()[0], 0});
}
return;
}
absl::StrAppend(out, ")");
return;
}
case TypeKind::kTypeParam:
absl::StrAppend(out, cur.AsTypeParam()->name());
return;
case TypeKind::kUint:
absl::StrAppend(out, "uint");
return;
case TypeKind::kUintWrapper:
absl::StrAppend(out, "wrapper(uint)");
return;
case TypeKind::kUnknown:
absl::StrAppend(out, "*unknown*");
return;
case TypeKind::kError:
case TypeKind::kFunction:
default:
absl::StrAppend(out, "*error*");
return;
}
}
} // namespace
std::string FormatTypeName(const Type& type) {
std::vector<FormatImplRecord> stack;
std::string out;
stack.push_back({type, 0});
while (!stack.empty()) {
auto [type, offset] = stack.back();
stack.pop_back();
FormatImpl(type, offset, stack, &out);
}
return out;
}
} // namespace cel::checker_internal
================================================
FILE: checker/internal/format_type_name.h
================================================
// 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.
#ifndef THIRD_PARTY_CEL_CPP_CHECKER_INTERNAL_FORMAT_TYPE_NAME_H_
#define THIRD_PARTY_CEL_CPP_CHECKER_INTERNAL_FORMAT_TYPE_NAME_H_
#include <string>
#include "common/type.h"
namespace cel::checker_internal {
// Format the type name for presentation in error messages. Matches the
// formatting used in github.com/cel-spec.
std::string FormatTypeName(const Type& type);
} // namespace cel::checker_internal
#endif // THIRD_PARTY_CEL_CPP_CHECKER_INTERNAL_FORMAT_TYPE_NAME_H_
================================================
FILE: checker/internal/format_type_name_test.cc
================================================
// 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.
#include "checker/internal/format_type_name.h"
#include "common/type.h"
#include "internal/testing.h"
#include "cel/expr/conformance/proto2/test_all_types.pb.h"
#include "google/protobuf/arena.h"
namespace cel::checker_internal {
namespace {
using ::cel::expr::conformance::proto2::GlobalEnum_descriptor;
using ::cel::expr::conformance::proto2::TestAllTypes;
using ::testing::MatchesRegex;
TEST(FormatTypeNameTest, PrimitiveTypes) {
EXPECT_EQ(FormatTypeName(IntType()), "int");
EXPECT_EQ(FormatTypeName(UintType()), "uint");
EXPECT_EQ(FormatTypeName(DoubleType()), "double");
EXPECT_EQ(FormatTypeName(StringType()), "string");
EXPECT_EQ(FormatTypeName(BytesType()), "bytes");
EXPECT_EQ(FormatTypeName(BoolType()), "bool");
EXPECT_EQ(FormatTypeName(NullType()), "null_type");
EXPECT_EQ(FormatTypeName(DynType()), "dyn");
}
TEST(FormatTypeNameTest, SpecialTypes) {
EXPECT_EQ(FormatTypeName(ErrorType()), "*error*");
EXPECT_EQ(FormatTypeName(UnknownType()), "*unknown*");
EXPECT_EQ(FormatTypeName(FunctionType()), "*error*");
}
TEST(FormatTypeNameTest, WellKnownTypes) {
EXPECT_EQ(FormatTypeName(AnyType()), "any");
EXPECT_EQ(FormatTypeName(DurationType()), "google.protobuf.Duration");
EXPECT_EQ(FormatTypeName(TimestampType()), "google.protobuf.Timestamp");
}
TEST(FormatTypeNameTest, Wrappers) {
EXPECT_EQ(FormatTypeName(IntWrapperType()), "wrapper(int)");
EXPECT_EQ(FormatTypeName(UintWrapperType()), "wrapper(uint)");
EXPECT_EQ(FormatTypeName(DoubleWrapperType()), "wrapper(double)");
EXPECT_EQ(FormatTypeName(StringWrapperType()), "wrapper(string)");
EXPECT_EQ(FormatTypeName(BytesWrapperType()), "wrapper(bytes)");
EXPECT_EQ(FormatTypeName(BoolWrapperType()), "wrapper(bool)");
}
TEST(FormatTypeNameTest, ProtobufTypes) {
EXPECT_EQ(FormatTypeName(MessageType(TestAllTypes::descriptor())),
"cel.expr.conformance.proto2.TestAllTypes");
EXPECT_EQ(FormatTypeName(EnumType(GlobalEnum_descriptor())), "int");
}
TEST(FormatTypeNameTest, Type) {
google::protobuf::Arena arena;
EXPECT_EQ(FormatTypeName(TypeType()), "type");
EXPECT_EQ(FormatTypeName(TypeType(&arena, IntType())), "type(int)");
EXPECT_EQ(FormatTypeName(TypeType(&arena, TypeType(&arena, IntType()))),
"type(type(int))");
EXPECT_EQ(FormatTypeName(TypeType(&arena, TypeParamType("T"))), "type(T)");
}
TEST(FormatTypeNameTest, List) {
google::protobuf::Arena arena;
EXPECT_EQ(FormatTypeName(ListType()), "list(dyn)");
EXPECT_EQ(FormatTypeName(ListType(&arena, IntType())), "list(int)");
EXPECT_EQ(FormatTypeName(ListType(&arena, ListType(&arena, IntType()))),
"list(list(int))");
}
TEST(FormatTypeNameTest, Map) {
google::protobuf::Arena arena;
EXPECT_EQ(FormatTypeName(MapType()), "map(dyn, dyn)");
EXPECT_EQ(FormatTypeName(MapType(&arena, IntType(), IntType())),
"map(int, int)");
EXPECT_EQ(FormatTypeName(MapType(&arena, IntType(),
MapType(&arena, IntType(), IntType()))),
"map(int, map(int, int))");
}
TEST(FormatTypeNameTest, Opaque) {
google::protobuf::Arena arena;
EXPECT_EQ(FormatTypeName(OpaqueType(&arena, "opaque", {})), "opaque");
Type two_tuple_type = OpaqueType(&arena, "tuple", {IntType(), IntType()});
Type three_tuple_type = OpaqueType(
&arena, "tuple", {two_tuple_type, two_tuple_type, two_tuple_type});
EXPECT_EQ(FormatTypeName(three_tuple_type),
"tuple(tuple(int, int), tuple(int, int), tuple(int, int))");
}
#ifndef __APPLE__
TEST(FormatTypeNameTest, ArbitraryNesting) {
google::protobuf::Arena arena;
Type type = IntType();
for (int i = 0; i < 1000; ++i) {
type = OpaqueType(&arena, "ptype", {type});
}
EXPECT_THAT(FormatTypeName(type),
MatchesRegex(R"(^(ptype\(){1000}int(\)){1000})"));
}
#endif
} // namespace
} // namespace cel::checker_internal
================================================
FILE: checker/internal/namespace_generator.cc
================================================
// 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.
#include "checker/internal/namespace_generator.h"
#include <algorithm>
#include <string>
#include <utility>
#include <vector>
#include "absl/functional/function_ref.h"
#include "absl/log/absl_check.h"
#include "absl/status/statusor.h"
#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
#include "common/container.h"
#include "internal/lexis.h"
namespace cel::checker_internal {
namespace {
bool FieldSelectInterpretationCandidatesImpl(
absl::string_view prefix,
absl::Span<const std::string> partly_qualified_name, bool prefix_is_alias,
absl::FunctionRef<bool(absl::string_view, int)> callback) {
for (int i = 0; i < partly_qualified_name.size(); ++i) {
std::string buf;
int count = partly_qualified_name.size() - i;
auto end_idx = count - (prefix_is_alias ? 0 : 1);
auto ident = absl::StrJoin(partly_qualified_name.subspan(0, count), ".");
absl::string_view candidate = ident;
if (absl::StartsWith(candidate, ".")) {
candidate = candidate.substr(1);
}
if (!prefix.empty()) {
buf = absl::StrCat(prefix, ".", candidate);
candidate = buf;
}
if (!callback(candidate, end_idx)) {
return false;
}
}
if (prefix_is_alias) {
return callback(prefix, 0);
}
return true;
}
bool FieldSelectInterpretationCandidates(
absl::string_view prefix,
absl::Span<const std::string> partly_qualified_name,
absl::FunctionRef<bool(absl::string_view, int)> callback) {
return FieldSelectInterpretationCandidatesImpl(
prefix, partly_qualified_name, /*prefix_is_alias=*/false, callback);
}
bool FieldSelectInterpretationCandidatesWithAlias(
absl::string_view prefix,
absl::Span<const std::string> partly_qualified_name,
absl::FunctionRef<bool(absl::string_view, int)> callback) {
return FieldSelectInterpretationCandidatesImpl(
prefix, partly_qualified_name, /*prefix_is_alias=*/true, callback);
}
} // namespace
absl::StatusOr<NamespaceGenerator> NamespaceGenerator::Create(
const ExpressionContainer& expression_container) {
std::vector<std::string> candidates;
absl::string_view container = expression_container.container();
if (container.empty()) {
return NamespaceGenerator(&expression_container, std::move(candidates));
}
std::string prefix;
for (auto segment : absl::StrSplit(container, '.')) {
// Assumes the the ExpressionContainer ha
gitextract_qb36pkd3/
├── .bazelrc
├── .bazelversion
├── .bcr/
│ ├── README.md
│ ├── metadata.template.json
│ ├── presubmit.yml
│ └── source.template.json
├── .github/
│ └── workflows/
│ └── publish_to_bcr.yml
├── .gitignore
├── BUILD.bazel
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Dockerfile
├── LICENSE
├── MODULE.bazel
├── README.md
├── base/
│ ├── BUILD
│ ├── ast.h
│ ├── attribute.cc
│ ├── attribute.h
│ ├── attribute_set.h
│ ├── builtins.h
│ ├── function.h
│ ├── function_adapter.h
│ ├── function_descriptor.h
│ ├── function_result.h
│ ├── function_result_set.cc
│ ├── function_result_set.h
│ ├── internal/
│ │ ├── BUILD
│ │ ├── memory_manager_testing.cc
│ │ ├── memory_manager_testing.h
│ │ ├── message_wrapper.h
│ │ ├── operators.h
│ │ ├── unknown_set.cc
│ │ └── unknown_set.h
│ ├── kind.h
│ ├── operators.cc
│ ├── operators.h
│ ├── operators_test.cc
│ └── type_provider.h
├── bazel/
│ ├── BUILD
│ ├── antlr.bzl
│ ├── antlr.patch
│ ├── cat_param_file.cc
│ ├── cel_cc_embed.bzl
│ ├── cel_cc_embed.cc
│ ├── cel_proto_transitive_descriptor_set.bzl
│ └── deps.bzl
├── checker/
│ ├── BUILD
│ ├── checker_options.h
│ ├── internal/
│ │ ├── BUILD
│ │ ├── builtins_arena.cc
│ │ ├── builtins_arena.h
│ │ ├── descriptor_pool_type_introspector.cc
│ │ ├── descriptor_pool_type_introspector.h
│ │ ├── descriptor_pool_type_introspector_test.cc
│ │ ├── format_type_name.cc
│ │ ├── format_type_name.h
│ │ ├── format_type_name_test.cc
│ │ ├── namespace_generator.cc
│ │ ├── namespace_generator.h
│ │ ├── namespace_generator_test.cc
│ │ ├── test_ast_helpers.cc
│ │ ├── test_ast_helpers.h
│ │ ├── test_ast_helpers_test.cc
│ │ ├── type_check_env.cc
│ │ ├── type_check_env.h
│ │ ├── type_checker_builder_impl.cc
│ │ ├── type_checker_builder_impl.h
│ │ ├── type_checker_builder_impl_test.cc
│ │ ├── type_checker_impl.cc
│ │ ├── type_checker_impl.h
│ │ ├── type_checker_impl_test.cc
│ │ ├── type_inference_context.cc
│ │ ├── type_inference_context.h
│ │ └── type_inference_context_test.cc
│ ├── optional.cc
│ ├── optional.h
│ ├── optional_test.cc
│ ├── standard_library.cc
│ ├── standard_library.h
│ ├── standard_library_test.cc
│ ├── type_check_issue.cc
│ ├── type_check_issue.h
│ ├── type_check_issue_test.cc
│ ├── type_checker.cc
│ ├── type_checker.h
│ ├── type_checker_builder.h
│ ├── type_checker_builder_factory.cc
│ ├── type_checker_builder_factory.h
│ ├── type_checker_builder_factory_test.cc
│ ├── type_checker_subset_factory.cc
│ ├── type_checker_subset_factory.h
│ ├── type_checker_subset_factory_test.cc
│ ├── validation_result.cc
│ ├── validation_result.h
│ └── validation_result_test.cc
├── cloudbuild.yaml
├── codelab/
│ ├── BUILD
│ ├── Dockerfile
│ ├── README.md
│ ├── cel_compiler.h
│ ├── cel_compiler_test.cc
│ ├── exercise1.cc
│ ├── exercise1.h
│ ├── exercise10.cc
│ ├── exercise10.h
│ ├── exercise10_test.cc
│ ├── exercise1_test.cc
│ ├── exercise2.cc
│ ├── exercise2.h
│ ├── exercise2_test.cc
│ ├── exercise3_test.cc
│ ├── exercise4.cc
│ ├── exercise4.h
│ ├── exercise4_test.cc
│ ├── network_functions.cc
│ ├── network_functions.h
│ ├── network_functions_test.cc
│ └── solutions/
│ ├── BUILD
│ ├── exercise1.cc
│ ├── exercise10.cc
│ ├── exercise2.cc
│ ├── exercise3_test.cc
│ └── exercise4.cc
├── common/
│ ├── BUILD
│ ├── allocator.h
│ ├── allocator_test.cc
│ ├── any.cc
│ ├── any.h
│ ├── any_test.cc
│ ├── arena.h
│ ├── arena_string.h
│ ├── arena_string_pool.h
│ ├── arena_string_pool_test.cc
│ ├── arena_string_test.cc
│ ├── arena_string_view.h
│ ├── arena_string_view_test.cc
│ ├── ast/
│ │ ├── BUILD
│ │ ├── constant_proto.cc
│ │ ├── constant_proto.h
│ │ ├── expr_proto.cc
│ │ ├── expr_proto.h
│ │ ├── expr_proto_test.cc
│ │ ├── metadata.cc
│ │ ├── metadata.h
│ │ ├── metadata_test.cc
│ │ ├── navigable_ast_internal.h
│ │ ├── navigable_ast_internal_test.cc
│ │ ├── navigable_ast_kinds.cc
│ │ ├── navigable_ast_kinds.h
│ │ ├── source_info_proto.cc
│ │ └── source_info_proto.h
│ ├── ast.cc
│ ├── ast.h
│ ├── ast_proto.cc
│ ├── ast_proto.h
│ ├── ast_proto_test.cc
│ ├── ast_rewrite.cc
│ ├── ast_rewrite.h
│ ├── ast_rewrite_test.cc
│ ├── ast_test.cc
│ ├── ast_traverse.cc
│ ├── ast_traverse.h
│ ├── ast_traverse_test.cc
│ ├── ast_visitor.h
│ ├── ast_visitor_base.h
│ ├── casting.h
│ ├── constant.cc
│ ├── constant.h
│ ├── constant_test.cc
│ ├── container.cc
│ ├── container.h
│ ├── container_test.cc
│ ├── data.h
│ ├── data_test.cc
│ ├── decl.cc
│ ├── decl.h
│ ├── decl_proto.cc
│ ├── decl_proto.h
│ ├── decl_proto_test.cc
│ ├── decl_proto_v1alpha1.cc
│ ├── decl_proto_v1alpha1.h
│ ├── decl_test.cc
│ ├── expr.cc
│ ├── expr.h
│ ├── expr_factory.h
│ ├── expr_test.cc
│ ├── function_descriptor.cc
│ ├── function_descriptor.h
│ ├── internal/
│ │ ├── BUILD
│ │ ├── byte_string.cc
│ │ ├── byte_string.h
│ │ ├── byte_string_test.cc
│ │ ├── casting.h
│ │ ├── metadata.h
│ │ ├── reference_count.cc
│ │ ├── reference_count.h
│ │ ├── reference_count_test.cc
│ │ ├── signature.cc
│ │ ├── signature.h
│ │ ├── signature_test.cc
│ │ ├── value_conversion.cc
│ │ └── value_conversion.h
│ ├── json.h
│ ├── kind.cc
│ ├── kind.h
│ ├── kind_test.cc
│ ├── legacy_value.cc
│ ├── legacy_value.h
│ ├── memory.cc
│ ├── memory.h
│ ├── memory_test.cc
│ ├── memory_testing.h
│ ├── minimal_descriptor_database.cc
│ ├── minimal_descriptor_database.h
│ ├── minimal_descriptor_database_test.cc
│ ├── minimal_descriptor_pool.cc
│ ├── minimal_descriptor_pool.h
│ ├── minimal_descriptor_pool_test.cc
│ ├── native_type.h
│ ├── navigable_ast.cc
│ ├── navigable_ast.h
│ ├── navigable_ast_test.cc
│ ├── operators.cc
│ ├── operators.h
│ ├── optional_ref.h
│ ├── reference.cc
│ ├── reference.h
│ ├── reference_count.h
│ ├── reference_test.cc
│ ├── source.cc
│ ├── source.h
│ ├── source_test.cc
│ ├── standard_definitions.h
│ ├── type.cc
│ ├── type.h
│ ├── type_introspector.cc
│ ├── type_introspector.h
│ ├── type_kind.h
│ ├── type_proto.cc
│ ├── type_proto.h
│ ├── type_proto_test.cc
│ ├── type_reflector.h
│ ├── type_reflector_test.cc
│ ├── type_test.cc
│ ├── type_testing.h
│ ├── typeinfo.cc
│ ├── typeinfo.h
│ ├── typeinfo_test.cc
│ ├── types/
│ │ ├── any_type.h
│ │ ├── any_type_test.cc
│ │ ├── basic_struct_type.cc
│ │ ├── basic_struct_type.h
│ │ ├── basic_struct_type_test.cc
│ │ ├── bool_type.h
│ │ ├── bool_type_test.cc
│ │ ├── bool_wrapper_type.h
│ │ ├── bool_wrapper_type_test.cc
│ │ ├── bytes_type.h
│ │ ├── bytes_type_test.cc
│ │ ├── bytes_wrapper_type.h
│ │ ├── bytes_wrapper_type_test.cc
│ │ ├── double_type.h
│ │ ├── double_type_test.cc
│ │ ├── double_wrapper_type.h
│ │ ├── double_wrapper_type_test.cc
│ │ ├── duration_type.h
│ │ ├── duration_type_test.cc
│ │ ├── dyn_type.h
│ │ ├── dyn_type_test.cc
│ │ ├── enum_type.cc
│ │ ├── enum_type.h
│ │ ├── enum_type_test.cc
│ │ ├── error_type.h
│ │ ├── error_type_test.cc
│ │ ├── function_type.cc
│ │ ├── function_type.h
│ │ ├── function_type_pool.cc
│ │ ├── function_type_pool.h
│ │ ├── function_type_test.cc
│ │ ├── int_type.h
│ │ ├── int_type_test.cc
│ │ ├── int_wrapper_type.h
│ │ ├── int_wrapper_type_test.cc
│ │ ├── legacy_type_introspector.h
│ │ ├── list_type.cc
│ │ ├── list_type.h
│ │ ├── list_type_pool.cc
│ │ ├── list_type_pool.h
│ │ ├── list_type_test.cc
│ │ ├── map_type.cc
│ │ ├── map_type.h
│ │ ├── map_type_pool.cc
│ │ ├── map_type_pool.h
│ │ ├── map_type_test.cc
│ │ ├── message_type.cc
│ │ ├── message_type.h
│ │ ├── message_type_test.cc
│ │ ├── null_type.h
│ │ ├── null_type_test.cc
│ │ ├── opaque_type.cc
│ │ ├── opaque_type.h
│ │ ├── opaque_type_pool.cc
│ │ ├── opaque_type_pool.h
│ │ ├── opaque_type_test.cc
│ │ ├── optional_type.cc
│ │ ├── optional_type.h
│ │ ├── optional_type_test.cc
│ │ ├── string_type.h
│ │ ├── string_type_test.cc
│ │ ├── string_wrapper_type.h
│ │ ├── string_wrapper_type_test.cc
│ │ ├── struct_type.cc
│ │ ├── struct_type.h
│ │ ├── struct_type_test.cc
│ │ ├── timestamp_type.h
│ │ ├── timestamp_type_test.cc
│ │ ├── type_param_type.h
│ │ ├── type_param_type_test.cc
│ │ ├── type_pool.cc
│ │ ├── type_pool.h
│ │ ├── type_pool_test.cc
│ │ ├── type_type.cc
│ │ ├── type_type.h
│ │ ├── type_type_pool.cc
│ │ ├── type_type_pool.h
│ │ ├── type_type_test.cc
│ │ ├── types.h
│ │ ├── uint_type.h
│ │ ├── uint_type_test.cc
│ │ ├── uint_wrapper_type.h
│ │ ├── uint_wrapper_type_test.cc
│ │ ├── unknown_type.h
│ │ └── unknown_type_test.cc
│ ├── unknown.h
│ ├── value.cc
│ ├── value.h
│ ├── value_kind.h
│ ├── value_test.cc
│ ├── value_testing.cc
│ ├── value_testing.h
│ ├── value_testing_test.cc
│ └── values/
│ ├── bool_value.cc
│ ├── bool_value.h
│ ├── bool_value_test.cc
│ ├── bytes_value.cc
│ ├── bytes_value.h
│ ├── bytes_value_input_stream.h
│ ├── bytes_value_output_stream.h
│ ├── bytes_value_test.cc
│ ├── custom_list_value.cc
│ ├── custom_list_value.h
│ ├── custom_list_value_test.cc
│ ├── custom_map_value.cc
│ ├── custom_map_value.h
│ ├── custom_map_value_test.cc
│ ├── custom_struct_value.cc
│ ├── custom_struct_value.h
│ ├── custom_struct_value_test.cc
│ ├── custom_value.h
│ ├── double_value.cc
│ ├── double_value.h
│ ├── double_value_test.cc
│ ├── duration_value.cc
│ ├── duration_value.h
│ ├── duration_value_test.cc
│ ├── enum_value.h
│ ├── error_value.cc
│ ├── error_value.h
│ ├── error_value_test.cc
│ ├── int_value.cc
│ ├── int_value.h
│ ├── int_value_test.cc
│ ├── legacy_list_value.cc
│ ├── legacy_list_value.h
│ ├── legacy_map_value.cc
│ ├── legacy_map_value.h
│ ├── legacy_struct_value.cc
│ ├── legacy_struct_value.h
│ ├── list_value.cc
│ ├── list_value.h
│ ├── list_value_builder.h
│ ├── list_value_test.cc
│ ├── list_value_variant.h
│ ├── map_value.cc
│ ├── map_value.h
│ ├── map_value_builder.h
│ ├── map_value_test.cc
│ ├── map_value_variant.h
│ ├── message_value.cc
│ ├── message_value.h
│ ├── message_value_test.cc
│ ├── mutable_list_value_test.cc
│ ├── mutable_map_value_test.cc
│ ├── null_value.cc
│ ├── null_value.h
│ ├── null_value_test.cc
│ ├── opaque_value.cc
│ ├── opaque_value.h
│ ├── optional_value.cc
│ ├── optional_value.h
│ ├── optional_value_test.cc
│ ├── parsed_json_list_value.cc
│ ├── parsed_json_list_value.h
│ ├── parsed_json_list_value_test.cc
│ ├── parsed_json_map_value.cc
│ ├── parsed_json_map_value.h
│ ├── parsed_json_map_value_test.cc
│ ├── parsed_json_value.cc
│ ├── parsed_json_value.h
│ ├── parsed_json_value_test.cc
│ ├── parsed_map_field_value.cc
│ ├── parsed_map_field_value.h
│ ├── parsed_map_field_value_test.cc
│ ├── parsed_message_value.cc
│ ├── parsed_message_value.h
│ ├── parsed_message_value_test.cc
│ ├── parsed_repeated_field_value.cc
│ ├── parsed_repeated_field_value.h
│ ├── parsed_repeated_field_value_test.cc
│ ├── string_value.cc
│ ├── string_value.h
│ ├── string_value_test.cc
│ ├── struct_value.cc
│ ├── struct_value.h
│ ├── struct_value_builder.cc
│ ├── struct_value_builder.h
│ ├── struct_value_test.cc
│ ├── struct_value_variant.h
│ ├── timestamp_value.cc
│ ├── timestamp_value.h
│ ├── timestamp_value_test.cc
│ ├── type_value.cc
│ ├── type_value.h
│ ├── type_value_test.cc
│ ├── uint_value.cc
│ ├── uint_value.h
│ ├── uint_value_test.cc
│ ├── unknown_value.cc
│ ├── unknown_value.h
│ ├── unknown_value_test.cc
│ ├── value_builder.cc
│ ├── value_builder.h
│ ├── value_variant.cc
│ ├── value_variant.h
│ ├── value_variant_test.cc
│ └── values.h
├── compiler/
│ ├── BUILD
│ ├── compiler.h
│ ├── compiler_factory.cc
│ ├── compiler_factory.h
│ ├── compiler_factory_test.cc
│ ├── compiler_library_subset_factory.cc
│ ├── compiler_library_subset_factory.h
│ ├── compiler_library_subset_factory_test.cc
│ ├── optional.cc
│ ├── optional.h
│ ├── optional_test.cc
│ ├── standard_library.cc
│ └── standard_library.h
├── conformance/
│ ├── BUILD
│ ├── run.bzl
│ ├── run.cc
│ ├── service.cc
│ ├── service.h
│ └── utils.h
├── env/
│ ├── BUILD
│ ├── config.cc
│ ├── config.h
│ ├── config_test.cc
│ ├── env.cc
│ ├── env.h
│ ├── env_runtime.cc
│ ├── env_runtime.h
│ ├── env_runtime_test.cc
│ ├── env_std_extensions.cc
│ ├── env_std_extensions.h
│ ├── env_std_extensions_test.cc
│ ├── env_test.cc
│ ├── env_yaml.cc
│ ├── env_yaml.h
│ ├── env_yaml_test.cc
│ ├── internal/
│ │ ├── BUILD
│ │ ├── ext_registry.cc
│ │ ├── ext_registry.h
│ │ ├── ext_registry_test.cc
│ │ ├── runtime_ext_registry.cc
│ │ ├── runtime_ext_registry.h
│ │ └── runtime_ext_registry_test.cc
│ ├── runtime_std_extensions.cc
│ ├── runtime_std_extensions.h
│ ├── runtime_std_extensions_test.cc
│ ├── type_info.cc
│ ├── type_info.h
│ └── type_info_test.cc
├── eval/
│ ├── BUILD
│ ├── LICENSE
│ ├── README.md
│ ├── compiler/
│ │ ├── BUILD
│ │ ├── LICENSE
│ │ ├── cel_expression_builder_flat_impl.cc
│ │ ├── cel_expression_builder_flat_impl.h
│ │ ├── cel_expression_builder_flat_impl_test.cc
│ │ ├── check_ast_extensions.cc
│ │ ├── check_ast_extensions.h
│ │ ├── check_ast_extensions_test.cc
│ │ ├── comprehension_vulnerability_check.cc
│ │ ├── comprehension_vulnerability_check.h
│ │ ├── constant_folding.cc
│ │ ├── constant_folding.h
│ │ ├── constant_folding_test.cc
│ │ ├── flat_expr_builder.cc
│ │ ├── flat_expr_builder.h
│ │ ├── flat_expr_builder_comprehensions_test.cc
│ │ ├── flat_expr_builder_extensions.cc
│ │ ├── flat_expr_builder_extensions.h
│ │ ├── flat_expr_builder_extensions_test.cc
│ │ ├── flat_expr_builder_short_circuiting_conformance_test.cc
│ │ ├── flat_expr_builder_test.cc
│ │ ├── instrumentation.cc
│ │ ├── instrumentation.h
│ │ ├── instrumentation_test.cc
│ │ ├── qualified_reference_resolver.cc
│ │ ├── qualified_reference_resolver.h
│ │ ├── qualified_reference_resolver_test.cc
│ │ ├── regex_precompilation_optimization.cc
│ │ ├── regex_precompilation_optimization.h
│ │ ├── regex_precompilation_optimization_test.cc
│ │ ├── resolver.cc
│ │ ├── resolver.h
│ │ └── resolver_test.cc
│ ├── eval/
│ │ ├── BUILD
│ │ ├── LICENSE
│ │ ├── attribute_trail.cc
│ │ ├── attribute_trail.h
│ │ ├── attribute_trail_test.cc
│ │ ├── attribute_utility.cc
│ │ ├── attribute_utility.h
│ │ ├── attribute_utility_test.cc
│ │ ├── cel_expression_flat_impl.cc
│ │ ├── cel_expression_flat_impl.h
│ │ ├── compiler_constant_step.cc
│ │ ├── compiler_constant_step.h
│ │ ├── compiler_constant_step_test.cc
│ │ ├── comprehension_slots.h
│ │ ├── comprehension_slots_test.cc
│ │ ├── comprehension_step.cc
│ │ ├── comprehension_step.h
│ │ ├── comprehension_step_test.cc
│ │ ├── const_value_step.h
│ │ ├── container_access_step.cc
│ │ ├── container_access_step.h
│ │ ├── container_access_step_test.cc
│ │ ├── create_list_step.cc
│ │ ├── create_list_step.h
│ │ ├── create_list_step_test.cc
│ │ ├── create_map_step.cc
│ │ ├── create_map_step.h
│ │ ├── create_map_step_test.cc
│ │ ├── create_struct_step.cc
│ │ ├── create_struct_step.h
│ │ ├── create_struct_step_test.cc
│ │ ├── direct_expression_step.cc
│ │ ├── direct_expression_step.h
│ │ ├── equality_steps.cc
│ │ ├── equality_steps.h
│ │ ├── equality_steps_test.cc
│ │ ├── evaluator_core.cc
│ │ ├── evaluator_core.h
│ │ ├── evaluator_core_test.cc
│ │ ├── evaluator_stack.cc
│ │ ├── evaluator_stack.h
│ │ ├── evaluator_stack_test.cc
│ │ ├── expression_step_base.h
│ │ ├── function_step.cc
│ │ ├── function_step.h
│ │ ├── function_step_test.cc
│ │ ├── ident_step.cc
│ │ ├── ident_step.h
│ │ ├── ident_step_test.cc
│ │ ├── iterator_stack.h
│ │ ├── jump_step.cc
│ │ ├── jump_step.h
│ │ ├── lazy_init_step.cc
│ │ ├── lazy_init_step.h
│ │ ├── lazy_init_step_test.cc
│ │ ├── logic_step.cc
│ │ ├── logic_step.h
│ │ ├── logic_step_test.cc
│ │ ├── optional_or_step.cc
│ │ ├── optional_or_step.h
│ │ ├── optional_or_step_test.cc
│ │ ├── regex_match_step.cc
│ │ ├── regex_match_step.h
│ │ ├── regex_match_step_test.cc
│ │ ├── select_step.cc
│ │ ├── select_step.h
│ │ ├── select_step_test.cc
│ │ ├── shadowable_value_step.cc
│ │ ├── shadowable_value_step.h
│ │ ├── shadowable_value_step_test.cc
│ │ ├── ternary_step.cc
│ │ ├── ternary_step.h
│ │ ├── ternary_step_test.cc
│ │ └── trace_step.h
│ ├── internal/
│ │ ├── BUILD
│ │ ├── adapter_activation_impl.cc
│ │ ├── adapter_activation_impl.h
│ │ ├── cel_value_equal.cc
│ │ ├── cel_value_equal.h
│ │ ├── cel_value_equal_test.cc
│ │ ├── errors.cc
│ │ ├── errors.h
│ │ └── interop.h
│ ├── public/
│ │ ├── BUILD
│ │ ├── LICENSE
│ │ ├── activation.cc
│ │ ├── activation.h
│ │ ├── activation_bind_helper.cc
│ │ ├── activation_bind_helper.h
│ │ ├── activation_bind_helper_test.cc
│ │ ├── activation_test.cc
│ │ ├── ast_rewrite.cc
│ │ ├── ast_rewrite.h
│ │ ├── ast_rewrite_test.cc
│ │ ├── ast_traverse.cc
│ │ ├── ast_traverse.h
│ │ ├── ast_traverse_test.cc
│ │ ├── ast_visitor.h
│ │ ├── ast_visitor_base.h
│ │ ├── base_activation.h
│ │ ├── builtin_func_registrar.cc
│ │ ├── builtin_func_registrar.h
│ │ ├── builtin_func_registrar_test.cc
│ │ ├── builtin_func_test.cc
│ │ ├── cel_attribute.cc
│ │ ├── cel_attribute.h
│ │ ├── cel_attribute_test.cc
│ │ ├── cel_builtins.h
│ │ ├── cel_expr_builder_factory.cc
│ │ ├── cel_expr_builder_factory.h
│ │ ├── cel_expression.h
│ │ ├── cel_function.cc
│ │ ├── cel_function.h
│ │ ├── cel_function_adapter.h
│ │ ├── cel_function_adapter_impl.h
│ │ ├── cel_function_adapter_test.cc
│ │ ├── cel_function_registry.cc
│ │ ├── cel_function_registry.h
│ │ ├── cel_function_registry_test.cc
│ │ ├── cel_number.cc
│ │ ├── cel_number.h
│ │ ├── cel_number_test.cc
│ │ ├── cel_options.cc
│ │ ├── cel_options.h
│ │ ├── cel_type_registry.cc
│ │ ├── cel_type_registry.h
│ │ ├── cel_type_registry_protobuf_reflection_test.cc
│ │ ├── cel_type_registry_test.cc
│ │ ├── cel_value.cc
│ │ ├── cel_value.h
│ │ ├── cel_value_internal.h
│ │ ├── cel_value_producer.h
│ │ ├── cel_value_test.cc
│ │ ├── comparison_functions.cc
│ │ ├── comparison_functions.h
│ │ ├── comparison_functions_test.cc
│ │ ├── container_function_registrar.cc
│ │ ├── container_function_registrar.h
│ │ ├── container_function_registrar_test.cc
│ │ ├── containers/
│ │ │ ├── BUILD
│ │ │ ├── container_backed_list_impl.h
│ │ │ ├── container_backed_map_impl.cc
│ │ │ ├── container_backed_map_impl.h
│ │ │ ├── container_backed_map_impl_test.cc
│ │ │ ├── field_access.cc
│ │ │ ├── field_access.h
│ │ │ ├── field_access_test.cc
│ │ │ ├── field_backed_list_impl.h
│ │ │ ├── field_backed_list_impl_test.cc
│ │ │ ├── field_backed_map_impl.h
│ │ │ ├── field_backed_map_impl_test.cc
│ │ │ ├── internal_field_backed_list_impl.cc
│ │ │ ├── internal_field_backed_list_impl.h
│ │ │ ├── internal_field_backed_list_impl_test.cc
│ │ │ ├── internal_field_backed_map_impl.cc
│ │ │ ├── internal_field_backed_map_impl.h
│ │ │ └── internal_field_backed_map_impl_test.cc
│ │ ├── equality_function_registrar.cc
│ │ ├── equality_function_registrar.h
│ │ ├── equality_function_registrar_test.cc
│ │ ├── extension_func_registrar.cc
│ │ ├── extension_func_registrar.h
│ │ ├── extension_func_test.cc
│ │ ├── logical_function_registrar.cc
│ │ ├── logical_function_registrar.h
│ │ ├── logical_function_registrar_test.cc
│ │ ├── message_wrapper.h
│ │ ├── message_wrapper_test.cc
│ │ ├── portable_cel_function_adapter.h
│ │ ├── set_util.cc
│ │ ├── set_util.h
│ │ ├── set_util_test.cc
│ │ ├── source_position.cc
│ │ ├── source_position.h
│ │ ├── source_position_test.cc
│ │ ├── string_extension_func_registrar.cc
│ │ ├── string_extension_func_registrar.h
│ │ ├── string_extension_func_registrar_test.cc
│ │ ├── structs/
│ │ │ ├── BUILD
│ │ │ ├── cel_proto_descriptor_pool_builder.cc
│ │ │ ├── cel_proto_descriptor_pool_builder.h
│ │ │ ├── cel_proto_descriptor_pool_builder_test.cc
│ │ │ ├── cel_proto_wrap_util.cc
│ │ │ ├── cel_proto_wrap_util.h
│ │ │ ├── cel_proto_wrap_util_test.cc
│ │ │ ├── cel_proto_wrapper.cc
│ │ │ ├── cel_proto_wrapper.h
│ │ │ ├── cel_proto_wrapper_test.cc
│ │ │ ├── dynamic_descriptor_pool_end_to_end_test.cc
│ │ │ ├── field_access_impl.cc
│ │ │ ├── field_access_impl.h
│ │ │ ├── field_access_impl_test.cc
│ │ │ ├── legacy_type_adapter.h
│ │ │ ├── legacy_type_adapter_test.cc
│ │ │ ├── legacy_type_info_apis.h
│ │ │ ├── legacy_type_provider.cc
│ │ │ ├── legacy_type_provider.h
│ │ │ ├── legacy_type_provider_test.cc
│ │ │ ├── proto_message_type_adapter.cc
│ │ │ ├── proto_message_type_adapter.h
│ │ │ ├── proto_message_type_adapter_test.cc
│ │ │ ├── protobuf_descriptor_type_provider.cc
│ │ │ ├── protobuf_descriptor_type_provider.h
│ │ │ ├── protobuf_descriptor_type_provider_test.cc
│ │ │ ├── protobuf_value_factory.h
│ │ │ ├── trivial_legacy_type_info.h
│ │ │ └── trivial_legacy_type_info_test.cc
│ │ ├── testing/
│ │ │ ├── BUILD
│ │ │ ├── matchers.cc
│ │ │ ├── matchers.h
│ │ │ └── matchers_test.cc
│ │ ├── transform_utility.cc
│ │ ├── transform_utility.h
│ │ ├── unknown_attribute_set.h
│ │ ├── unknown_attribute_set_test.cc
│ │ ├── unknown_function_result_set.cc
│ │ ├── unknown_function_result_set.h
│ │ ├── unknown_function_result_set_test.cc
│ │ ├── unknown_set.h
│ │ ├── unknown_set_test.cc
│ │ ├── value_export_util.cc
│ │ ├── value_export_util.h
│ │ └── value_export_util_test.cc
│ ├── tests/
│ │ ├── BUILD
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── allocation_benchmark_test.cc
│ │ ├── benchmark_test.cc
│ │ ├── end_to_end_test.cc
│ │ ├── expression_builder_benchmark_test.cc
│ │ ├── memory_safety_test.cc
│ │ ├── mock_cel_expression.h
│ │ ├── modern_benchmark_test.cc
│ │ ├── request_context.proto
│ │ └── unknowns_end_to_end_test.cc
│ └── testutil/
│ ├── BUILD
│ ├── test_extensions.proto
│ └── test_message.proto
├── extensions/
│ ├── BUILD
│ ├── bindings_ext.cc
│ ├── bindings_ext.h
│ ├── bindings_ext_benchmark_test.cc
│ ├── bindings_ext_test.cc
│ ├── comprehensions_v2.cc
│ ├── comprehensions_v2.h
│ ├── comprehensions_v2_functions.cc
│ ├── comprehensions_v2_functions.h
│ ├── comprehensions_v2_macros.cc
│ ├── comprehensions_v2_macros.h
│ ├── comprehensions_v2_test.cc
│ ├── encoders.cc
│ ├── encoders.h
│ ├── encoders_test.cc
│ ├── formatting.cc
│ ├── formatting.h
│ ├── formatting_test.cc
│ ├── lists_functions.cc
│ ├── lists_functions.h
│ ├── lists_functions_test.cc
│ ├── math_ext.cc
│ ├── math_ext.h
│ ├── math_ext_decls.cc
│ ├── math_ext_decls.h
│ ├── math_ext_macros.cc
│ ├── math_ext_macros.h
│ ├── math_ext_test.cc
│ ├── proto_ext.cc
│ ├── proto_ext.h
│ ├── protobuf/
│ │ ├── BUILD
│ │ ├── ast_converters.h
│ │ ├── bind_proto_to_activation.cc
│ │ ├── bind_proto_to_activation.h
│ │ ├── bind_proto_to_activation_test.cc
│ │ ├── enum_adapter.cc
│ │ ├── enum_adapter.h
│ │ ├── internal/
│ │ │ ├── BUILD
│ │ │ ├── map_reflection.cc
│ │ │ ├── map_reflection.h
│ │ │ ├── qualify.cc
│ │ │ └── qualify.h
│ │ ├── memory_manager.cc
│ │ ├── memory_manager.h
│ │ ├── memory_manager_test.cc
│ │ ├── runtime_adapter.cc
│ │ ├── runtime_adapter.h
│ │ ├── value.h
│ │ ├── value_end_to_end_test.cc
│ │ ├── value_test.cc
│ │ ├── value_testing.h
│ │ └── value_testing_test.cc
│ ├── regex_ext.cc
│ ├── regex_ext.h
│ ├── regex_ext_test.cc
│ ├── regex_functions.cc
│ ├── regex_functions.h
│ ├── regex_functions_test.cc
│ ├── select_optimization.cc
│ ├── select_optimization.h
│ ├── select_optimization_test.cc
│ ├── sets_functions.cc
│ ├── sets_functions.h
│ ├── sets_functions_benchmark_test.cc
│ ├── sets_functions_test.cc
│ ├── strings.cc
│ ├── strings.h
│ └── strings_test.cc
├── internal/
│ ├── BUILD
│ ├── align.h
│ ├── align_test.cc
│ ├── benchmark.h
│ ├── casts.h
│ ├── empty_descriptors.cc
│ ├── empty_descriptors.h
│ ├── empty_descriptors_test.cc
│ ├── equals_text_proto.cc
│ ├── equals_text_proto.h
│ ├── exceptions.h
│ ├── json.cc
│ ├── json.h
│ ├── json_test.cc
│ ├── lexis.cc
│ ├── lexis.h
│ ├── lexis_test.cc
│ ├── manual.h
│ ├── message_equality.cc
│ ├── message_equality.h
│ ├── message_equality_test.cc
│ ├── message_type_name.h
│ ├── message_type_name_test.cc
│ ├── minimal_descriptor_database.h
│ ├── minimal_descriptor_pool.h
│ ├── minimal_descriptors.cc
│ ├── names.cc
│ ├── names.h
│ ├── names_test.cc
│ ├── new.cc
│ ├── new.h
│ ├── new_test.cc
│ ├── noop_delete.h
│ ├── number.h
│ ├── number_test.cc
│ ├── overflow.cc
│ ├── overflow.h
│ ├── overflow_test.cc
│ ├── parse_text_proto.h
│ ├── proto_file_util.h
│ ├── proto_matchers.h
│ ├── proto_time_encoding.cc
│ ├── proto_time_encoding.h
│ ├── proto_time_encoding_test.cc
│ ├── proto_util.h
│ ├── proto_util_test.cc
│ ├── protobuf_runtime_version.h
│ ├── re2_options.h
│ ├── status_builder.h
│ ├── status_macros.h
│ ├── string_pool.cc
│ ├── string_pool.h
│ ├── string_pool_test.cc
│ ├── strings.cc
│ ├── strings.h
│ ├── strings_test.cc
│ ├── testing.cc
│ ├── testing.h
│ ├── testing_descriptor_pool.cc
│ ├── testing_descriptor_pool.h
│ ├── testing_descriptor_pool_test.cc
│ ├── testing_message_factory.cc
│ ├── testing_message_factory.h
│ ├── time.cc
│ ├── time.h
│ ├── time_test.cc
│ ├── to_address.h
│ ├── to_address_test.cc
│ ├── unicode.h
│ ├── utf8.cc
│ ├── utf8.h
│ ├── utf8_test.cc
│ ├── well_known_types.cc
│ ├── well_known_types.h
│ └── well_known_types_test.cc
├── parser/
│ ├── BUILD
│ ├── internal/
│ │ ├── BUILD
│ │ ├── Cel.g4
│ │ └── options.h
│ ├── macro.cc
│ ├── macro.h
│ ├── macro_expr_factory.cc
│ ├── macro_expr_factory.h
│ ├── macro_expr_factory_test.cc
│ ├── macro_registry.cc
│ ├── macro_registry.h
│ ├── macro_registry_test.cc
│ ├── options.h
│ ├── parser.cc
│ ├── parser.h
│ ├── parser_benchmarks.cc
│ ├── parser_interface.h
│ ├── parser_subset_factory.cc
│ ├── parser_subset_factory.h
│ ├── parser_test.cc
│ ├── source_factory.h
│ ├── standard_macros.cc
│ ├── standard_macros.h
│ └── standard_macros_test.cc
├── runtime/
│ ├── BUILD
│ ├── activation.cc
│ ├── activation.h
│ ├── activation_interface.h
│ ├── activation_test.cc
│ ├── comprehension_vulnerability_check.cc
│ ├── comprehension_vulnerability_check.h
│ ├── comprehension_vulnerability_check_test.cc
│ ├── constant_folding.cc
│ ├── constant_folding.h
│ ├── constant_folding_test.cc
│ ├── embedder_context.h
│ ├── embedder_context_test.cc
│ ├── function.h
│ ├── function_adapter.h
│ ├── function_adapter_test.cc
│ ├── function_overload_reference.h
│ ├── function_provider.h
│ ├── function_registry.cc
│ ├── function_registry.h
│ ├── function_registry_test.cc
│ ├── internal/
│ │ ├── BUILD
│ │ ├── activation_attribute_matcher_access.cc
│ │ ├── activation_attribute_matcher_access.h
│ │ ├── attribute_matcher.h
│ │ ├── convert_constant.cc
│ │ ├── convert_constant.h
│ │ ├── errors.cc
│ │ ├── errors.h
│ │ ├── function_adapter.h
│ │ ├── function_adapter_test.cc
│ │ ├── issue_collector.h
│ │ ├── issue_collector_test.cc
│ │ ├── legacy_runtime_type_provider.h
│ │ ├── runtime_env.cc
│ │ ├── runtime_env.h
│ │ ├── runtime_env_testing.cc
│ │ ├── runtime_env_testing.h
│ │ ├── runtime_friend_access.h
│ │ ├── runtime_impl.cc
│ │ ├── runtime_impl.h
│ │ ├── runtime_type_provider.cc
│ │ └── runtime_type_provider.h
│ ├── memory_safety_test.cc
│ ├── optional_types.cc
│ ├── optional_types.h
│ ├── optional_types_test.cc
│ ├── reference_resolver.cc
│ ├── reference_resolver.h
│ ├── reference_resolver_test.cc
│ ├── regex_precompilation.cc
│ ├── regex_precompilation.h
│ ├── regex_precompilation_test.cc
│ ├── register_function_helper.h
│ ├── runtime.h
│ ├── runtime_builder.h
│ ├── runtime_builder_factory.cc
│ ├── runtime_builder_factory.h
│ ├── runtime_issue.h
│ ├── runtime_options.h
│ ├── standard/
│ │ ├── BUILD
│ │ ├── arithmetic_functions.cc
│ │ ├── arithmetic_functions.h
│ │ ├── arithmetic_functions_test.cc
│ │ ├── comparison_functions.cc
│ │ ├── comparison_functions.h
│ │ ├── comparison_functions_test.cc
│ │ ├── container_functions.cc
│ │ ├── container_functions.h
│ │ ├── container_functions_test.cc
│ │ ├── container_membership_functions.cc
│ │ ├── container_membership_functions.h
│ │ ├── container_membership_functions_test.cc
│ │ ├── equality_functions.cc
│ │ ├── equality_functions.h
│ │ ├── equality_functions_test.cc
│ │ ├── logical_functions.cc
│ │ ├── logical_functions.h
│ │ ├── logical_functions_test.cc
│ │ ├── regex_functions.cc
│ │ ├── regex_functions.h
│ │ ├── regex_functions_test.cc
│ │ ├── string_functions.cc
│ │ ├── string_functions.h
│ │ ├── string_functions_test.cc
│ │ ├── time_functions.cc
│ │ ├── time_functions.h
│ │ ├── time_functions_test.cc
│ │ ├── type_conversion_functions.cc
│ │ ├── type_conversion_functions.h
│ │ └── type_conversion_functions_test.cc
│ ├── standard_functions.cc
│ ├── standard_functions.h
│ ├── standard_runtime_builder_factory.cc
│ ├── standard_runtime_builder_factory.h
│ ├── standard_runtime_builder_factory_test.cc
│ ├── type_registry.cc
│ └── type_registry.h
├── testing/
│ └── testrunner/
│ ├── BUILD
│ ├── cel_cc_test.bzl
│ ├── cel_expression_source.h
│ ├── cel_test_context.h
│ ├── cel_test_factories.h
│ ├── coverage_index.cc
│ ├── coverage_index.h
│ ├── coverage_index_test.cc
│ ├── coverage_reporting.cc
│ ├── coverage_reporting.h
│ ├── resources/
│ │ ├── BUILD
│ │ ├── simple_tests.textproto
│ │ ├── test.cel
│ │ └── test_environment.textproto
│ ├── runner_bin.cc
│ ├── runner_lib.cc
│ ├── runner_lib.h
│ ├── runner_lib_test.cc
│ └── user_tests/
│ ├── BUILD
│ ├── checked_expr_test.cc
│ ├── raw_expr_and_cel_file_test.cc
│ ├── raw_expression_test.cc
│ └── simple.cc
├── testutil/
│ ├── BUILD
│ ├── baseline_tests.cc
│ ├── baseline_tests.h
│ ├── baseline_tests_test.cc
│ ├── expr_printer.cc
│ ├── expr_printer.h
│ ├── expr_printer_test.cc
│ ├── test_json_names.proto
│ └── util.h
├── tools/
│ ├── BUILD
│ ├── branch_coverage.cc
│ ├── branch_coverage.h
│ ├── branch_coverage_test.cc
│ ├── cel_field_extractor.cc
│ ├── cel_field_extractor.h
│ ├── cel_field_extractor_test.cc
│ ├── cel_unparser.cc
│ ├── cel_unparser.h
│ ├── cel_unparser_test.cc
│ ├── descriptor_pool_builder.cc
│ ├── descriptor_pool_builder.h
│ ├── descriptor_pool_builder_test.cc
│ ├── flatbuffers_backed_impl.cc
│ ├── flatbuffers_backed_impl.h
│ ├── flatbuffers_backed_impl_test.cc
│ ├── navigable_ast.cc
│ ├── navigable_ast.h
│ ├── navigable_ast_test.cc
│ └── testdata/
│ ├── BUILD
│ ├── checked_expr_and.textproto
│ ├── const_str.textproto
│ ├── coverage_example.textproto
│ ├── exists_macro.textproto
│ ├── flatbuffers.fbs
│ ├── macro_multiple_references.textproto
│ ├── macro_nested_macro_call.textproto
│ ├── macro_single_reference.textproto
│ ├── msg_new_field.textproto
│ └── msg_new_field_int.textproto
└── validator/
├── BUILD
├── ast_depth_validator.cc
├── ast_depth_validator.h
├── ast_depth_validator_test.cc
├── comprehension_nesting_validator.cc
├── comprehension_nesting_validator.h
├── comprehension_nesting_validator_test.cc
├── homogeneous_literal_validator.cc
├── homogeneous_literal_validator.h
├── homogeneous_literal_validator_test.cc
├── regex_validator.cc
├── regex_validator.h
├── regex_validator_test.cc
├── timestamp_literal_validator.cc
├── timestamp_literal_validator.h
├── timestamp_literal_validator_test.cc
├── validator.cc
├── validator.h
└── validator_test.cc
Showing preview only (892K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (8962 symbols across 1013 files)
FILE: base/attribute.cc
type cel (line 30) | namespace cel {
class AttributeStringPrinter (line 35) | class AttributeStringPrinter {
method AttributeStringPrinter (line 39) | explicit AttributeStringPrinter(std::string* output, Kind type)
class AttributeQualifierStringPrinter (line 75) | class AttributeQualifierStringPrinter {
method AttributeQualifierStringPrinter (line 78) | explicit AttributeQualifierStringPrinter(std::string* absl_nonnull o...
type AttributeQualifierTypeVisitor (line 114) | struct AttributeQualifierTypeVisitor final {
method Kind (line 115) | Kind operator()(const Kind& type) const { return type; }
method Kind (line 117) | Kind operator()(int64_t ignored) const {
method Kind (line 122) | Kind operator()(uint64_t ignored) const {
method Kind (line 127) | Kind operator()(const std::string& ignored) const {
method Kind (line 132) | Kind operator()(bool ignored) const {
type AttributeQualifierTypeComparator (line 138) | struct AttributeQualifierTypeComparator final {
type AttributeQualifierIntComparator (line 154) | struct AttributeQualifierIntComparator final {
type AttributeQualifierUintComparator (line 168) | struct AttributeQualifierUintComparator final {
type AttributeQualifierStringComparator (line 182) | struct AttributeQualifierStringComparator final {
type AttributeQualifierBoolComparator (line 196) | struct AttributeQualifierBoolComparator final {
type AttributeQualifier::ComparatorVisitor (line 212) | struct AttributeQualifier::ComparatorVisitor final {
function Kind (line 236) | Kind AttributeQualifier::kind() const {
FILE: base/attribute.h
function namespace (line 32) | namespace cel {
function class (line 130) | class AttributeQualifierPattern final {
function class (line 178) | class Attribute final {
type FieldSpecifier (line 269) | struct FieldSpecifier {
FILE: base/attribute_set.h
function namespace (line 22) | namespace google::api::expr::runtime {
function namespace (line 26) | namespace cel {
function AttributeSet (line 84) | static AttributeSet Merge(const AttributeSet& set1,
function Add (line 94) | void Add(const Attribute& attribute) { attributes_.insert(attribute); }
function Add (line 96) | void Add(const AttributeSet& other) {
FILE: base/builtins.h
function namespace (line 18) | namespace cel {
FILE: base/function_result.h
function namespace (line 23) | namespace cel {
FILE: base/function_result_set.cc
type cel (line 17) | namespace cel {
FILE: base/function_result_set.h
function namespace (line 24) | namespace google::api::expr::runtime {
function namespace (line 28) | namespace cel {
FILE: base/internal/memory_manager_testing.cc
type cel::base_internal (line 19) | namespace cel::base_internal {
function MemoryManagerTestModeToString (line 21) | std::string MemoryManagerTestModeToString(MemoryManagerTestMode mode) {
FILE: base/internal/memory_manager_testing.h
function namespace (line 23) | namespace cel::base_internal {
FILE: base/internal/message_wrapper.h
function namespace (line 20) | namespace cel::base_internal {
FILE: base/internal/operators.h
function namespace (line 20) | namespace cel {
FILE: base/internal/unknown_set.cc
type cel::base_internal (line 19) | namespace cel::base_internal {
function AttributeSet (line 21) | const AttributeSet& EmptyAttributeSet() {
function FunctionResultSet (line 26) | const FunctionResultSet& EmptyFunctionResultSet() {
FILE: base/internal/unknown_set.h
function namespace (line 25) | namespace cel::base_internal {
function final (line 117) | struct UnknownSetAccess final {
FILE: base/operators.cc
type cel (line 27) | namespace cel {
type OperatorDataNameComparer (line 33) | struct OperatorDataNameComparer {
type OperatorDataDisplayNameComparer (line 49) | struct OperatorDataDisplayNameComparer {
function InitializeOperators (line 121) | void InitializeOperators() {
FILE: base/operators.h
function namespace (line 26) | namespace cel {
function class (line 416) | class TernaryOperator final {
FILE: base/operators_test.cc
type cel (line 25) | namespace cel {
function TestOperator (line 32) | void TestOperator(Op op, OpId id, absl::string_view name,
function TestUnaryOperator (line 44) | void TestUnaryOperator(UnaryOperator op, UnaryOperatorId id,
function TestBinaryOperator (line 50) | void TestBinaryOperator(BinaryOperator op, BinaryOperatorId id,
function TestTernaryOperator (line 56) | void TestTernaryOperator(TernaryOperator op, TernaryOperatorId id,
function TEST (line 62) | TEST(Operator, TypeTraits) {
function TEST (line 73) | TEST(UnaryOperator, TypeTraits) {
function TEST (line 82) | TEST(BinaryOperator, TypeTraits) {
function TEST (line 91) | TEST(TernaryOperator, TypeTraits) {
function TEST (line 130) | TEST(Operator, FindByName) {
function TEST (line 137) | TEST(Operator, FindByDisplayName) {
function TEST (line 144) | TEST(UnaryOperator, FindByName) {
function TEST (line 151) | TEST(UnaryOperator, FindByDisplayName) {
function TEST (line 158) | TEST(BinaryOperator, FindByName) {
function TEST (line 165) | TEST(BinaryOperator, FindByDisplayName) {
function TEST (line 172) | TEST(TernaryOperator, FindByName) {
function TEST (line 179) | TEST(TernaryOperator, FindByDisplayName) {
function TEST (line 184) | TEST(Operator, SupportsAbslHash) {
function TEST (line 192) | TEST(UnaryOperator, SupportsAbslHash) {
function TEST (line 200) | TEST(BinaryOperator, SupportsAbslHash) {
FILE: base/type_provider.h
function namespace (line 20) | namespace cel {
FILE: bazel/cat_param_file.cc
function main (line 26) | int main(int argc, char** argv) {
FILE: bazel/cel_cc_embed.cc
function ReadFile (line 35) | std::vector<uint8_t> ReadFile(const std::string& path) {
function WriteFile (line 51) | void WriteFile(const std::string& path, absl::Span<const char> data) {
function main (line 63) | int main(int argc, char** argv) {
FILE: checker/checker_options.h
function namespace (line 18) | namespace cel {
FILE: checker/internal/builtins_arena.cc
type cel::checker_internal (line 21) | namespace cel::checker_internal {
FILE: checker/internal/builtins_arena.h
function namespace (line 21) | namespace cel::checker_internal {
FILE: checker/internal/descriptor_pool_type_introspector.cc
type cel::checker_internal (line 33) | namespace cel::checker_internal {
function FindStructTypeFieldByNameDirectly (line 38) | absl::StatusOr<absl::optional<StructTypeField>>
function ListStructTypeFieldsDirectly (line 62) | absl::StatusOr<
FILE: checker/internal/descriptor_pool_type_introspector.h
function namespace (line 33) | namespace cel::checker_internal {
FILE: checker/internal/descriptor_pool_type_introspector_test.cc
type cel::checker_internal (line 27) | namespace cel::checker_internal {
function TEST (line 40) | TEST(DescriptorPoolTypeIntrospectorTest, FindType) {
function TEST (line 53) | TEST(DescriptorPoolTypeIntrospectorTest, FindEnumConstant) {
function TEST (line 65) | TEST(DescriptorPoolTypeIntrospectorTest, FindStructTypeFieldByName) {
function TEST (line 78) | TEST(DescriptorPoolTypeIntrospectorTest,
function TEST (line 90) | TEST(DescriptorPoolTypeIntrospectorTest, FindExtension) {
function TEST (line 103) | TEST(DescriptorPoolTypeIntrospectorTest, FindStructTypeFieldByNameWith...
function TEST (line 114) | TEST(DescriptorPoolTypeIntrospectorTest,
function TEST (line 131) | TEST(DescriptorPoolTypeIntrospectorTest, ListFieldsForStructType) {
function TEST (line 142) | TEST(DescriptorPoolTypeIntrospectorTest, ListFieldsForStructTypeExtens...
function TEST (line 154) | TEST(DescriptorPoolTypeIntrospectorTest,
function TEST (line 166) | TEST(DescriptorPoolTypeIntrospectorTest, ListFieldsForStructTypeNotFou...
FILE: checker/internal/format_type_name.cc
type cel::checker_internal (line 23) | namespace cel::checker_internal {
type FormatImplRecord (line 26) | struct FormatImplRecord {
function FormatImpl (line 35) | void FormatImpl(const Type& cur, int offset,
function FormatTypeName (line 168) | std::string FormatTypeName(const Type& type) {
FILE: checker/internal/format_type_name.h
function namespace (line 22) | namespace cel::checker_internal {
FILE: checker/internal/format_type_name_test.cc
type cel::checker_internal (line 22) | namespace cel::checker_internal {
function TEST (line 29) | TEST(FormatTypeNameTest, PrimitiveTypes) {
function TEST (line 40) | TEST(FormatTypeNameTest, SpecialTypes) {
function TEST (line 46) | TEST(FormatTypeNameTest, WellKnownTypes) {
function TEST (line 52) | TEST(FormatTypeNameTest, Wrappers) {
function TEST (line 61) | TEST(FormatTypeNameTest, ProtobufTypes) {
function TEST (line 67) | TEST(FormatTypeNameTest, Type) {
function TEST (line 76) | TEST(FormatTypeNameTest, List) {
function TEST (line 84) | TEST(FormatTypeNameTest, Map) {
function TEST (line 94) | TEST(FormatTypeNameTest, Opaque) {
function TEST (line 105) | TEST(FormatTypeNameTest, ArbitraryNesting) {
FILE: checker/internal/namespace_generator.cc
type cel::checker_internal (line 34) | namespace cel::checker_internal {
function FieldSelectInterpretationCandidatesImpl (line 37) | bool FieldSelectInterpretationCandidatesImpl(
function FieldSelectInterpretationCandidates (line 64) | bool FieldSelectInterpretationCandidates(
function FieldSelectInterpretationCandidatesWithAlias (line 72) | bool FieldSelectInterpretationCandidatesWithAlias(
FILE: checker/internal/namespace_generator.h
function namespace (line 30) | namespace cel::checker_internal {
FILE: checker/internal/namespace_generator_test.cc
type cel::checker_internal (line 25) | namespace cel::checker_internal {
function TEST (line 32) | TEST(NamespaceGeneratorTest, EmptyContainer) {
function TEST (line 43) | TEST(NamespaceGeneratorTest, MultipleSegments) {
function TEST (line 55) | TEST(NamespaceGeneratorTest, MultipleSegmentsRootNamespace) {
function TEST (line 67) | TEST(NamespaceGeneratorTest, MultipleSegmentsSelectInterpretation) {
function TEST (line 85) | TEST(NamespaceGeneratorTest, MultipleSegmentsSelectInterpretationAlias...
function TEST (line 101) | TEST(NamespaceGeneratorTest, MultipleSegmentsSelectInterpretationAlias...
function TEST (line 121) | TEST(NamespaceGeneratorTest,
FILE: checker/internal/test_ast_helpers.cc
type cel::checker_internal (line 27) | namespace cel::checker_internal {
function MakeTestParsedAst (line 29) | absl::StatusOr<std::unique_ptr<Ast>> MakeTestParsedAst(
FILE: checker/internal/test_ast_helpers.h
function namespace (line 24) | namespace cel::checker_internal {
FILE: checker/internal/test_ast_helpers_test.cc
type cel::checker_internal (line 24) | namespace cel::checker_internal {
function TEST (line 29) | TEST(MakeTestParsedAstTest, Works) {
function TEST (line 34) | TEST(MakeTestParsedAstTest, ForwardsParseError) {
FILE: checker/internal/type_check_env.cc
type cel::checker_internal (line 32) | namespace cel::checker_internal {
function VariableDecl (line 34) | const VariableDecl* absl_nullable TypeCheckEnv::LookupVariable(
function FunctionDecl (line 42) | const FunctionDecl* absl_nullable TypeCheckEnv::LookupFunction(
function VariableDecl (line 114) | const VariableDecl* absl_nullable VariableScope::LookupLocalVariable(
FILE: checker/internal/type_check_env.h
function namespace (line 41) | namespace cel::checker_internal {
function InsertVariableIfAbsent (line 147) | bool InsertVariableIfAbsent(VariableDecl decl) {
function InsertOrReplaceVariable (line 153) | void InsertOrReplaceVariable(VariableDecl decl) {
function InsertFunctionIfAbsent (line 166) | bool InsertFunctionIfAbsent(FunctionDecl decl) {
function InsertOrReplaceFunction (line 170) | void InsertOrReplaceFunction(FunctionDecl decl) {
function google (line 192) | const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool() c...
function set_arena (line 199) | void set_arena(std::shared_ptr<google::protobuf::Arena> arena) {
FILE: checker/internal/type_checker_builder_impl.cc
type cel::checker_internal (line 47) | namespace cel::checker_internal {
function CheckStdMacroOverlap (line 66) | absl::Status CheckStdMacroOverlap(const FunctionDecl& decl) {
function AddWellKnownContextDeclarationVariables (line 88) | absl::Status AddWellKnownContextDeclarationVariables(
function AddContextDeclarationVariables (line 111) | absl::Status AddContextDeclarationVariables(
function MergeFunctionDecls (line 145) | absl::StatusOr<FunctionDecl> MergeFunctionDecls(
function FilterDecl (line 161) | absl::optional<FunctionDecl> FilterDecl(FunctionDecl decl,
function ValidateType (line 183) | absl::Status ValidateType(const Type& t, bool check_type_param_name,
function ValidateFunctionDecl (line 243) | absl::Status ValidateFunctionDecl(const FunctionDecl& decl,
function ValidateVariableDecl (line 257) | absl::Status ValidateVariableDecl(const VariableDecl& decl,
FILE: checker/internal/type_checker_builder_impl.h
function namespace (line 41) | namespace cel::checker_internal {
FILE: checker/internal/type_checker_builder_impl_test.cc
type cel::checker_internal (line 39) | namespace cel::checker_internal {
type ContextDeclsTestCase (line 45) | struct ContextDeclsTestCase {
class ContextDeclsFieldsDefinedTest (line 50) | class ContextDeclsFieldsDefinedTest
function TEST_P (line 53) | TEST_P(ContextDeclsFieldsDefinedTest, ContextDeclsFieldsDefined) {
function TEST (line 110) | TEST(ContextDeclsTest, ErrorOnDuplicateContextDeclaration) {
function TEST (line 123) | TEST(ContextDeclsTest, ErrorOnContextDeclarationNotFound) {
function TEST (line 132) | TEST(ContextDeclsTest, ErrorOnNonStructMessageType) {
function TEST (line 142) | TEST(ContextDeclsTest, CustomStructNotSupported) {
function TEST (line 163) | TEST(ContextDeclsTest, ErrorOnOverlappingContextDeclaration) {
function TEST (line 182) | TEST(ContextDeclsTest, ErrorOnOverlappingVariableDeclaration) {
function TEST (line 196) | TEST(TypeCheckerBuilderImplTest,
function TEST (line 209) | TEST(TypeCheckerBuilderImplTest, ErrorOnUnspecifiedMessageType) {
function TEST (line 220) | TEST(TypeCheckerBuilderImplTest, ErrorOnInvalidTypeParamNameVariable) {
function TEST (line 235) | TEST(TypeCheckerBuilderImplTest, ErrorOnTooDeepTypeNestingVariable) {
function TEST (line 252) | TEST(TypeCheckerBuilderImplTest, ErrorOnInvalidTypeParamNameFunction) {
function TEST (line 270) | TEST(TypeCheckerBuilderImplTest, ErrorOnTooDeepTypeNestingFunction) {
function TEST (line 295) | TEST(TypeCheckerBuilderImplTest, ReplaceVariable) {
FILE: checker/internal/type_checker_impl.cc
type cel::checker_internal (line 59) | namespace cel::checker_internal {
function FormatCandidate (line 67) | std::string FormatCandidate(absl::Span<const std::string> qualifiers) {
function FlattenAbstractType (line 79) | absl::StatusOr<AstType> FlattenAbstractType(const OpaqueType& type) {
function FlattenMapType (line 91) | absl::StatusOr<AstType> FlattenMapType(const MapType& type) {
function FlattenListType (line 99) | absl::StatusOr<AstType> FlattenListType(const ListType& type) {
function FlattenMessageType (line 105) | absl::StatusOr<AstType> FlattenMessageType(const StructType& type) {
function FlattenTypeType (line 109) | absl::StatusOr<AstType> FlattenTypeType(const TypeType& type) {
function FlattenType (line 121) | absl::StatusOr<AstType> FlattenType(const Type& type) {
class ResolveVisitor (line 181) | class ResolveVisitor : public AstVisitorBase {
type FunctionResolution (line 183) | struct FunctionResolution {
type AttributeResolution (line 188) | struct AttributeResolution {
method ResolveVisitor (line 193) | ResolveVisitor(NamespaceGenerator namespace_generator,
method PreVisitExpr (line 207) | void PreVisitExpr(const Expr& expr) override { expr_stack_.push_back...
method PostVisitExpr (line 209) | void PostVisitExpr(const Expr& expr) override {
method error_count (line 264) | int error_count() const { return error_count_; }
method AssertExpectedType (line 266) | void AssertExpectedType(const Expr& expr, const Type& expected_type) {
type ComprehensionScope (line 274) | struct ComprehensionScope {
type FunctionOverloadMatch (line 281) | struct FunctionOverloadMatch {
method ReportIssue (line 319) | void ReportIssue(TypeCheckIssue issue) {
method ReportMissingReference (line 326) | void ReportMissingReference(const Expr& expr, absl::string_view name) {
method ReportUndefinedField (line 333) | void ReportUndefinedField(int64_t expr_id, absl::string_view field_n...
method ReportTypeMismatch (line 341) | void ReportTypeMismatch(int64_t expr_id, const Type& expected,
method CheckFieldAssignments (line 352) | absl::Status CheckFieldAssignments(const Expr& expr,
method Type (line 401) | Type GetDeducedType(const Expr* expr) {
function IsSupportedKeyType (line 526) | bool IsSupportedKeyType(const Type& type) {
function FunctionDecl (line 858) | const FunctionDecl* ResolveVisitor::ResolveFunctionCallShape(
function VariableDecl (line 926) | const VariableDecl* absl_nullable ResolveVisitor::LookupLocalIdentifier(
function VariableDecl (line 937) | const VariableDecl* absl_nullable ResolveVisitor::LookupGlobalIdentifier(
class ResolveRewriter (line 1175) | class ResolveRewriter : public AstRewriterBase {
method ResolveRewriter (line 1177) | explicit ResolveRewriter(const ResolveVisitor& visitor,
method PostVisitRewrite (line 1188) | bool PostVisitRewrite(Expr& expr) override {
FILE: checker/internal/type_checker_impl.h
function namespace (line 30) | namespace cel::checker_internal {
FILE: checker/internal/type_checker_impl_test.cc
type checker_internal (line 55) | namespace checker_internal {
function SevString (line 81) | std::string SevString(Severity severity) {
function AbslStringify (line 98) | void AbslStringify(Sink& sink, const TypeCheckIssue& issue) {
function FunctionDecl (line 111) | FunctionDecl MakeIdentFunction() {
function RegisterMinimalBuiltins (line 162) | absl::Status RegisterMinimalBuiltins(google::protobuf::Arena* absl_nonnu...
function TEST (line 296) | TEST(TypeCheckerImplTest, SmokeTest) {
function TEST (line 311) | TEST(TypeCheckerImplTest, SimpleIdentsResolved) {
function TEST (line 386) | TEST(TypeCheckerImplTest, LocationCalculation) {
function TEST (line 417) | TEST(TypeCheckerImplTest, QualifiedIdentsResolved) {
function TEST (line 435) | TEST(TypeCheckerImplTest, ReportMissingQualifiedIdentDecl) {
function TEST (line 454) | TEST(TypeCheckerImplTest, ResolveMostQualfiedIdent) {
function TEST (line 472) | TEST(TypeCheckerImplTest, MemberFunctionCallResolved) {
function TEST (line 495) | TEST(TypeCheckerImplTest, MemberFunctionCallNotDeclared) {
function TEST (line 512) | TEST(TypeCheckerImplTest, FunctionShapeMismatch) {
function TEST (line 531) | TEST(TypeCheckerImplTest, NamespaceFunctionCallResolved) {
function TEST (line 560) | TEST(TypeCheckerImplTest, NamespacedFunctionSkipsFieldCheck) {
function TEST (line 588) | TEST(TypeCheckerImplTest, NamespacedFunctionWithAbbreviation) {
function TEST (line 667) | TEST(TypeCheckerImplTest, FreeMapTypeToDyn) {
function TEST (line 704) | TEST(TypeCheckerImplTest, MapTypeUnsupportedKeyWarns) {
function TEST (line 721) | TEST(TypeCheckerImplTest, MapTypeWithMixedValues) {
function TEST (line 740) | TEST(TypeCheckerImplTest, ComprehensionVariablesResolved) {
function TEST (line 756) | TEST(TypeCheckerImplTest, MapComprehensionVariablesResolved) {
function TEST (line 772) | TEST(TypeCheckerImplTest, NestedComprehensions) {
function TEST (line 789) | TEST(TypeCheckerImplTest, ComprehensionVarsShadowNamespacePriorityRules) {
function TEST (line 811) | TEST(TypeCheckerImplTest, ComprehensionVarsShadowsQualifiedIdent) {
function TEST (line 831) | TEST(TypeCheckerImplTest, ComprehensionVarsShadowsQualifiedIdentTypeErro...
function TEST (line 849) | TEST(TypeCheckerImplTest, ComprehensionVarsDisamgiguatesQualifiedIdent) {
function TEST (line 869) | TEST(TypeCheckerImplTest, ComprehensionVarsDisamgiguatesQualifiedIdentMi...
function TEST (line 887) | TEST(TypeCheckerImplTest, ComprehensionVarsDisamgiguatesIdent) {
function TEST (line 906) | TEST(TypeCheckerImplTest, ComprehensionVarsCyclicParamAssignability) {
type PrimitiveLiteralsTestCase (line 953) | struct PrimitiveLiteralsTestCase {
class PrimitiveLiteralsTest (line 958) | class PrimitiveLiteralsTest
function TEST_P (line 961) | TEST_P(PrimitiveLiteralsTest, LiteralsTypeInferred) {
type AstTypeConversionTestCase (line 1000) | struct AstTypeConversionTestCase {
class AstTypeConversionTest (line 1005) | class AstTypeConversionTest
function TEST_P (line 1008) | TEST_P(AstTypeConversionTest, TypeConversion) {
FILE: checker/internal/type_inference_context.cc
type cel::checker_internal (line 36) | namespace cel::checker_internal {
function IsWildCardType (line 39) | bool IsWildCardType(Type type) {
function IsLegacyNullable (line 57) | bool IsLegacyNullable(Type type) {
function IsTypeVar (line 70) | bool IsTypeVar(absl::string_view name) { return absl::StartsWith(name,...
function IsUnionType (line 72) | bool IsUnionType(Type t) {
function IsSubsetOf (line 90) | bool IsSubsetOf(Type a, Type b) {
type FunctionOverloadInstance (line 113) | struct FunctionOverloadInstance {
function FunctionOverloadInstance (line 118) | FunctionOverloadInstance InstantiateFunctionOverload(
function WrapperToPrimitive (line 136) | absl::optional<Type> WrapperToPrimitive(const Type& t) {
function Type (line 157) | Type TypeInferenceContext::InstantiateTypeParams(const Type& type) {
function Type (line 162) | Type TypeInferenceContext::InstantiateTypeParams(
function Type (line 356) | Type TypeInferenceContext::Substitute(
function Type (line 602) | Type TypeInferenceContext::FullySubstitute(const Type& type,
FILE: checker/internal/type_inference_context.h
function namespace (line 33) | namespace cel::checker_internal {
FILE: checker/internal/type_inference_context_test.cc
type cel::checker_internal (line 28) | namespace cel::checker_internal {
function TEST (line 101) | TEST(TypeInferenceContextTest, InstantiateTypeParams) {
function TEST (line 110) | TEST(TypeInferenceContextTest, InstantiateTypeParamsWithSubstitutions) {
function TEST (line 122) | TEST(TypeInferenceContextTest, InstantiateTypeParamsUnparameterized) {
function TEST (line 130) | TEST(TypeInferenceContextTest, InstantiateTypeParamsList) {
function TEST (line 139) | TEST(TypeInferenceContextTest, InstantiateTypeParamsListPrimitive) {
function TEST (line 148) | TEST(TypeInferenceContextTest, InstantiateTypeParamsMap) {
function TEST (line 157) | TEST(TypeInferenceContextTest, InstantiateTypeParamsMapSameParam) {
function TEST (line 166) | TEST(TypeInferenceContextTest, InstantiateTypeParamsMapPrimitive) {
function TEST (line 176) | TEST(TypeInferenceContextTest, InstantiateTypeParamsType) {
function TEST (line 185) | TEST(TypeInferenceContextTest, InstantiateTypeParamsTypeEmpty) {
function TEST (line 195) | TEST(TypeInferenceContextTest, InstantiateTypeParamsOpaque) {
function TEST (line 213) | TEST(TypeInferenceContextTest, OpaqueTypeAssignable) {
function TEST (line 225) | TEST(TypeInferenceContextTest, WrapperTypeAssignable) {
function TEST (line 233) | TEST(TypeInferenceContextTest, MismatchedTypeNotAssignable) {
function TEST (line 240) | TEST(TypeInferenceContextTest, OverloadResolution) {
function TEST (line 259) | TEST(TypeInferenceContextTest, MultipleOverloadsResultTypeDyn) {
function TEST (line 283) | TEST(TypeInferenceContextTest, ResolveOverloadBasic) {
function TEST (line 301) | TEST(TypeInferenceContextTest, ResolveOverloadFails) {
function TEST (line 317) | TEST(TypeInferenceContextTest, ResolveOverloadWithParamsNoMatch) {
function TEST (line 332) | TEST(TypeInferenceContextTest, ResolveOverloadWithMixedParamsMatch) {
function TEST (line 349) | TEST(TypeInferenceContextTest, ResolveOverloadWithMixedParamsMatch2) {
function TEST (line 368) | TEST(TypeInferenceContextTest, ResolveOverloadWithParamsMatches) {
function TEST (line 385) | TEST(TypeInferenceContextTest, ResolveOverloadWithNestedParamsMatch) {
function TEST (line 424) | TEST(TypeInferenceContextTest, ResolveOverloadWithNestedParamsNoMatch) {
function TEST (line 441) | TEST(TypeInferenceContextTest, InferencesAccumulate) {
function TEST (line 472) | TEST(TypeInferenceContextTest, DebugString) {
type TypeInferenceContextWrapperTypesTestCase (line 491) | struct TypeInferenceContextWrapperTypesTestCase {
class TypeInferenceContextWrapperTypesTest (line 496) | class TypeInferenceContextWrapperTypesTest
method TypeInferenceContextWrapperTypesTest (line 500) | TypeInferenceContextWrapperTypesTest() : context_(&arena_) {
function TEST_P (line 517) | TEST_P(TypeInferenceContextWrapperTypesTest, ResolvePrimitiveArg) {
function TEST_P (line 534) | TEST_P(TypeInferenceContextWrapperTypesTest, ResolveWrapperArg) {
function TEST_P (line 550) | TEST_P(TypeInferenceContextWrapperTypesTest, ResolveNullArg) {
function TEST_P (line 566) | TEST_P(TypeInferenceContextWrapperTypesTest, NullWidens) {
function TEST_P (line 582) | TEST_P(TypeInferenceContextWrapperTypesTest, PrimitiveWidens) {
function TEST (line 613) | TEST(TypeInferenceContextTest, ResolveOverloadWithUnionTypePromotion) {
function TEST (line 639) | TEST(TypeInferenceContextTest, ResolveOverloadWithTypeType) {
FILE: checker/optional.cc
type cel (line 28) | namespace cel {
function Type (line 31) | Type OptionalOfV() {
function Type (line 38) | Type TypeOfOptionalOfV() {
function Type (line 45) | Type ListOfV() {
function Type (line 52) | Type OptionalListOfV() {
function Type (line 59) | Type MapOfKV() {
function Type (line 67) | Type OptionalMapOfKV() {
class OptionalNames (line 74) | class OptionalNames {
class OptionalOverloads (line 90) | class OptionalOverloads {
function RegisterOptionalDecls (line 119) | absl::Status RegisterOptionalDecls(TypeCheckerBuilder& builder, int ve...
function CheckerLibrary (line 236) | CheckerLibrary OptionalCheckerLibrary(int version) {
FILE: checker/optional.h
function namespace (line 20) | namespace cel {
FILE: checker/optional_test.cc
type cel (line 35) | namespace cel {
function TEST (line 76) | TEST(OptionalTest, OptSelectDoesNotAnnotateFieldType) {
type TestCase (line 103) | struct TestCase {
class OptionalTest (line 109) | class OptionalTest : public testing::TestWithParam<TestCase> {}
function TEST_P (line 111) | TEST_P(OptionalTest, Runner) {
class OptionalStrictNullAssignmentTest (line 287) | class OptionalStrictNullAssignmentTest
function TEST_P (line 290) | TEST_P(OptionalStrictNullAssignmentTest, Runner) {
FILE: checker/standard_library.cc
type cel (line 30) | namespace cel {
function TypeParamType (line 36) | TypeParamType TypeParamA() { return TypeParamType("A"); }
function TypeParamType (line 39) | TypeParamType TypeParamB() { return TypeParamType("B"); }
function Type (line 41) | Type ListOfA() {
function Type (line 47) | Type MapOfAB() {
function Type (line 53) | Type TypeOfType() {
function Type (line 59) | Type TypeOfA() {
function Type (line 65) | Type TypeNullType() {
function Type (line 71) | Type TypeBoolType() {
function Type (line 77) | Type TypeIntType() {
function Type (line 83) | Type TypeUintType() {
function Type (line 89) | Type TypeDoubleType() {
function Type (line 95) | Type TypeStringType() {
function Type (line 101) | Type TypeBytesType() {
function Type (line 107) | Type TypeDynType() {
function Type (line 113) | Type TypeListType() {
function Type (line 119) | Type TypeMapType() {
function AddArithmeticOps (line 125) | absl::Status AddArithmeticOps(TypeCheckerBuilder& builder) {
function AddLogicalOps (line 220) | absl::Status AddLogicalOps(TypeCheckerBuilder& builder) {
function AddTypeConversions (line 265) | absl::Status AddTypeConversions(TypeCheckerBuilder& builder) {
function AddEqualityOps (line 381) | absl::Status AddEqualityOps(TypeCheckerBuilder& builder) {
function AddContainerOps (line 398) | absl::Status AddContainerOps(TypeCheckerBuilder& builder) {
function AddRelationOps (line 454) | absl::Status AddRelationOps(TypeCheckerBuilder& builder) {
function AddStringFunctions (line 652) | absl::Status AddStringFunctions(TypeCheckerBuilder& builder) {
function AddRegexFunctions (line 677) | absl::Status AddRegexFunctions(TypeCheckerBuilder& builder) {
function AddTimeFunctions (line 689) | absl::Status AddTimeFunctions(TypeCheckerBuilder& builder) {
function AddTypeConstantVariables (line 794) | absl::Status AddTypeConstantVariables(TypeCheckerBuilder& builder) {
function AddEnumConstants (line 834) | absl::Status AddEnumConstants(TypeCheckerBuilder& builder) {
function AddStandardLibraryDecls (line 843) | absl::Status AddStandardLibraryDecls(TypeCheckerBuilder& builder) {
function CheckerLibrary (line 861) | CheckerLibrary StandardCheckerLibrary() {
FILE: checker/standard_library.h
function namespace (line 19) | namespace cel {
FILE: checker/standard_library_test.cc
type cel (line 37) | namespace cel {
function TEST (line 50) | TEST(StandardLibraryTest, StandardLibraryAddsDecls) {
function TEST (line 58) | TEST(StandardLibraryTest, StandardLibraryErrorsIfAddedTwice) {
function TEST (line 67) | TEST(StandardLibraryTest, ComprehensionVarsIndirectCyclicParamAssignab...
function TEST (line 106) | TEST(StandardLibraryTest, ComprehensionResultTypeIsSubstituted) {
class StandardLibraryDefinitionsTest (line 137) | class StandardLibraryDefinitionsTest : public ::testing::Test {
method SetUp (line 139) | void SetUp() override {
class StdlibTypeVarDefinitionTest (line 151) | class StdlibTypeVarDefinitionTest
function TEST_P (line 155) | TEST_P(StdlibTypeVarDefinitionTest, DefinesTypeConstants) {
function TEST_F (line 178) | TEST_F(StandardLibraryDefinitionsTest, DefinesProtoStructNull) {
function TEST_F (line 204) | TEST_F(StandardLibraryDefinitionsTest, DefinesTypeType) {
type DefinitionsTestCase (line 221) | struct DefinitionsTestCase {
class StdLibDefinitionsTest (line 227) | class StdLibDefinitionsTest
function TEST_P (line 239) | TEST_P(StdLibDefinitionsTest, Runner) {
FILE: checker/type_check_issue.cc
type cel (line 23) | namespace cel {
function SeverityString (line 27) | absl::string_view SeverityString(TypeCheckIssue::Severity severity) {
FILE: checker/type_check_issue.h
function namespace (line 24) | namespace cel {
FILE: checker/type_check_issue_test.cc
type cel (line 20) | namespace cel {
function TEST (line 23) | TEST(TypeCheckIssueTest, DisplayString) {
function TEST (line 33) | TEST(TypeCheckIssueTest, DisplayStringNoPosition) {
function TEST (line 39) | TEST(TypeCheckIssueTest, DisplayStringDeprecated) {
FILE: checker/type_checker.cc
type cel (line 17) | namespace cel {
FILE: checker/type_checker.h
function namespace (line 27) | namespace cel {
FILE: checker/type_checker_builder.h
function namespace (line 35) | namespace cel {
FILE: checker/type_checker_builder_factory.cc
type cel (line 31) | namespace cel {
function CreateTypeCheckerBuilder (line 33) | absl::StatusOr<std::unique_ptr<TypeCheckerBuilder>> CreateTypeCheckerB...
function CreateTypeCheckerBuilder (line 44) | absl::StatusOr<std::unique_ptr<TypeCheckerBuilder>> CreateTypeCheckerB...
FILE: checker/type_checker_builder_factory.h
function namespace (line 25) | namespace cel {
FILE: checker/type_checker_builder_factory_test.cc
type cel (line 38) | namespace cel {
function TEST (line 49) | TEST(TypeCheckerBuilderTest, AddVariable) {
function TEST (line 78) | TEST(TypeCheckerBuilderTest, TypeCheckersIndependent) {
function TEST (line 128) | TEST(TypeCheckerBuilderTest, AddVariableRedeclaredError) {
function TEST (line 143) | TEST(TypeCheckerBuilderTest, AddFunction) {
function TEST (line 160) | TEST(TypeCheckerBuilderTest, AddFunctionRedeclaredError) {
function TEST (line 178) | TEST(TypeCheckerBuilderTest, AddLibrary) {
function SubsetTestlibConfigurer (line 205) | absl::Status SubsetTestlibConfigurer(TypeCheckerBuilder& builder) {
function CheckerLibrary (line 227) | CheckerLibrary SubsetTestlib() { return {"testlib", SubsetTestlibConfi...
function TEST (line 229) | TEST(TypeCheckerBuilderTest, AddLibraryIncludeSubset) {
function TEST (line 268) | TEST(TypeCheckerBuilderTest, AddLibraryExcludeSubset) {
function TEST (line 308) | TEST(TypeCheckerBuilderTest, AddLibrarySubsetRemoveAllOvl) {
function TEST (line 346) | TEST(TypeCheckerBuilderTest, AddLibraryOneSubsetPerLibraryId) {
function TEST (line 364) | TEST(TypeCheckerBuilderTest, AddLibrarySubsetLibraryIdRequireds) {
function TEST (line 378) | TEST(TypeCheckerBuilderTest, AddContextDeclaration) {
function TEST (line 481) | TEST(TypeCheckerBuilderTest, AllowWellKnownTypeContextDeclarationInt64...
function TEST (line 501) | TEST(TypeCheckerBuilderTest, ContextDeclarationWithJsonName) {
function TEST (line 534) | TEST(TypeCheckerBuilderTest, JsonFieldNameOptionStructCreation) {
FILE: checker/type_checker_subset_factory.cc
type cel (line 25) | namespace cel {
function IncludeOverloadsByIdPredicate (line 27) | TypeCheckerSubset::FunctionPredicate IncludeOverloadsByIdPredicate(
function IncludeOverloadsByIdPredicate (line 35) | TypeCheckerSubset::FunctionPredicate IncludeOverloadsByIdPredicate(
function ExcludeOverloadsByIdPredicate (line 41) | TypeCheckerSubset::FunctionPredicate ExcludeOverloadsByIdPredicate(
function ExcludeOverloadsByIdPredicate (line 49) | TypeCheckerSubset::FunctionPredicate ExcludeOverloadsByIdPredicate(
FILE: checker/type_checker_subset_factory.h
function namespace (line 27) | namespace cel {
FILE: checker/type_checker_subset_factory_test.cc
type cel (line 31) | namespace cel {
function TEST (line 34) | TEST(TypeCheckerSubsetFactoryTest, IncludeOverloadsByIdPredicate) {
function TEST (line 79) | TEST(TypeCheckerSubsetFactoryTest, ExcludeOverloadsByIdPredicate) {
FILE: checker/validation_result.cc
type cel (line 23) | namespace cel {
FILE: checker/validation_result.h
function namespace (line 34) | namespace cel {
FILE: checker/validation_result_test.cc
type cel (line 27) | namespace cel {
function TEST (line 39) | TEST(ValidationResultTest, IsValidWithAst) {
function TEST (line 46) | TEST(ValidationResultTest, IsNotValidWithoutAst) {
function TEST (line 54) | TEST(ValidationResultTest, GetIssues) {
function TEST (line 69) | TEST(ValidationResultTest, FormatError) {
FILE: codelab/cel_compiler.h
function namespace (line 27) | namespace cel_codelab {
FILE: codelab/cel_compiler_test.cc
type cel_codelab (line 41) | namespace cel_codelab {
function MakeDefaultCompilerBuilder (line 61) | std::unique_ptr<cel::CompilerBuilder> MakeDefaultCompilerBuilder() {
function TEST (line 74) | TEST(DefaultCompiler, Basic) {
function TEST (line 79) | TEST(DefaultCompiler, AddFunctionDecl) {
function TEST (line 101) | TEST(DefaultCompiler, EndToEnd) {
FILE: codelab/exercise1.cc
type cel_codelab (line 35) | namespace cel_codelab {
function ConvertResult (line 45) | absl::StatusOr<std::string> ConvertResult(const CelValue& value) {
function ParseAndEvaluate (line 55) | absl::StatusOr<std::string> ParseAndEvaluate(absl::string_view cel_exp...
FILE: codelab/exercise1.h
function namespace (line 23) | namespace cel_codelab {
FILE: codelab/exercise10.cc
type cel_codelab (line 40) | namespace cel_codelab {
function ConfigureCompiler (line 44) | absl::StatusOr<std::unique_ptr<cel::Compiler>> ConfigureCompiler() {
function ConfigureRuntime (line 61) | absl::StatusOr<std::unique_ptr<cel::Runtime>> ConfigureRuntime() {
function CompileAndEvaluateExercise10 (line 76) | absl::StatusOr<bool> CompileAndEvaluateExercise10(absl::string_view ex...
FILE: codelab/exercise10.h
function namespace (line 21) | namespace cel_codelab {
FILE: codelab/exercise10_test.cc
type cel_codelab (line 21) | namespace cel_codelab {
function TEST (line 28) | TEST(Exercise10, IpInRange) {
function TEST (line 40) | TEST(Exercise10, IpNotInRange) {
function TEST (line 52) | TEST(Exercise10, IpEqual) {
function TEST (line 61) | TEST(Exercise10, IpInequal) {
function TEST (line 70) | TEST(Exercise10, IpInvalid) {
FILE: codelab/exercise1_test.cc
type cel_codelab (line 20) | namespace cel_codelab {
function TEST (line 26) | TEST(Exercise1, PrintHelloWorld) {
function TEST (line 31) | TEST(Exercise1, WrongTypeResultError) {
function TEST (line 37) | TEST(Exercise1, Conditional) {
FILE: codelab/exercise2.cc
type cel_codelab (line 41) | namespace cel_codelab {
function MakeCelCompiler (line 55) | absl::StatusOr<std::unique_ptr<cel::Compiler>> MakeCelCompiler() {
function EvalCheckedExpr (line 79) | absl::StatusOr<bool> EvalCheckedExpr(const CheckedExpr& checked_expr,
function CompileAndEvaluateWithBoolVar (line 109) | absl::StatusOr<bool> CompileAndEvaluateWithBoolVar(absl::string_view c...
function CompileAndEvaluateWithContext (line 126) | absl::StatusOr<bool> CompileAndEvaluateWithContext(
FILE: codelab/exercise2.h
function namespace (line 22) | namespace cel_codelab {
FILE: codelab/exercise2_test.cc
type cel_codelab (line 22) | namespace cel_codelab {
function TEST (line 31) | TEST(Exercise2Var, Simple) {
function TEST (line 42) | TEST(Exercise2Var, WrongTypeResultError) {
function TEST (line 48) | TEST(Exercise2Context, Simple) {
function TEST (line 71) | TEST(Exercise2Context, WrongTypeResultError) {
FILE: codelab/exercise3_test.cc
type cel_codelab (line 22) | namespace cel_codelab {
function TruthTableTest (line 30) | absl::StatusOr<bool> TruthTableTest(absl::string_view statement) {
function TEST (line 34) | TEST(Exercise3, LogicalOr) {
function TEST (line 58) | TEST(Exercise3, LogicalAnd) {
function TEST (line 77) | TEST(Exercise3, Ternary) {
function TEST (line 87) | TEST(Exercise3, BadFieldAccess) {
FILE: codelab/exercise4.cc
type cel_codelab (line 41) | namespace cel_codelab {
function MakeConfiguredCompiler (line 55) | absl::StatusOr<std::unique_ptr<cel::Compiler>> MakeConfiguredCompiler() {
class Evaluator (line 74) | class Evaluator {
method Evaluator (line 76) | Evaluator() {
method SetupEvaluatorEnvironment (line 82) | absl::Status SetupEvaluatorEnvironment() {
method Evaluate (line 91) | absl::StatusOr<bool> Evaluate(const CheckedExpr& expr,
function EvaluateWithExtensionFunction (line 116) | absl::StatusOr<bool> EvaluateWithExtensionFunction(
FILE: codelab/exercise4.h
function namespace (line 22) | namespace cel_codelab {
FILE: codelab/exercise4_test.cc
type cel_codelab (line 22) | namespace cel_codelab {
function TEST (line 28) | TEST(EvaluateWithExtensionFunction, Baseline) {
function TEST (line 47) | TEST(EvaluateWithExtensionFunction, ContainsTrue) {
function TEST (line 67) | TEST(EvaluateWithExtensionFunction, ContainsFalse) {
FILE: codelab/network_functions.cc
type cel_codelab (line 50) | namespace cel_codelab {
function AddressType (line 61) | cel::Type AddressType() {
function TypeOfAddressType (line 67) | cel::Type TypeOfAddressType() {
function AddressMatcherType (line 72) | cel::Type AddressMatcherType() {
function TypeOfAddressMatcherType (line 78) | cel::Type TypeOfAddressMatcherType() {
function ParseAddressImpl (line 84) | absl::StatusOr<IpVersion> ParseAddressImpl(absl::string_view str,
function ConfigureNetworkFunctions (line 122) | absl::Status ConfigureNetworkFunctions(cel::TypeCheckerBuilder& builde...
function NetworkAddressRepGetTypeId (line 174) | cel::NativeTypeId NetworkAddressRepGetTypeId(
function NetworkAddressRepGetTypeName (line 186) | absl::string_view NetworkAddressRepGetTypeName(
function NetworkAddressRepDebugString (line 192) | std::string NetworkAddressRepDebugString(
function NetworkAddressRepGetRuntimeType (line 199) | cel::OpaqueType NetworkAddressRepGetRuntimeType(
function NetworkAddressRepEqual (line 205) | absl::Status NetworkAddressRepEqual(
function NetworkAddressRepClone (line 223) | cel::OpaqueValue NetworkAddressRepClone(
class NetworkAddressMatcherImpl (line 259) | class NetworkAddressMatcherImpl : public cel::OpaqueValueInterface {
method NetworkAddressMatcherImpl (line 261) | explicit NetworkAddressMatcherImpl(NetworkAddressMatcher rep)
method NetworkAddressMatcher (line 264) | const NetworkAddressMatcher& rep() const { return rep_; }
method DebugString (line 267) | std::string DebugString() const final {
method GetTypeName (line 271) | absl::string_view GetTypeName() const final { return "net.AddressMat...
method GetRuntimeType (line 273) | cel::OpaqueType GetRuntimeType() const final {
method Equal (line 277) | absl::Status Equal(const cel::OpaqueValue& other,
method Clone (line 292) | cel::OpaqueValue Clone(google::protobuf::Arena* absl_nonnull arena) ...
method GetNativeTypeId (line 296) | cel::NativeTypeId GetNativeTypeId() const final {
function parseAddress (line 307) | cel::Value parseAddress(
function parseAddressOrZero (line 321) | cel::Value parseAddressOrZero(const cel::StringValue& str) {
function parseAddressMatcher (line 332) | cel::Value parseAddressMatcher(
function containsAddress (line 349) | cel::Value containsAddress(const cel::OpaqueValue& matcher,
function NetworkAddressMatcher (line 466) | const NetworkAddressMatcher* NetworkAddressMatcher::Unwrap(
function NetworkFunctionsCompilerLibrary (line 512) | cel::CompilerLibrary NetworkFunctionsCompilerLibrary() {
function RegisterNetworkTypes (line 516) | absl::Status RegisterNetworkTypes(cel::TypeRegistry& registry,
function RegisterNetworkFunctions (line 523) | absl::Status RegisterNetworkFunctions(cel::FunctionRegistry& registry,
FILE: codelab/network_functions.h
function IpVersion (line 40) | enum class IpVersion : uint8_t {
FILE: codelab/network_functions_test.cc
type cel_codelab (line 43) | namespace cel_codelab {
type TestCase (line 55) | struct TestCase {
class NetworkFunctionsCheckerTest (line 61) | class NetworkFunctionsCheckerTest : public testing::TestWithParam<Test...
function TEST_P (line 63) | TEST_P(NetworkFunctionsCheckerTest, DeclarationsTest) {
type RuntimeTestCase (line 112) | struct RuntimeTestCase {
class NetworkFunctionsRuntimeTest (line 119) | class NetworkFunctionsRuntimeTest
function TEST_P (line 122) | TEST_P(NetworkFunctionsRuntimeTest, EvaluationTest) {
class BenchmarkState (line 197) | class BenchmarkState {
method Create (line 199) | static absl::StatusOr<BenchmarkState> Create(bool optimize) {
method MakeProgram (line 230) | absl::StatusOr<std::unique_ptr<Program>> MakeProgram(absl::string_vi...
method BenchmarkState (line 240) | BenchmarkState(std::unique_ptr<Compiler> c, std::unique_ptr<const Ru...
function BM_ParseAddress (line 248) | void BM_ParseAddress(benchmark::State& state) {
function BM_ParseAddressVar (line 265) | void BM_ParseAddressVar(benchmark::State& state) {
function BM_ParseAddressMatcher (line 283) | void BM_ParseAddressMatcher(benchmark::State& state) {
function BM_ParseAddressMatcherMatches (line 301) | void BM_ParseAddressMatcherMatches(benchmark::State& state) {
function BM_ParseAddressMatcherMatchesVar (line 320) | void BM_ParseAddressMatcherMatchesVar(benchmark::State& state) {
FILE: codelab/solutions/exercise1.cc
type cel_codelab (line 35) | namespace cel_codelab {
function ConvertResult (line 52) | absl::StatusOr<std::string> ConvertResult(const CelValue& value) {
function ParseAndEvaluate (line 62) | absl::StatusOr<std::string> ParseAndEvaluate(absl::string_view cel_exp...
FILE: codelab/solutions/exercise10.cc
type cel_codelab (line 40) | namespace cel_codelab {
function ConfigureCompiler (line 44) | absl::StatusOr<std::unique_ptr<cel::Compiler>> ConfigureCompiler() {
function ConfigureRuntime (line 65) | absl::StatusOr<std::unique_ptr<cel::Runtime>> ConfigureRuntime() {
function CompileAndEvaluateExercise10 (line 86) | absl::StatusOr<bool> CompileAndEvaluateExercise10(absl::string_view ex...
FILE: codelab/solutions/exercise2.cc
type cel_codelab (line 45) | namespace cel_codelab {
function MakeCelCompiler (line 60) | absl::StatusOr<std::unique_ptr<cel::Compiler>> MakeCelCompiler() {
function EvalCheckedExpr (line 83) | absl::StatusOr<bool> EvalCheckedExpr(const CheckedExpr& checked_expr,
function CompileAndEvaluateWithBoolVar (line 113) | absl::StatusOr<bool> CompileAndEvaluateWithBoolVar(absl::string_view c...
function CompileAndEvaluateWithContext (line 130) | absl::StatusOr<bool> CompileAndEvaluateWithContext(
FILE: codelab/solutions/exercise3_test.cc
type cel_codelab (line 22) | namespace cel_codelab {
function TruthTableTest (line 30) | absl::StatusOr<bool> TruthTableTest(absl::string_view statement) {
function TEST (line 34) | TEST(Exercise3, LogicalOr) {
function TEST (line 49) | TEST(Exercise3, LogicalAnd) {
function TEST (line 64) | TEST(Exercise3, Ternary) {
function TEST (line 73) | TEST(Exercise3Context, BadFieldAccess) {
FILE: codelab/solutions/exercise4.cc
type cel_codelab (line 45) | namespace cel_codelab {
function ContainsExtensionFunction (line 62) | absl::StatusOr<bool> ContainsExtensionFunction(google::protobuf::Arena...
function MakeConfiguredCompiler (line 78) | absl::StatusOr<std::unique_ptr<cel::Compiler>> MakeConfiguredCompiler() {
class Evaluator (line 112) | class Evaluator {
method Evaluator (line 114) | Evaluator() {
method SetupEvaluatorEnvironment (line 120) | absl::Status SetupEvaluatorEnvironment() {
method Evaluate (line 134) | absl::StatusOr<bool> Evaluate(const CheckedExpr& expr,
function EvaluateWithExtensionFunction (line 159) | absl::StatusOr<bool> EvaluateWithExtensionFunction(
FILE: common/allocator.h
function namespace (line 34) | namespace cel {
function deallocate (line 187) | void deallocate(pointer p, size_type n) noexcept {
function google (line 247) | constexpr google::protobuf::Arena* absl_nonnull arena() const noexcept {
function deallocate (line 381) | void deallocate(pointer, size_type) noexcept {}
function arena_ (line 435) | constexpr Allocator(google::protobuf::Arena* absl_nullable arena) noexcept
function google (line 449) | constexpr google::protobuf::Arena* absl_nullable arena() const noexcept {
function deallocate (line 553) | void deallocate(pointer p, size_type n) noexcept {
FILE: common/allocator_test.cc
type cel (line 28) | namespace cel {
function TEST (line 33) | TEST(AllocatorKind, AbslStringify) {
function TEST (line 39) | TEST(NewDeleteAllocator, Bytes) {
function TEST (line 46) | TEST(ArenaAllocator, Bytes) {
type TrivialObject (line 54) | struct TrivialObject {
function TEST (line 58) | TEST(NewDeleteAllocator, NewDeleteObject) {
function TEST (line 65) | TEST(ArenaAllocator, NewDeleteObject) {
function TEST (line 73) | TEST(NewDeleteAllocator, Object) {
function TEST (line 80) | TEST(ArenaAllocator, Object) {
function TEST (line 88) | TEST(NewDeleteAllocator, ObjectArray) {
function TEST (line 95) | TEST(ArenaAllocator, ObjectArray) {
function TEST (line 103) | TEST(NewDeleteAllocator, T) {
function TEST (line 112) | TEST(ArenaAllocator, T) {
function TEST (line 122) | TEST(NewDeleteAllocator, CopyConstructible) {
function TEST (line 139) | TEST(ArenaAllocator, CopyConstructible) {
function TEST (line 154) | TEST(Allocator, CopyConstructible) {
FILE: common/any.cc
type cel (line 20) | namespace cel {
function ParseTypeUrl (line 22) | bool ParseTypeUrl(absl::string_view type_url,
FILE: common/any.h
function namespace (line 28) | namespace cel {
FILE: common/any_test.cc
type cel (line 24) | namespace cel {
function TEST (line 27) | TEST(Any, Value) {
function TEST (line 36) | TEST(MakeTypeUrlWithPrefix, Basic) {
function TEST (line 41) | TEST(MakeTypeUrl, Basic) {
function TEST (line 45) | TEST(ParseTypeUrl, Valid) {
function TEST (line 52) | TEST(ParseTypeUrl, TypeName) {
function TEST (line 61) | TEST(ParseTypeUrl, PrefixAndTypeName) {
FILE: common/arena.h
function namespace (line 24) | namespace cel {
function void (line 76) | struct ArenaTraits<void> {
FILE: common/arena_string.h
function namespace (line 34) | namespace cel {
function string_view (line 295) | string_view rhs) {
function string_view (line 321) | string_view rhs) {
function string_view (line 347) | string_view rhs) {
FILE: common/arena_string_pool.h
function namespace (line 31) | namespace cel {
FILE: common/arena_string_pool_test.cc
type cel (line 24) | namespace cel {
function TEST (line 27) | TEST(ArenaStringPool, InternCString) {
function TEST (line 35) | TEST(ArenaStringPool, InternStringView) {
function TEST (line 43) | TEST(ArenaStringPool, InternStringSmall) {
function TEST (line 51) | TEST(ArenaStringPool, InternStringLarge) {
function TEST (line 61) | TEST(ArenaStringPool, InternCord) {
FILE: common/arena_string_test.cc
type cel (line 24) | namespace cel {
class ArenaStringTest (line 38) | class ArenaStringTest : public ::testing::Test {
method arena (line 40) | arena() { return &arena_; }
function TEST_F (line 46) | TEST_F(ArenaStringTest, Default) {
function TEST_F (line 53) | TEST_F(ArenaStringTest, Small) {
function TEST_F (line 63) | TEST_F(ArenaStringTest, Large) {
function TEST_F (line 74) | TEST_F(ArenaStringTest, Iterator) {
function TEST_F (line 92) | TEST_F(ArenaStringTest, ReverseIterator) {
function TEST_F (line 110) | TEST_F(ArenaStringTest, RemovePrefix) {
function TEST_F (line 116) | TEST_F(ArenaStringTest, RemoveSuffix) {
function TEST_F (line 122) | TEST_F(ArenaStringTest, Equal) {
function TEST_F (line 126) | TEST_F(ArenaStringTest, NotEqual) {
function TEST_F (line 130) | TEST_F(ArenaStringTest, Less) {
function TEST_F (line 134) | TEST_F(ArenaStringTest, LessEqual) {
function TEST_F (line 138) | TEST_F(ArenaStringTest, Greater) {
function TEST_F (line 142) | TEST_F(ArenaStringTest, GreaterEqual) {
function TEST_F (line 146) | TEST_F(ArenaStringTest, ImplementsAbslHashCorrectly) {
function TEST_F (line 154) | TEST_F(ArenaStringTest, Hash) {
FILE: common/arena_string_view.h
function namespace (line 30) | namespace cel {
FILE: common/arena_string_view_test.cc
type cel (line 24) | namespace cel {
class ArenaStringViewTest (line 36) | class ArenaStringViewTest : public ::testing::Test {
method arena (line 38) | arena() { return &arena_; }
function TEST_F (line 44) | TEST_F(ArenaStringViewTest, Default) {
function TEST_F (line 51) | TEST_F(ArenaStringViewTest, Iterator) {
function TEST_F (line 69) | TEST_F(ArenaStringViewTest, ReverseIterator) {
function TEST_F (line 87) | TEST_F(ArenaStringViewTest, RemovePrefix) {
function TEST_F (line 93) | TEST_F(ArenaStringViewTest, RemoveSuffix) {
function TEST_F (line 99) | TEST_F(ArenaStringViewTest, Equal) {
function TEST_F (line 103) | TEST_F(ArenaStringViewTest, NotEqual) {
function TEST_F (line 107) | TEST_F(ArenaStringViewTest, Less) {
function TEST_F (line 111) | TEST_F(ArenaStringViewTest, LessEqual) {
function TEST_F (line 115) | TEST_F(ArenaStringViewTest, Greater) {
function TEST_F (line 119) | TEST_F(ArenaStringViewTest, GreaterEqual) {
function TEST_F (line 123) | TEST_F(ArenaStringViewTest, ImplementsAbslHashCorrectly) {
function TEST_F (line 131) | TEST_F(ArenaStringViewTest, Hash) {
FILE: common/ast.cc
type cel (line 24) | namespace cel {
function TypeSpec (line 27) | const TypeSpec& DynSingleton() {
function TypeSpec (line 34) | const TypeSpec* absl_nullable Ast::GetType(int64_t expr_id) const {
function TypeSpec (line 42) | const TypeSpec& Ast::GetTypeOrDyn(int64_t expr_id) const {
function TypeSpec (line 49) | const TypeSpec& Ast::GetReturnType() const {
function Reference (line 53) | const Reference* absl_nullable Ast::GetReference(int64_t expr_id) const {
function SourceLocation (line 61) | SourceLocation Ast::ComputeSourceLocation(int64_t expr_id) const {
FILE: common/ast.h
function namespace (line 29) | namespace cel {
FILE: common/ast/constant_proto.cc
type cel::ast_internal (line 31) | namespace cel::ast_internal {
function ConstantToProto (line 35) | absl::Status ConstantToProto(const Constant& constant,
function ConstantFromProto (line 81) | absl::Status ConstantFromProto(const ConstantProto& proto, Constant& c...
FILE: common/ast/constant_proto.h
function namespace (line 23) | namespace cel::ast_internal {
FILE: common/ast/expr_proto.cc
type cel::ast_internal (line 36) | namespace cel::ast_internal {
class ExprToProtoState (line 44) | class ExprToProtoState final {
type Frame (line 46) | struct Frame final {
method ExprToProto (line 52) | absl::Status ExprToProto(const Expr& expr,
method ExprToProtoImpl (line 63) | absl::Status ExprToProtoImpl(const Expr& expr,
method ConstExprToProto (line 102) | absl::Status ConstExprToProto(const Expr& expr, const Constant& cons...
method IdentExprToProto (line 109) | absl::Status IdentExprToProto(const Expr& expr, const IdentExpr& ide...
method SelectExprToProto (line 118) | absl::Status SelectExprToProto(const Expr& expr,
method CallExprToProto (line 132) | absl::Status CallExprToProto(const Expr& expr, const CallExpr& call_...
method ListExprToProto (line 151) | absl::Status ListExprToProto(const Expr& expr, const ListExpr& list_...
method StructExprToProto (line 173) | absl::Status StructExprToProto(const Expr& expr,
method MapExprToProto (line 198) | absl::Status MapExprToProto(const Expr& expr, const MapExpr& map_expr,
method ComprehensionExprToProto (line 223) | absl::Status ComprehensionExprToProto(
method Push (line 254) | void Push(const Expr& expr, ExprProto* absl_nonnull proto) {
method Pop (line 258) | bool Pop(Frame& frame) {
class ExprFromProtoState (line 270) | class ExprFromProtoState final {
type Frame (line 272) | struct Frame final {
method ExprFromProto (line 278) | absl::Status ExprFromProto(const ExprProto& proto, Expr& expr) {
method ExprFromProtoImpl (line 288) | absl::Status ExprFromProtoImpl(const ExprProto& proto, Expr& expr) {
method ConstExprFromProto (line 319) | absl::Status ConstExprFromProto(const ExprProto& proto,
method IdentExprFromProto (line 327) | absl::Status IdentExprFromProto(const ExprProto& proto,
method SelectExprFromProto (line 337) | absl::Status SelectExprFromProto(const ExprProto& proto,
method CallExprFromProto (line 351) | absl::Status CallExprFromProto(const ExprProto& proto,
method ListExprFromProto (line 369) | absl::Status ListExprFromProto(const ExprProto& proto,
method StructExprFromProto (line 389) | absl::Status StructExprFromProto(const ExprProto& proto,
method MapExprFromProto (line 421) | absl::Status MapExprFromProto(const ExprProto& proto,
method ComprehensionExprFromProto (line 454) | absl::Status ComprehensionExprFromProto(
method Push (line 485) | void Push(const ExprProto& proto, Expr& expr) {
method Pop (line 489) | bool Pop(Frame& frame) {
function ExprToProto (line 503) | absl::Status ExprToProto(const Expr& expr,
function ExprFromProto (line 509) | absl::Status ExprFromProto(const cel::expr::Expr& proto, Expr& expr) {
FILE: common/ast/expr_proto.h
function namespace (line 23) | namespace cel::ast_internal {
FILE: common/ast/expr_proto_test.cc
type cel::ast_internal (line 27) | namespace cel::ast_internal {
type ExprRoundtripTestCase (line 36) | struct ExprRoundtripTestCase {
function TEST_P (line 42) | TEST_P(ExprRoundTripTest, RoundTrip) {
function TEST (line 254) | TEST(ExprFromProto, StructFieldInMap) {
function TEST (line 276) | TEST(ExprFromProto, MapEntryInStruct) {
FILE: common/ast/metadata.cc
type cel (line 31) | namespace cel {
function TypeSpec (line 35) | const TypeSpec& DefaultTypeSpec() {
function FormatPrimitive (line 40) | std::string FormatPrimitive(PrimitiveType t) {
function FormatWellKnown (line 59) | std::string FormatWellKnown(WellKnownTypeSpec t) {
function HandleFormatTypeSpec (line 75) | void HandleFormatTypeSpec(const TypeSpec& t, FormatStack& stack,
function TypeSpecKind (line 130) | TypeSpecKind CopyImpl(const TypeSpecKind& other) {
function ExtensionSpec (line 153) | const ExtensionSpec& ExtensionSpec::DefaultInstance() {
function ExtensionSpec (line 165) | ExtensionSpec& ExtensionSpec::operator=(const ExtensionSpec& other) {
function TypeSpec (line 176) | const TypeSpec& ListTypeSpec::elem_type() const {
function TypeSpec (line 187) | const TypeSpec& MapTypeSpec::key_type() const {
function TypeSpec (line 194) | const TypeSpec& MapTypeSpec::value_type() const {
function TypeSpec (line 205) | const TypeSpec& FunctionTypeSpec::result_type() const {
function TypeSpec (line 216) | const TypeSpec& TypeSpec::type() const {
function TypeSpec (line 227) | TypeSpec& TypeSpec::operator=(const TypeSpec& other) {
function FunctionTypeSpec (line 236) | FunctionTypeSpec& FunctionTypeSpec::operator=(const FunctionTypeSpec& ...
function FormatTypeSpec (line 242) | std::string FormatTypeSpec(const TypeSpec& t) {
FILE: common/ast/metadata.h
function namespace (line 36) | namespace cel {
function PrimitiveType (line 279) | enum class PrimitiveType {
function class (line 557) | class TypeSpec {
function PrimitiveType (line 644) | PrimitiveType wrapper() const {
function ErrorTypeSpec (line 708) | ErrorTypeSpec error_type() const {
function class (line 747) | class Reference {
function ListTypeSpec (line 819) | inline ListTypeSpec::ListTypeSpec(const ListTypeSpec& rhs)
function ListTypeSpec (line 827) | inline ListTypeSpec::ListTypeSpec(std::unique_ptr<TypeSpec> elem_type)
function set_elem_type (line 830) | inline void ListTypeSpec::set_elem_type(std::unique_ptr<TypeSpec> elem_t...
function TypeSpec (line 834) | inline TypeSpec& ListTypeSpec::mutable_elem_type() {
function MapTypeSpec (line 841) | inline MapTypeSpec::MapTypeSpec(std::unique_ptr<TypeSpec> key_type,
function MapTypeSpec (line 845) | inline MapTypeSpec::MapTypeSpec(const MapTypeSpec& rhs)
function set_key_type (line 855) | inline void MapTypeSpec::set_key_type(std::unique_ptr<TypeSpec> key_type) {
function set_value_type (line 859) | inline void MapTypeSpec::set_value_type(std::unique_ptr<TypeSpec> value_...
function TypeSpec (line 863) | inline TypeSpec& MapTypeSpec::mutable_key_type() {
function TypeSpec (line 870) | inline TypeSpec& MapTypeSpec::mutable_value_type() {
function set_result_type (line 877) | inline void FunctionTypeSpec::set_result_type(
function TypeSpec (line 882) | inline TypeSpec& FunctionTypeSpec::mutable_result_type() {
function FunctionTypeSpec (line 893) | inline FunctionTypeSpec::FunctionTypeSpec(std::unique_ptr<TypeSpec> resu...
function set_arg_types (line 897) | inline void FunctionTypeSpec::set_arg_types(std::vector<TypeSpec> arg_ty...
function AbstractType (line 901) | inline AbstractType::AbstractType(std::string name,
function set_parameter_types (line 905) | inline void AbstractType::set_parameter_types(
function other (line 910) | inline bool AbstractType::operator==(const AbstractType& other) const {
FILE: common/ast/metadata_test.cc
type cel (line 25) | namespace cel {
function TEST (line 30) | TEST(AstTest, ListTypeSpecMutableConstruction) {
function TEST (line 37) | TEST(AstTest, MapTypeSpecMutableConstruction) {
function TEST (line 47) | TEST(AstTest, MapTypeSpecComparatorKeyType) {
function TEST (line 53) | TEST(AstTest, MapTypeSpecComparatorValueType) {
function TEST (line 59) | TEST(AstTest, FunctionTypeSpecMutableConstruction) {
function TEST (line 66) | TEST(AstTest, FunctionTypeSpecComparatorArgTypes) {
function TEST (line 72) | TEST(AstTest, ListTypeSpecDefaults) {
function TEST (line 76) | TEST(AstTest, MapTypeSpecDefaults) {
function TEST (line 81) | TEST(AstTest, FunctionTypeSpecDefaults) {
function TEST (line 85) | TEST(AstTest, TypeDefaults) {
function TEST (line 101) | TEST(AstTest, TypeComparatorTest) {
function TEST (line 113) | TEST(AstTest, ExprMutableConstruction) {
function TEST (line 143) | TEST(AstTest, ReferenceConstantDefaultValue) {
function TEST (line 148) | TEST(AstTest, TypeCopyable) {
function TEST (line 179) | TEST(AstTest, TypeMoveable) {
function TEST (line 215) | TEST(AstTest, NestedTypeKindCopyAssignable) {
function TEST (line 243) | TEST(AstTest, ExtensionSupported) {
function TEST (line 253) | TEST(AstTest, ExtensionSpecEquality) {
function TEST (line 269) | TEST(AstTest, ExtensionCopyMove) {
FILE: common/ast/navigable_ast_internal.h
function namespace (line 30) | namespace cel::common_internal {
function explicit (line 104) | explicit NavigableAstRange(SpanType span) : span_(span) {}
function AstNode (line 154) | static const AstNode& Adapt(const AstNode* const node) { return *node; }
function AstNode (line 160) | static const AstNode& Adapt(const std::unique_ptr<AstNode>& node) {
function Derived (line 179) | const Derived* absl_nullable parent() const { return data_.parent; }
function ExprType (line 181) | const ExprType* absl_nonnull expr() const { return data_.expr; }
function PreorderRange (line 205) | PreorderRange DescendantsPreorder() const {
function NodeType (line 265) | const NodeType* absl_nullable FindExpr(
function explicit (line 303) | explicit NavigableAstBase(std::unique_ptr<MetadataType> metadata)
FILE: common/ast/navigable_ast_internal_test.cc
type cel::common_internal (line 25) | namespace cel::common_internal {
type TestRangeTraits (line 28) | struct TestRangeTraits {
method Adapt (line 30) | static double Adapt(const UnderlyingType& value) {
function TEST (line 35) | TEST(NavigableAstRangeTest, BasicIteration) {
function TEST (line 50) | TEST(NodeKind, Stringify) {
function TEST (line 67) | TEST(ChildKind, Stringify) {
FILE: common/ast/navigable_ast_kinds.cc
type cel (line 20) | namespace cel {
function ChildKindName (line 22) | std::string ChildKindName(ChildKind kind) {
function NodeKindName (line 55) | std::string NodeKindName(NodeKind kind) {
FILE: common/ast/navigable_ast_kinds.h
type class (line 25) | enum class
function NodeKind (line 42) | enum class NodeKind {
FILE: common/ast/source_info_proto.cc
type cel::ast_internal (line 30) | namespace cel::ast_internal {
function SourceInfoToProto (line 39) | absl::Status SourceInfoToProto(const cel::SourceInfo& source_info,
FILE: common/ast/source_info_proto.h
function namespace (line 23) | namespace cel::ast_internal {
FILE: common/ast_proto.cc
type cel (line 41) | namespace cel {
function ExprValueFromProto (line 58) | absl::StatusOr<Expr> ExprValueFromProto(const ExprPb& expr) {
function ConvertProtoSourceInfoToNative (line 64) | absl::StatusOr<SourceInfo> ConvertProtoSourceInfoToNative(
function ToNative (line 113) | absl::StatusOr<PrimitiveType> ToNative(
function ToNative (line 137) | absl::StatusOr<WellKnownTypeSpec> ToNative(
function ToNative (line 155) | absl::StatusOr<ListTypeSpec> ToNative(
function ToNative (line 165) | absl::StatusOr<MapTypeSpec> ToNative(
function ToNative (line 180) | absl::StatusOr<FunctionTypeSpec> ToNative(
function ToNative (line 200) | absl::StatusOr<AbstractType> ToNative(
function ConvertProtoTypeToNative (line 213) | absl::StatusOr<TypeSpec> ConvertProtoTypeToNative(
function ConvertProtoReferenceToNative (line 294) | absl::StatusOr<Reference> ConvertProtoReferenceToNative(
function ReferenceToProto (line 309) | absl::StatusOr<ReferencePb> ReferenceToProto(const Reference& referenc...
type TypeKindToProtoVisitor (line 328) | struct TypeKindToProtoVisitor {
function TypeToProto (line 458) | absl::Status TypeToProto(const TypeSpec& type, TypePb* result) {
function CreateAstFromParsedExpr (line 464) | absl::StatusOr<std::unique_ptr<Ast>> CreateAstFromParsedExpr(
function CreateAstFromParsedExpr (line 477) | absl::StatusOr<std::unique_ptr<Ast>> CreateAstFromParsedExpr(
function AstToParsedExpr (line 483) | absl::Status AstToParsedExpr(const Ast& ast,
function CreateAstFromCheckedExpr (line 493) | absl::StatusOr<std::unique_ptr<Ast>> CreateAstFromCheckedExpr(
function AstToCheckedExpr (line 521) | absl::Status AstToCheckedExpr(
FILE: common/ast_proto.h
function namespace (line 27) | namespace cel {
FILE: common/ast_proto_test.cc
type cel (line 50) | namespace cel {
function ConvertProtoTypeToNative (line 64) | absl::StatusOr<TypeSpec> ConvertProtoTypeToNative(
function TEST (line 81) | TEST(AstConvertersTest, PrimitiveTypeUnspecifiedToNative) {
function TEST (line 91) | TEST(AstConvertersTest, PrimitiveTypeBoolToNative) {
function TEST (line 101) | TEST(AstConvertersTest, PrimitiveTypeInt64ToNative) {
function TEST (line 111) | TEST(AstConvertersTest, PrimitiveTypeUint64ToNative) {
function TEST (line 121) | TEST(AstConvertersTest, PrimitiveTypeDoubleToNative) {
function TEST (line 131) | TEST(AstConvertersTest, PrimitiveTypeStringToNative) {
function TEST (line 141) | TEST(AstConvertersTest, PrimitiveTypeBytesToNative) {
function TEST (line 151) | TEST(AstConvertersTest, PrimitiveTypeError) {
function TEST (line 163) | TEST(AstConvertersTest, WellKnownTypeUnspecifiedToNative) {
function TEST (line 174) | TEST(AstConvertersTest, WellKnownTypeAnyToNative) {
function TEST (line 184) | TEST(AstConvertersTest, WellKnownTypeTimestampToNative) {
function TEST (line 194) | TEST(AstConvertersTest, WellKnownTypeDuraionToNative) {
function TEST (line 204) | TEST(AstConvertersTest, WellKnownTypeError) {
function TEST (line 216) | TEST(AstConvertersTest, ListTypeToNative) {
function TEST (line 229) | TEST(AstConvertersTest, MapTypeToNative) {
function TEST (line 250) | TEST(AstConvertersTest, FunctionTypeToNative) {
function TEST (line 277) | TEST(AstConvertersTest, AbstractTypeToNative) {
function TEST (line 302) | TEST(AstConvertersTest, DynamicTypeToNative) {
function TEST (line 311) | TEST(AstConvertersTest, NullTypeToNative) {
function TEST (line 321) | TEST(AstConvertersTest, PrimitiveTypeWrapperToNative) {
function TEST (line 331) | TEST(AstConvertersTest, MessageTypeToNative) {
function TEST (line 341) | TEST(AstConvertersTest, ParamTypeToNative) {
function TEST (line 351) | TEST(AstConvertersTest, NestedTypeToNative) {
function TEST (line 361) | TEST(AstConvertersTest, TypeTypeDefault) {
function TEST (line 368) | TEST(AstConvertersTest, ReferenceToNative) {
function TEST (line 394) | TEST(AstConvertersTest, SourceInfoToNative) {
function TEST (line 424) | TEST(AstConvertersTest, CheckedExprToAst) {
function TEST (line 463) | TEST(AstConvertersTest, AstToCheckedExprBasic) {
type CheckedExprToAstTypesTestCase (line 550) | struct CheckedExprToAstTypesTestCase {
class CheckedExprToAstTypesTest (line 554) | class CheckedExprToAstTypesTest
method SetUp (line 557) | void SetUp() override {
function TEST_P (line 566) | TEST_P(CheckedExprToAstTypesTest, CheckedExprToAstTypes) {
function TEST (line 627) | TEST(AstConvertersTest, ParsedExprToAst) {
function TEST (line 650) | TEST(AstConvertersTest, AstToParsedExprBasic) {
function TEST (line 692) | TEST(AstConvertersTest, ExprToAst) {
function TEST (line 703) | TEST(AstConvertersTest, ExprAndSourceInfoToAst) {
function TEST (line 730) | TEST(AstConvertersTest, EmptyNodeRoundTrip) {
function TEST (line 754) | TEST(AstConvertersTest, DurationConstantRoundTrip) {
function TEST (line 776) | TEST(AstConvertersTest, TimestampConstantRoundTrip) {
type ConversionRoundTripCase (line 797) | struct ConversionRoundTripCase {
class ConversionRoundTripTest (line 801) | class ConversionRoundTripTest
method ConversionRoundTripTest (line 804) | ConversionRoundTripTest() {
method ParseToProto (line 821) | absl::StatusOr<ParsedExpr> ParseToProto(absl::string_view expr) {
method CompileToProto (line 831) | absl::StatusOr<CheckedExpr> CompileToProto(absl::string_view expr) {
function TEST_P (line 847) | TEST_P(ConversionRoundTripTest, ParsedExprCopyable) {
function TEST_P (line 862) | TEST_P(ConversionRoundTripTest, ExprCopyable) {
function TEST_P (line 880) | TEST_P(ConversionRoundTripTest, CheckedExprRoundTrip) {
function TEST_P (line 892) | TEST_P(ConversionRoundTripTest, CheckedExprCopyRoundTrip) {
function TEST (line 925) | TEST(ExtensionConversionRoundTripTest, RoundTrip) {
FILE: common/ast_rewrite.cc
type cel (line 27) | namespace cel {
type ArgRecord (line 31) | struct ArgRecord {
type ComprehensionRecord (line 41) | struct ComprehensionRecord {
type ExprRecord (line 51) | struct ExprRecord {
type StackRecord (line 59) | struct StackRecord {
method StackRecord (line 63) | explicit StackRecord(Expr* e) {
method StackRecord (line 69) | StackRecord(Expr* e, ComprehensionExpr* comprehension,
method StackRecord (line 89) | StackRecord(Expr* e, const Expr* call, int argnum) {
method Expr (line 97) | Expr* expr() const { return absl::get<ExprRecord>(record_variant).ex...
method IsExprRecord (line 99) | bool IsExprRecord() const {
type PreVisitor (line 107) | struct PreVisitor {
function PreVisit (line 156) | void PreVisit(const StackRecord& record, AstVisitor* visitor) {
type PostVisitor (line 160) | struct PostVisitor {
function PostVisit (line 215) | void PostVisit(const StackRecord& record, AstVisitor* visitor) {
function PushSelectDeps (line 219) | void PushSelectDeps(SelectExpr* select_expr, std::stack<StackRecord>* ...
function PushCallDeps (line 225) | void PushCallDeps(CallExpr* call_expr, Expr* expr,
function PushListDeps (line 240) | void PushListDeps(ListExpr* list_expr, std::stack<StackRecord>* stack) {
function PushStructDeps (line 248) | void PushStructDeps(StructExpr* struct_expr, std::stack<StackRecord>* ...
function PushMapDeps (line 260) | void PushMapDeps(MapExpr* struct_expr, std::stack<StackRecord>* stack) {
function PushComprehensionDeps (line 277) | void PushComprehensionDeps(ComprehensionExpr* c, Expr* expr,
type PushDepsVisitor (line 298) | struct PushDepsVisitor {
function PushDependencies (line 343) | void PushDependencies(const StackRecord& record, std::stack<StackRecor...
function AstRewrite (line 350) | bool AstRewrite(Expr& expr, AstRewriter& visitor,
FILE: common/ast_rewrite.h
function namespace (line 24) | namespace cel {
FILE: common/ast_rewrite_test.cc
type cel (line 32) | namespace cel {
class MockAstRewriter (line 44) | class MockAstRewriter : public AstRewriter {
function TEST (line 115) | TEST(AstCrawlerTest, CheckCrawlConstant) {
function TEST (line 126) | TEST(AstCrawlerTest, CheckCrawlIdent) {
function TEST (line 138) | TEST(AstCrawlerTest, CheckCrawlSelectNotCrashingPostVisitAbsentOperand) {
function TEST (line 151) | TEST(AstCrawlerTest, CheckCrawlSelect) {
function TEST (line 169) | TEST(AstCrawlerTest, CheckCrawlCallNoReceiver) {
function TEST (line 205) | TEST(AstCrawlerTest, CheckCrawlCallReceiver) {
function TEST (line 247) | TEST(AstCrawlerTest, CheckCrawlComprehension) {
function TEST (line 327) | TEST(AstCrawlerTest, CheckCrawlComprehensionLegacyCallbacks) {
function TEST (line 378) | TEST(AstCrawlerTest, CheckList) {
function TEST (line 399) | TEST(AstCrawlerTest, CheckStruct) {
function TEST (line 418) | TEST(AstCrawlerTest, CheckMap) {
function TEST (line 439) | TEST(AstCrawlerTest, CheckExprHandlers) {
function TEST (line 456) | TEST(AstCrawlerTest, CheckExprRewriteHandlers) {
class RewriterExample (line 496) | class RewriterExample : public AstRewriterBase {
method RewriterExample (line 498) | RewriterExample() {}
method PostVisitRewrite (line 499) | bool PostVisitRewrite(Expr& expr) override {
method PostVisitIdent (line 507) | void PostVisitIdent(const Expr& expr, const IdentExpr& ident) overri...
method TraversalStackUpdate (line 522) | void TraversalStackUpdate(absl::Span<const Expr*> path) override {
function TEST (line 531) | TEST(AstRewrite, SelectRewriteExample) {
class PreRewriterExample (line 555) | class PreRewriterExample : public AstRewriterBase {
method PreRewriterExample (line 557) | PreRewriterExample() {}
method PreVisitRewrite (line 558) | bool PreVisitRewrite(Expr& expr) override {
method PostVisitRewrite (line 566) | bool PostVisitRewrite(Expr& expr) override {
method PostVisitIdent (line 574) | void PostVisitIdent(const Expr& expr, const IdentExpr& ident) overri...
function TEST (line 586) | TEST(AstRewrite, PreAndPostVisitExpample) {
FILE: common/ast_test.cc
type cel (line 24) | namespace cel {
function TEST (line 30) | TEST(AstImpl, RawExprCtor) {
function TEST (line 67) | TEST(AstImpl, CheckedExprCtor) {
function TEST (line 96) | TEST(AstImpl, CheckedExprDeepCopy) {
function TEST (line 136) | TEST(AstImpl, ComputeSourceLocation) {
function TEST (line 156) | TEST(AstImpl, ComputeSourceLocationFailures) {
function TEST (line 171) | TEST(AstImpl, ComputeSourceLocationInvalidLineOffsets) {
FILE: common/ast_traverse.cc
type cel (line 26) | namespace cel {
type ArgRecord (line 30) | struct ArgRecord {
type ComprehensionRecord (line 40) | struct ComprehensionRecord {
type ExprRecord (line 50) | struct ExprRecord {
type StackRecord (line 58) | struct StackRecord {
method StackRecord (line 62) | explicit StackRecord(const Expr* e) {
method StackRecord (line 68) | StackRecord(const Expr* e, const ComprehensionExpr* comprehension,
method StackRecord (line 89) | StackRecord(const Expr* e, const Expr* call, int argnum) {
type PreVisitor (line 100) | struct PreVisitor {
function PreVisit (line 127) | void PreVisit(const StackRecord& record, AstVisitor* visitor) {
type PostVisitor (line 131) | struct PostVisitor {
function PostVisit (line 187) | void PostVisit(const StackRecord& record, AstVisitor* visitor) {
function PushSelectDeps (line 191) | void PushSelectDeps(const SelectExpr* select_expr,
function PushCallDeps (line 198) | void PushCallDeps(const CallExpr* call_expr, const Expr* expr,
function PushListDeps (line 212) | void PushListDeps(const ListExpr* list_expr, std::stack<StackRecord>* ...
function PushStructDeps (line 220) | void PushStructDeps(const StructExpr* struct_expr,
function PushMapDeps (line 233) | void PushMapDeps(const MapExpr* map_expr, std::stack<StackRecord>* sta...
function PushComprehensionDeps (line 250) | void PushComprehensionDeps(const ComprehensionExpr* c, const Expr* expr,
type PushDepsVisitor (line 271) | struct PushDepsVisitor {
function PushDependencies (line 315) | void PushDependencies(const StackRecord& record, std::stack<StackRecor...
type common_internal (line 322) | namespace common_internal {
type AstTraversalState (line 323) | struct AstTraversalState {
function AstTraversal (line 328) | AstTraversal AstTraversal::Create(const cel::Expr& ast,
function AstTraverse (line 362) | void AstTraverse(const Expr& expr, AstVisitor& visitor,
FILE: common/ast_traverse.h
function namespace (line 24) | namespace cel {
FILE: common/ast_traverse_test.cc
type cel::ast_internal (line 22) | namespace cel::ast_internal {
class MockAstVisitor (line 29) | class MockAstVisitor : public AstVisitor {
function TEST (line 93) | TEST(AstCrawlerTest, CheckCrawlConstant) {
function TEST (line 104) | TEST(AstCrawlerTest, CheckCrawlIdent) {
function TEST (line 116) | TEST(AstCrawlerTest, CheckCrawlSelectNotCrashingPostVisitAbsentOperand) {
function TEST (line 129) | TEST(AstCrawlerTest, CheckCrawlSelect) {
function TEST (line 147) | TEST(AstCrawlerTest, CheckCrawlCallNoReceiver) {
function TEST (line 183) | TEST(AstCrawlerTest, CheckCrawlCallReceiver) {
function TEST (line 225) | TEST(AstCrawlerTest, CheckCrawlComprehension) {
function TEST (line 305) | TEST(AstCrawlerTest, CheckCrawlComprehensionLegacyCallbacks) {
function TEST (line 356) | TEST(AstCrawlerTest, CheckList) {
function TEST (line 377) | TEST(AstCrawlerTest, CheckStruct) {
function TEST (line 396) | TEST(AstCrawlerTest, CheckMap) {
function TEST (line 417) | TEST(AstCrawlerTest, CheckExprHandlers) {
function TEST (line 433) | TEST(AstTraversal, Interrupt) {
function TEST (line 457) | TEST(AstTraversal, NoInterrupt) {
FILE: common/ast_visitor.h
function namespace (line 21) | namespace cel {
FILE: common/ast_visitor_base.h
function namespace (line 22) | namespace cel {
FILE: common/casting.h
function namespace (line 21) | namespace cel {
FILE: common/constant.cc
type cel (line 28) | namespace cel {
function BytesConstant (line 30) | const BytesConstant& BytesConstant::default_instance() {
function StringConstant (line 35) | const StringConstant& StringConstant::default_instance() {
function Constant (line 40) | const Constant& Constant::default_instance() {
function FormatNullConstant (line 45) | std::string FormatNullConstant() { return "null"; }
function FormatBoolConstant (line 47) | std::string FormatBoolConstant(bool value) {
function FormatIntConstant (line 51) | std::string FormatIntConstant(int64_t value) { return absl::StrCat(val...
function FormatUintConstant (line 53) | std::string FormatUintConstant(uint64_t value) {
function FormatDoubleConstant (line 57) | std::string FormatDoubleConstant(double value) {
function FormatBytesConstant (line 82) | std::string FormatBytesConstant(absl::string_view value) {
function FormatStringConstant (line 86) | std::string FormatStringConstant(absl::string_view value) {
function FormatDurationConstant (line 90) | std::string FormatDurationConstant(absl::Duration value) {
function FormatTimestampConstant (line 94) | std::string FormatTimestampConstant(absl::Time value) {
FILE: common/constant.h
function namespace (line 30) | namespace cel {
function ConstantKindCase (line 143) | enum class ConstantKindCase {
function std (line 163) | inline std::string FormatNullConstant(std::nullptr_t) {
function explicit (line 212) | explicit Constant(ConstantKind kind) : kind_(std::move(kind)) {}
function ABSL_MUST_USE_RESULT (line 214) | ABSL_MUST_USE_RESULT const ConstantKind& kind() const
function ABSL_MUST_USE_RESULT (line 229) | ABSL_MUST_USE_RESULT bool has_null_value() const {
function set_null_value (line 235) | void set_null_value() { mutable_kind().emplace<std::nullptr_t>(); }
function set_null_value (line 237) | void set_null_value(std::nullptr_t) { set_null_value(); }
function ABSL_MUST_USE_RESULT (line 239) | ABSL_MUST_USE_RESULT bool has_bool_value() const {
function ABSL_MUST_USE_RESULT (line 247) | ABSL_MUST_USE_RESULT bool has_int_value() const {
function ABSL_MUST_USE_RESULT (line 257) | ABSL_MUST_USE_RESULT bool has_uint_value() const {
function set_int64_value (line 273) | void set_int64_value(int64_t value) { set_int_value(value); }
function set_uint64_value (line 284) | void set_uint64_value(uint64_t value) { set_uint_value(value); }
function ABSL_MUST_USE_RESULT (line 289) | ABSL_MUST_USE_RESULT bool has_double_value() const {
function ABSL_MUST_USE_RESULT (line 299) | ABSL_MUST_USE_RESULT bool has_bytes_value() const {
function set_bytes_value (line 307) | void set_bytes_value(std::string value) {
function set_bytes_value (line 311) | void set_bytes_value(absl::string_view value) {
function set_bytes_value (line 315) | void set_bytes_value(const char* value) {
function ABSL_MUST_USE_RESULT (line 319) | ABSL_MUST_USE_RESULT const std::string& bytes_value() const
function ABSL_MUST_USE_RESULT (line 327) | ABSL_MUST_USE_RESULT std::string release_bytes_value() {
function ABSL_MUST_USE_RESULT (line 336) | ABSL_MUST_USE_RESULT bool has_string_value() const {
function set_string_value (line 344) | void set_string_value(std::string value) {
function set_string_value (line 348) | void set_string_value(absl::string_view value) {
function set_string_value (line 352) | void set_string_value(const char* value) {
function ABSL_MUST_USE_RESULT (line 356) | ABSL_MUST_USE_RESULT const std::string& string_value() const
function ABSL_MUST_USE_RESULT (line 364) | ABSL_MUST_USE_RESULT std::string release_string_value() {
function set_duration_value (line 379) | void set_duration_value(absl::Duration value) {
function set_timestamp_value (line 394) | void set_timestamp_value(absl::Time value) {
function set_time_value (line 409) | void set_time_value(absl::Time value) { set_timestamp_value(value); }
function ConstantKindCase (line 416) | ConstantKindCase kind_case() const {
function ABSL_MUST_USE_RESULT (line 430) | ABSL_MUST_USE_RESULT ConstantKind& mutable_kind()
FILE: common/constant_test.cc
type cel (line 27) | namespace cel {
function TEST (line 34) | TEST(Constant, NullValue) {
function TEST (line 43) | TEST(Constant, BoolValue) {
function TEST (line 54) | TEST(Constant, IntValue) {
function TEST (line 65) | TEST(Constant, UintValue) {
function TEST (line 76) | TEST(Constant, DoubleValue) {
function TEST (line 87) | TEST(Constant, BytesValue) {
function TEST (line 98) | TEST(Constant, StringValue) {
function TEST (line 109) | TEST(Constant, DurationValue) {
function TEST (line 120) | TEST(Constant, TimestampValue) {
function TEST (line 131) | TEST(Constant, DefaultConstructed) {
function TEST (line 136) | TEST(Constant, Equality) {
function Stringify (line 246) | std::string Stringify(const Constant& constant) {
function TEST (line 250) | TEST(Constant, HasAbslStringify) {
function TEST (line 254) | TEST(Constant, AbslStringify) {
FILE: common/container.cc
type cel (line 26) | namespace cel {
function IsValidQualifiedName (line 29) | bool IsValidQualifiedName(absl::string_view name) {
function IsValidAlias (line 41) | bool IsValidAlias(absl::string_view alias) {
function IsAbbreviationImpl (line 45) | bool IsAbbreviationImpl(absl::string_view alias, absl::string_view nam...
function MakeExpressionContainer (line 57) | absl::StatusOr<ExpressionContainer> MakeExpressionContainer(
FILE: common/container.h
function namespace (line 26) | namespace cel {
FILE: common/container_test.cc
type cel (line 20) | namespace cel {
function TEST (line 30) | TEST(ExpressionContainerTest, DefaultConstructed) {
function TEST (line 36) | TEST(ExpressionContainerTest, MakeExpressionContainer) {
function TEST (line 45) | TEST(ExpressionContainerTest, MakeExpressionContainerWithAbbrevs) {
function TEST (line 57) | TEST(ExpressionContainerTest, SetContainer) {
function TEST (line 67) | TEST(ExpressionContainerTest, AddAlias) {
function TEST (line 74) | TEST(ExpressionContainerTest, AddAbbreviation) {
function TEST (line 81) | TEST(ExpressionContainerTest, ListAbbreviationsAndAliases) {
function TEST (line 94) | TEST(ExpressionContainerTest, InvalidAbbreviation) {
function TEST (line 107) | TEST(ExpressionContainerTest, InvalidAlias) {
function TEST (line 118) | TEST(ExpressionContainerTest, CollidesWithContainer) {
FILE: common/data.h
function namespace (line 26) | namespace cel {
FILE: common/data_test.cc
type cel (line 27) | namespace cel {
class DataTest (line 32) | class DataTest final : public Data {
method DataTest (line 34) | DataTest() noexcept : Data() {}
method DataTest (line 36) | explicit DataTest(google::protobuf::Arena* absl_nullable arena) noex...
class DataReferenceCount (line 40) | class DataReferenceCount final : public common_internal::ReferenceCoun...
method DataReferenceCount (line 42) | explicit DataReferenceCount(const Data* data) : data_(data) {}
method Finalize (line 45) | void Finalize() noexcept override { delete data_; }
function TEST (line 50) | TEST(Data, Arena) {
function TEST (line 57) | TEST(Data, ReferenceCount) {
FILE: common/decl.cc
type cel (line 33) | namespace cel {
type common_internal (line 35) | namespace common_internal {
function TypeIsAssignable (line 37) | bool TypeIsAssignable(const Type& to, const Type& from) {
function SignaturesOverlap (line 89) | bool SignaturesOverlap(const OverloadDecl& lhs, const OverloadDecl& rh...
function AddOverloadInternal (line 110) | void AddOverloadInternal(std::string_view function_name,
function CollectTypeParams (line 151) | void CollectTypeParams(absl::flat_hash_set<std::string>& type_params,
FILE: common/decl.h
function namespace (line 37) | namespace cel {
function ABSL_MUST_USE_RESULT (line 146) | ABSL_MUST_USE_RESULT const std::string& id() const
function set_id (line 153) | void set_id(absl::string_view id) { id_.assign(id.data(), id.size()); }
function set_id (line 155) | void set_id(const char* id) { set_id(absl::NullSafeStringView(id)); }
function ABSL_MUST_USE_RESULT (line 157) | ABSL_MUST_USE_RESULT std::string release_id() {
function ABSL_MUST_USE_RESULT (line 163) | ABSL_MUST_USE_RESULT const std::vector<Type>& args() const
function ABSL_MUST_USE_RESULT (line 173) | ABSL_MUST_USE_RESULT std::vector<Type> release_args() {
function ABSL_MUST_USE_RESULT (line 179) | ABSL_MUST_USE_RESULT const Type& result() const
function set_result (line 188) | void set_result(Type result) { mutable_result() = std::move(result); }
function set_member (line 192) | void set_member(bool member) { member_ = member; }
function const (line 267) | struct OverloadDeclHash {
function const (line 277) | struct OverloadDeclEqualTo {
function const (line 288) | bool operator()(absl::string_view lhs, const OverloadDecl& rhs) const {
function const (line 292) | bool operator()(absl::string_view lhs, absl::string_view rhs) const {
function ABSL_MUST_USE_RESULT (line 313) | ABSL_MUST_USE_RESULT const std::string& name() const
function set_name (line 320) | void set_name(absl::string_view name) {
function set_name (line 324) | void set_name(const char* name) { set_name(absl::NullSafeStringView(name...
function ABSL_MUST_USE_RESULT (line 326) | ABSL_MUST_USE_RESULT std::string release_name() {
type Overloads (line 357) | struct Overloads {
function namespace (line 400) | namespace common_internal {
FILE: common/decl_proto.cc
type cel (line 33) | namespace cel {
function VariableDeclFromProto (line 35) | absl::StatusOr<VariableDecl> VariableDeclFromProto(
function FunctionDeclFromProto (line 44) | absl::StatusOr<FunctionDecl> FunctionDeclFromProto(
function DeclFromProto (line 72) | absl::StatusOr<absl::variant<VariableDecl, FunctionDecl>> DeclFromProto(
FILE: common/decl_proto.h
function namespace (line 27) | namespace cel {
FILE: common/decl_proto_test.cc
type cel (line 30) | namespace cel {
type DeclType (line 35) | enum class DeclType { kVariable, kFunction, kInvalid }
type TestCase (line 37) | struct TestCase {
class DeclFromProtoTest (line 42) | class DeclFromProtoTest : public ::testing::TestWithParam<TestCase> {}
function TEST_P (line 44) | TEST_P(DeclFromProtoTest, FromProtoWorks) {
function TEST_P (line 74) | TEST_P(DeclFromProtoTest, FromV1Alpha1ProtoWorks) {
FILE: common/decl_proto_v1alpha1.cc
type cel (line 27) | namespace cel {
function VariableDeclFromV1Alpha1Proto (line 29) | absl::StatusOr<VariableDecl> VariableDeclFromV1Alpha1Proto(
function FunctionDeclFromV1Alpha1Proto (line 42) | absl::StatusOr<FunctionDecl> FunctionDeclFromV1Alpha1Proto(
function DeclFromV1Alpha1Proto (line 55) | absl::StatusOr<absl::variant<VariableDecl, FunctionDecl>> DeclFromV1Al...
FILE: common/decl_proto_v1alpha1.h
function namespace (line 29) | namespace cel {
FILE: common/decl_test.cc
type cel (line 28) | namespace cel {
function TEST (line 38) | TEST(VariableDecl, Name) {
function TEST (line 47) | TEST(VariableDecl, Type) {
function TEST (line 54) | TEST(VariableDecl, Value) {
function Constant (line 67) | Constant MakeBoolConstant(bool value) {
function TEST (line 73) | TEST(VariableDecl, Equality) {
function TEST (line 91) | TEST(OverloadDecl, Id) {
function TEST (line 100) | TEST(OverloadDecl, Result) {
function TEST (line 107) | TEST(OverloadDecl, Args) {
function TEST (line 116) | TEST(OverloadDecl, Member) {
function TEST (line 123) | TEST(OverloadDecl, Equality) {
function TEST (line 130) | TEST(OverloadDecl, GetTypeParams) {
function TEST (line 141) | TEST(FunctionDecl, Name) {
function TEST (line 150) | TEST(FunctionDecl, Overloads) {
function TEST (line 168) | TEST(FunctionDecl, OverloadId) {
function TEST (line 219) | TEST(TypeIsAssignable, BoolWrapper) {
function TEST (line 226) | TEST(TypeIsAssignable, IntWrapper) {
function TEST (line 233) | TEST(TypeIsAssignable, UintWrapper) {
function TEST (line 240) | TEST(TypeIsAssignable, DoubleWrapper) {
function TEST (line 247) | TEST(TypeIsAssignable, BytesWrapper) {
function TEST (line 254) | TEST(TypeIsAssignable, StringWrapper) {
function TEST (line 261) | TEST(TypeIsAssignable, Complex) {
FILE: common/expr.cc
type cel (line 26) | namespace cel {
type CopyStackRecord (line 30) | struct CopyStackRecord {
function CopyNode (line 35) | void CopyNode(CopyStackRecord element, std::vector<CopyStackRecord>& s...
function CloneImpl (line 136) | void CloneImpl(const Expr& expr, Expr& dst) {
function UnspecifiedExpr (line 148) | const UnspecifiedExpr& UnspecifiedExpr::default_instance() {
function IdentExpr (line 153) | const IdentExpr& IdentExpr::default_instance() {
function SelectExpr (line 158) | const SelectExpr& SelectExpr::default_instance() {
function CallExpr (line 163) | const CallExpr& CallExpr::default_instance() {
function ListExpr (line 168) | const ListExpr& ListExpr::default_instance() {
function StructExpr (line 173) | const StructExpr& StructExpr::default_instance() {
function MapExpr (line 178) | const MapExpr& MapExpr::default_instance() {
function ComprehensionExpr (line 183) | const ComprehensionExpr& ComprehensionExpr::default_instance() {
function Expr (line 188) | const Expr& Expr::default_instance() {
function Expr (line 193) | Expr& Expr::operator=(const Expr& other) {
type common_internal (line 205) | namespace common_internal {
type ExprEraseTag (line 206) | struct ExprEraseTag {}
function Expand (line 210) | void Expand(Expr** tail, Expr* cur) {
FILE: common/expr.h
function namespace (line 31) | namespace cel {
function class (line 106) | class IdentExpr final {
function class (line 169) | class SelectExpr final {
function class (line 260) | class CallExpr final {
function class (line 355) | class ListExprElement final {
function class (line 392) | class ListExpr final {
function class (line 442) | class StructExprField final {
function class (line 500) | class StructExpr final {
function class (line 574) | class MapExprEntry final {
function class (line 629) | class MapExpr final {
function class (line 681) | class ComprehensionExpr final {
function ExprKindCase (line 877) | enum class ExprKindCase {
function ABSL_MUST_USE_RESULT (line 1143) | ABSL_MUST_USE_RESULT inline std::unique_ptr<Expr>
function Expr (line 1148) | inline const Expr& SelectExpr::operand() const ABSL_ATTRIBUTE_LIFETIME_B...
function set_operand (line 1159) | inline void SelectExpr::set_operand(Expr operand) {
function set_operand (line 1163) | inline void SelectExpr::set_operand(std::unique_ptr<Expr> operand) {
function std (line 1167) | inline std::unique_ptr<Expr> SelectExpr::release(
function Clear (line 1174) | inline void ComprehensionExpr::Clear() {
function Expr (line 1184) | inline const Expr& ComprehensionExpr::iter_range() const
function set_iter_range (line 1197) | inline void ComprehensionExpr::set_iter_range(Expr iter_range) {
function set_iter_range (line 1201) | inline void ComprehensionExpr::set_iter_range(
function ABSL_MUST_USE_RESULT (line 1206) | ABSL_MUST_USE_RESULT inline std::unique_ptr<Expr>
function Expr (line 1211) | inline const Expr& ComprehensionExpr::accu_init() const
function Expr (line 1221) | inline Expr& ComprehensionExpr::mutable_accu_init()
function set_accu_init (line 1229) | inline void ComprehensionExpr::set_accu_init(Expr accu_init) {
function set_accu_init (line 1233) | inline void ComprehensionExpr::set_accu_init(std::unique_ptr<Expr> accu_...
function Expr (line 1237) | inline const Expr& ComprehensionExpr::loop_step() const
function set_loop_step (line 1250) | inline void ComprehensionExpr::set_loop_step(Expr loop_step) {
function set_loop_step (line 1254) | inline void ComprehensionExpr::set_loop_step(std::unique_ptr<Expr> loop_...
function ABSL_MUST_USE_RESULT (line 1258) | ABSL_MUST_USE_RESULT inline std::unique_ptr<Expr>
function Expr (line 1263) | inline const Expr& ComprehensionExpr::loop_condition() const
function Expr (line 1273) | inline Expr& ComprehensionExpr::mutable_loop_condition()
function set_loop_condition (line 1281) | inline void ComprehensionExpr::set_loop_condition(Expr loop_condition) {
function set_loop_condition (line 1285) | inline void ComprehensionExpr::set_loop_condition(
function Expr (line 1290) | inline const Expr& ComprehensionExpr::result() const
function set_result (line 1302) | inline void ComprehensionExpr::set_result(Expr result) {
function set_result (line 1306) | inline void ComprehensionExpr::set_result(std::unique_ptr<Expr> result) {
function ABSL_MUST_USE_RESULT (line 1310) | ABSL_MUST_USE_RESULT inline std::unique_ptr<Expr>
function std (line 1315) | inline std::unique_ptr<Expr> ComprehensionExpr::release(
function Clear (line 1348) | inline void MapExpr::Clear() { entries_.clear(); }
function set_entries (line 1350) | inline void MapExpr::set_entries(std::vector<MapExprEntry> entries) {
function set_entries (line 1354) | inline void MapExpr::set_entries(absl::Span<MapExprEntry> entries) {
function set_kind (line 1379) | inline void Expr::set_kind(ExprKind kind) { kind_ = std::move(kind); }
function set_call_expr (line 1387) | inline void Expr::set_call_expr(CallExpr call_expr) {
function set_list_expr (line 1395) | inline void Expr::set_list_expr(ListExpr list_expr) {
function ListExpr (line 1399) | inline ListExpr Expr::release_list_expr() { return release_kind<ListExpr...
function set_struct_expr (line 1401) | inline void Expr::set_struct_expr(StructExpr struct_expr) {
function StructExpr (line 1405) | inline StructExpr Expr::release_struct_expr() {
function set_map_expr (line 1409) | inline void Expr::set_map_expr(MapExpr map_expr) {
function MapExpr (line 1413) | inline MapExpr Expr::release_map_expr() { return release_kind<MapExpr>(); }
function T (line 1416) | T Expr::release_kind() {
function ExprKindCase (line 1425) | inline ExprKindCase Expr::kind_case() const {
function Clear (line 1439) | inline void CallExpr::Clear() {
function Expr (line 1445) | inline const Expr& CallExpr::target() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
function set_target (line 1456) | inline void CallExpr::set_target(Expr target) {
function set_target (line 1460) | inline void CallExpr::set_target(std::unique_ptr<Expr> target) {
function ABSL_MUST_USE_RESULT (line 1464) | ABSL_MUST_USE_RESULT inline std::unique_ptr<Expr> CallExpr::release_targ...
function set_args (line 1468) | inline void CallExpr::set_args(std::vector<Expr> args) {
function set_args (line 1472) | inline void CallExpr::set_args(absl::Span<Expr> args) {
function set_expr (line 1515) | inline void ListExprElement::set_expr(Expr expr) {
function set_expr (line 1519) | inline void ListExprElement::set_expr(std::unique_ptr<Expr> expr) {
function swap (line 1527) | inline void swap(ListExprElement& lhs, ListExprElement& rhs) noexcept {
function Expr (line 1533) | inline Expr ListExprElement::release(std::unique_ptr<Expr>& property) {
function Clear (line 1542) | inline void ListExpr::Clear() { elements_.clear(); }
function set_elements (line 1544) | inline void ListExpr::set_elements(std::vector<ListExprElement> elements) {
function set_elements (line 1548) | inline void ListExpr::set_elements(absl::Span<ListExprElement> elements) {
function set_value (line 1586) | inline void StructExprField::set_value(Expr value) {
function set_value (line 1590) | inline void StructExprField::set_value(std::unique_ptr<Expr> value) {
function swap (line 1598) | inline void swap(StructExprField& lhs, StructExprField& rhs) noexcept {
function Expr (line 1606) | inline Expr StructExprField::release(std::unique_ptr<Expr>& property) {
function Clear (line 1615) | inline void StructExpr::Clear() {
function set_fields (line 1620) | inline void StructExpr::set_fields(std::vector<StructExprField> fields) {
function set_fields (line 1624) | inline void StructExpr::set_fields(absl::Span<StructExprField> fields) {
function set_key (line 1662) | inline void MapExprEntry::set_key(Expr key) { mutable_key() = std::move(...
function set_key (line 1664) | inline void MapExprEntry::set_key(std::unique_ptr<Expr> key) {
function set_value (line 1685) | inline void MapExprEntry::set_value(Expr value) {
function set_value (line 1689) | inline void MapExprEntry::set_value(std::unique_ptr<Expr> value) {
function swap (line 1697) | inline void swap(MapExprEntry& lhs, MapExprEntry& rhs) noexcept {
function Expr (line 1705) | inline Expr MapExprEntry::release(std::unique_ptr<Expr>& property) {
function SetNext (line 1714) | inline void Expr::SetNext(common_internal::ExprEraseTag&, Expr* next) {
FILE: common/expr_factory.h
function namespace (line 31) | namespace cel {
function Expr (line 81) | Expr NewUnspecified(ExprId id) {
function Expr (line 87) | Expr NewConst(ExprId id, Constant value) {
function Expr (line 94) | Expr NewNullConst(ExprId id) {
function Expr (line 100) | Expr NewBoolConst(ExprId id, bool value) {
function Expr (line 106) | Expr NewIntConst(ExprId id, int64_t value) {
function Expr (line 112) | Expr NewUintConst(ExprId id, uint64_t value) {
function Expr (line 118) | Expr NewDoubleConst(ExprId id, double value) {
function Expr (line 124) | Expr NewBytesConst(ExprId id, BytesConstant value) {
function Expr (line 130) | Expr NewBytesConst(ExprId id, std::string value) {
function Expr (line 136) | Expr NewBytesConst(ExprId id, absl::string_view value) {
function Expr (line 142) | Expr NewBytesConst(ExprId id, const char* value) {
function Expr (line 148) | Expr NewStringConst(ExprId id, StringConstant value) {
function Expr (line 154) | Expr NewStringConst(ExprId id, std::string value) {
function Expr (line 160) | Expr NewStringConst(ExprId id, absl::string_view value) {
function Expr (line 166) | Expr NewStringConst(ExprId id, const char* value) {
function Expr (line 184) | Expr NewAccuIdent(ExprId id) { return NewIdent(id, AccuVarName()); }
function accu_var_ (line 359) | accu_var_(kAccumulatorVariableName) {}
FILE: common/expr_test.cc
type cel (line 21) | namespace cel {
function Expr (line 32) | Expr MakeUnspecifiedExpr(ExprId id) {
function ListExprElement (line 38) | ListExprElement MakeListExprElement(Expr expr, bool optional = false) {
function StructExprField (line 45) | StructExprField MakeStructExprField(ExprId id, const char* name, Expr ...
function MapExprEntry (line 55) | MapExprEntry MakeMapExprEntry(ExprId id, Expr key, Expr value,
function TEST (line 65) | TEST(UnspecifiedExpr, Equality) {
function TEST (line 69) | TEST(IdentExpr, Name) {
function TEST (line 79) | TEST(IdentExpr, Equality) {
function TEST (line 86) | TEST(SelectExpr, Operand) {
function TEST (line 98) | TEST(SelectExpr, Field) {
function TEST (line 108) | TEST(SelectExpr, TestOnly) {
function TEST (line 115) | TEST(SelectExpr, Equality) {
function TEST (line 122) | TEST(CallExpr, Function) {
function TEST (line 132) | TEST(CallExpr, Target) {
function TEST (line 144) | TEST(CallExpr, Args) {
function TEST (line 155) | TEST(CallExpr, Equality) {
function TEST (line 162) | TEST(ListExprElement, Expr) {
function TEST (line 174) | TEST(ListExprElement, Optional) {
function TEST (line 181) | TEST(ListExprElement, Equality) {
function TEST (line 188) | TEST(ListExpr, Elements) {
function TEST (line 201) | TEST(ListExpr, Equality) {
function TEST (line 209) | TEST(StructExprField, Id) {
function TEST (line 216) | TEST(StructExprField, Name) {
function TEST (line 226) | TEST(StructExprField, Value) {
function TEST (line 238) | TEST(StructExprField, Optional) {
function TEST (line 245) | TEST(StructExprField, Equality) {
function TEST (line 252) | TEST(StructExpr, Name) {
function TEST (line 262) | TEST(StructExpr, Fields) {
function TEST (line 275) | TEST(StructExpr, Equality) {
function TEST (line 283) | TEST(MapExprEntry, Id) {
function TEST (line 290) | TEST(MapExprEntry, Key) {
function TEST (line 303) | TEST(MapExprEntry, Value) {
function TEST (line 316) | TEST(MapExprEntry, Optional) {
function TEST (line 323) | TEST(MapExprEntry, Equality) {
function TEST (line 330) | TEST(MapExpr, Entries) {
function TEST (line 343) | TEST(MapExpr, Equality) {
function TEST (line 351) | TEST(ComprehensionExpr, IterVar) {
function TEST (line 361) | TEST(ComprehensionExpr, IterRange) {
function TEST (line 373) | TEST(ComprehensionExpr, AccuVar) {
function TEST (line 383) | TEST(ComprehensionExpr, AccuInit) {
function TEST (line 395) | TEST(ComprehensionExpr, LoopCondition) {
function TEST (line 407) | TEST(ComprehensionExpr, LoopStep) {
function TEST (line 419) | TEST(ComprehensionExpr, Result) {
function TEST (line 431) | TEST(ComprehensionExpr, Equality) {
function TEST (line 438) | TEST(Expr, Unspecified) {
function TEST (line 446) | TEST(Expr, Ident) {
function TEST (line 462) | TEST(Expr, Select) {
function TEST (line 478) | TEST(Expr, Call) {
function TEST (line 494) | TEST(Expr, List) {
function TEST (line 510) | TEST(Expr, Struct) {
function TEST (line 526) | TEST(Expr, Map) {
function TEST (line 542) | TEST(Expr, Comprehension) {
function TEST (line 558) | TEST(Expr, CopyCtor) {
function TEST (line 568) | TEST(Expr, CopyAssignChildReference) {
function TEST (line 583) | TEST(Expr, FlattenedErase) {
function Expr (line 641) | Expr MakeNestedList(int size) {
function TEST (line 655) | TEST(Expr, FlattenedErase256k) {
function TEST (line 666) | TEST(Expr, Id) {
FILE: common/function_descriptor.cc
type cel (line 24) | namespace cel {
FILE: common/function_descriptor.h
function namespace (line 27) | namespace cel {
FILE: common/internal/byte_string.cc
type cel::common_internal (line 39) | namespace cel::common_internal {
function T (line 52) | T ConsumeAndDestroy(T& object) {
function ByteString (line 60) | ByteString ByteString::Concat(const ByteString& lhs, const ByteString&...
function ByteString (line 147) | ByteString ByteString::Borrowed(Borrower borrower, absl::string_view s...
function ByteString (line 165) | ByteString ByteString::Borrowed(Borrower borrower, const absl::Cord& c...
function ByteString (line 186) | ByteString ByteString::FromExternal(absl::string_view string) {
function ByteString (line 377) | ByteString ByteString::Substring(size_t pos, size_t npos) const {
type ReferenceCountReleaser (line 532) | struct ReferenceCountReleaser {
function ReferenceCount (line 664) | const ReferenceCount* absl_nullable ByteString::GetMediumReferenceCount(
function ByteString (line 831) | ByteString ByteString::Clone(google::protobuf::Arena* absl_nonnull are...
function LegacyByteString (line 1041) | absl::string_view LegacyByteString(const ByteString& string, bool stable,
FILE: common/internal/byte_string.h
function namespace (line 41) | namespace cel {
function string_view (line 589) | string_view rhs) {
function string_view (line 609) | string_view rhs) {
function string_view (line 629) | string_view rhs) {
function string_view (line 649) | string_view rhs) {
function ByteString (line 670) | struct ArenaTraits<common_internal::ByteString> {
FILE: common/internal/byte_string_test.cc
type cel::common_internal (line 34) | namespace cel::common_internal {
type ByteStringTestFriend (line 36) | struct ByteStringTestFriend {
method ByteStringKind (line 37) | static ByteStringKind GetKind(const ByteString& byte_string) {
function TEST (line 52) | TEST(ByteStringKind, Ostream) {
class ByteStringTest (line 70) | class ByteStringTest : public TestWithParam<AllocatorKind>,
method GetAllocator (line 73) | Allocator<> GetAllocator() {
function GetSmallStringView (line 86) | absl::string_view GetSmallStringView() {
function GetSmallString (line 91) | std::string GetSmallString() { return std::string(GetSmallStringView()...
function GetSmallCord (line 93) | absl::Cord GetSmallCord() {
function GetMediumStringView (line 98) | absl::string_view GetMediumStringView() {
function GetMediumString (line 104) | std::string GetMediumString() { return std::string(GetMediumStringView...
function TEST_P (line 120) | TEST_P(ByteStringTest, Default) {
function TEST_P (line 127) | TEST_P(ByteStringTest, ConstructSmallCString) {
function TEST_P (line 136) | TEST_P(ByteStringTest, ConstructMediumCString) {
function TEST_P (line 146) | TEST_P(ByteStringTest, ConstructSmallRValueString) {
function TEST_P (line 155) | TEST_P(ByteStringTest, ConstructSmallLValueString) {
function TEST_P (line 165) | TEST_P(ByteStringTest, ConstructMediumRValueString) {
function TEST_P (line 174) | TEST_P(ByteStringTest, ConstructMediumLValueString) {
function TEST_P (line 184) | TEST_P(ByteStringTest, ConstructSmallCord) {
function TEST_P (line 193) | TEST_P(ByteStringTest, ConstructMediumOrLargeCord) {
function TEST (line 206) | TEST(ByteStringTest, BorrowedUnownedString) {
function TEST (line 220) | TEST(ByteStringTest, BorrowedUnownedCord) {
function TEST (line 233) | TEST(ByteStringTest, BorrowedReferenceCountSmallString) {
function TEST (line 243) | TEST(ByteStringTest, BorrowedReferenceCountMediumString) {
function TEST (line 254) | TEST(ByteStringTest, BorrowedArenaSmallString) {
function TEST (line 263) | TEST(ByteStringTest, BorrowedArenaMediumString) {
function TEST (line 273) | TEST(ByteStringTest, BorrowedReferenceCountCord) {
function TEST (line 283) | TEST(ByteStringTest, BorrowedArenaCord) {
function TEST_P (line 293) | TEST_P(ByteStringTest, CopyConstruct) {
function TEST_P (line 325) | TEST_P(ByteStringTest, CopyConstructFromExternal) {
function TEST_P (line 348) | TEST_P(ByteStringTest, MoveConstruct) {
function TEST_P (line 386) | TEST_P(ByteStringTest, MoveConstructFromExternal) {
function TEST_P (line 414) | TEST_P(ByteStringTest, CopyFromByteString) {
function TEST_P (line 520) | TEST_P(ByteStringTest, MoveFrom) {
function TEST_P (line 629) | TEST_P(ByteStringTest, Swap) {
function TEST_P (line 724) | TEST_P(ByteStringTest, FlattenSmall) {
function TEST_P (line 731) | TEST_P(ByteStringTest, FlattenMedium) {
function TEST_P (line 738) | TEST_P(ByteStringTest, FlattenLarge) {
function TEST_P (line 748) | TEST_P(ByteStringTest, TryFlatSmall) {
function TEST_P (line 755) | TEST_P(ByteStringTest, TryFlatMedium) {
function TEST_P (line 762) | TEST_P(ByteStringTest, TryFlatLarge) {
function TEST_P (line 773) | TEST_P(ByteStringTest, Equals) {
function TEST_P (line 778) | TEST_P(ByteStringTest, Compare) {
function TEST_P (line 784) | TEST_P(ByteStringTest, StartsWith) {
function TEST_P (line 792) | TEST_P(ByteStringTest, EndsWith) {
function TEST_P (line 801) | TEST_P(ByteStringTest, Find) {
function TEST_P (line 830) | TEST_P(ByteStringTest, FindEdgeCases) {
function TEST_P (line 897) | TEST_P(ByteStringTest, FindOutOfBounds) {
function TEST_P (line 903) | TEST_P(ByteStringTest, Substring) {
function TEST_P (line 931) | TEST_P(ByteStringTest, SubstringEdgeCases) {
function TEST_P (line 938) | TEST_P(ByteStringTest, SubstringOutOfBounds) {
function TEST_P (line 946) | TEST_P(ByteStringTest, RemovePrefixSmall) {
function TEST_P (line 952) | TEST_P(ByteStringTest, RemovePrefixMedium) {
function TEST_P (line 962) | TEST_P(ByteStringTest, RemovePrefixMediumOrLarge) {
function TEST_P (line 971) | TEST_P(ByteStringTest, RemoveSuffixSmall) {
function TEST_P (line 978) | TEST_P(ByteStringTest, RemoveSuffixMedium) {
function TEST_P (line 987) | TEST_P(ByteStringTest, RemoveSuffixMediumOrLarge) {
function TEST_P (line 995) | TEST_P(ByteStringTest, ToStringSmall) {
function TEST_P (line 1000) | TEST_P(ByteStringTest, ToStringMedium) {
function TEST_P (line 1005) | TEST_P(ByteStringTest, ToStringLarge) {
function TEST_P (line 1010) | TEST_P(ByteStringTest, ToStringViewSmall) {
function TEST_P (line 1016) | TEST_P(ByteStringTest, ToStringViewMedium) {
function TEST_P (line 1022) | TEST_P(ByteStringTest, ToStringViewLarge) {
function TEST_P (line 1028) | TEST_P(ByteStringTest, AsStringViewSmall) {
function TEST_P (line 1033) | TEST_P(ByteStringTest, AsStringViewMedium) {
function TEST_P (line 1038) | TEST_P(ByteStringTest, AsStringViewLarge) {
function TEST_P (line 1043) | TEST_P(ByteStringTest, CopyToStringSmall) {
function TEST_P (line 1050) | TEST_P(ByteStringTest, CopyToStringMedium) {
function TEST_P (line 1057) | TEST_P(ByteStringTest, CopyToStringLarge) {
function TEST_P (line 1064) | TEST_P(ByteStringTest, AppendToStringSmall) {
function TEST_P (line 1071) | TEST_P(ByteStringTest, AppendToStringMedium) {
function TEST_P (line 1078) | TEST_P(ByteStringTest, AppendToStringLarge) {
function TEST_P (line 1085) | TEST_P(ByteStringTest, ToCordSmall) {
function TEST_P (line 1091) | TEST_P(ByteStringTest, ToCordMedium) {
function TEST_P (line 1097) | TEST_P(ByteStringTest, ToCordLarge) {
function TEST_P (line 1103) | TEST_P(ByteStringTest, CopyToCordSmall) {
function TEST_P (line 1110) | TEST_P(ByteStringTest, CopyToCordMedium) {
function TEST_P (line 1117) | TEST_P(ByteStringTest, CopyToCordLarge) {
function TEST_P (line 1124) | TEST_P(ByteStringTest, AppendToCordSmall) {
function TEST_P (line 1131) | TEST_P(ByteStringTest, AppendToCordMedium) {
function TEST_P (line 1138) | TEST_P(ByteStringTest, AppendToCordLarge) {
function TEST_P (line 1145) | TEST_P(ByteStringTest, CloneSmall) {
function TEST_P (line 1151) | TEST_P(ByteStringTest, CloneMedium) {
function TEST_P (line 1157) | TEST_P(ByteStringTest, CloneLarge) {
function TEST_P (line 1163) | TEST_P(ByteStringTest, LegacyByteStringSmall) {
function TEST_P (line 1172) | TEST_P(ByteStringTest, LegacyByteStringMedium) {
function TEST_P (line 1181) | TEST_P(ByteStringTest, LegacyByteStringLarge) {
function TEST_P (line 1190) | TEST_P(ByteStringTest, HashValue) {
FILE: common/internal/casting.h
function namespace (line 31) | namespace common_internal {
FILE: common/internal/metadata.h
function namespace (line 22) | namespace cel::common_internal {
FILE: common/internal/reference_count.cc
type cel::common_internal (line 31) | namespace cel::common_internal {
class DeletingReferenceCount<google::protobuf::MessageLite> (line 33) | class DeletingReferenceCount<google::protobuf::MessageLite>
class ReferenceCountedStdString (line 37) | class ReferenceCountedStdString final : public ReferenceCounted {
method New (line 39) | static std::pair<const ReferenceCount* absl_nonnull, absl::string_vi...
method ReferenceCountedStdString (line 49) | explicit ReferenceCountedStdString(std::string&& string) {
method Finalize (line 55) | void Finalize() noexcept override {
class ReferenceCountedString (line 62) | class ReferenceCountedString final : public ReferenceCounted {
method New (line 64) | static std::pair<const ReferenceCount* absl_nonnull, absl::string_vi...
method Overhead (line 82) | static size_t Overhead() { return offsetof(ReferenceCountedString, d...
method ReferenceCountedString (line 88) | explicit ReferenceCountedString(absl::string_view string)
method Delete (line 93) | void Delete() noexcept override {
function MakeReferenceCountedString (line 106) | std::pair<const ReferenceCount* absl_nonnull, absl::string_view>
function MakeReferenceCountedString (line 112) | std::pair<const ReferenceCount* absl_nonnull, absl::string_view>
FILE: common/internal/reference_count.h
function namespace (line 39) | namespace cel::common_internal {
function DeletingReferenceCount (line 202) | DeletingReferenceCount final : public ReferenceCounted {
function InlinedReferenceCount (line 250) | InlinedReferenceCount final : public ReferenceCounted {
function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 258) | ABSL_ATTRIBUTE_ALWAYS_INLINE T* absl_nonnull value() {
function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 262) | ABSL_ATTRIBUTE_ALWAYS_INLINE const T* absl_nonnull value() const {
function StrongRef (line 291) | inline void StrongRef(const ReferenceCount& refcount) noexcept {
function StrongRef (line 297) | inline void StrongRef(const ReferenceCount* absl_nullable refcount) noex...
function StrongUnref (line 303) | inline void StrongUnref(const ReferenceCount& refcount) noexcept {
function StrongUnref (line 314) | inline void StrongUnref(const ReferenceCount* absl_nullable refcount) no...
function ABSL_MUST_USE_RESULT (line 320) | ABSL_MUST_USE_RESULT
function ABSL_MUST_USE_RESULT (line 337) | ABSL_MUST_USE_RESULT
function WeakRef (line 343) | inline void WeakRef(const ReferenceCount& refcount) noexcept {
function WeakRef (line 349) | inline void WeakRef(const ReferenceCount* absl_nullable refcount) noexce...
function WeakUnref (line 355) | inline void WeakUnref(const ReferenceCount& refcount) noexcept {
function WeakUnref (line 365) | inline void WeakUnref(const ReferenceCount* absl_nullable refcount) noex...
function ABSL_MUST_USE_RESULT (line 371) | ABSL_MUST_USE_RESULT
function ABSL_MUST_USE_RESULT (line 379) | ABSL_MUST_USE_RESULT
function ABSL_MUST_USE_RESULT (line 384) | ABSL_MUST_USE_RESULT
function ABSL_MUST_USE_RESULT (line 392) | ABSL_MUST_USE_RESULT
FILE: common/internal/reference_count_test.cc
type cel::common_internal (line 26) | namespace cel::common_internal {
class Object (line 32) | class Object : public virtual ReferenceCountFromThis {
method Object (line 34) | explicit Object(bool& destructed) : destructed_(destructed) {}
class Subobject (line 42) | class Subobject : public Object, public virtual ReferenceCountFromThis {
function TEST (line 47) | TEST(ReferenceCount, Strong) {
function TEST (line 64) | TEST(ReferenceCount, Weak) {
class DataObject (line 85) | class DataObject final : public Data {
method DataObject (line 87) | DataObject() noexcept : Data() {}
method DataObject (line 89) | explicit DataObject(google::protobuf::Arena* absl_nullable arena) no...
type OtherObject (line 95) | struct OtherObject final {
function TEST (line 99) | TEST(DeletingReferenceCount, Data) {
function TEST (line 109) | TEST(DeletingReferenceCount, MessageLite) {
function TEST (line 119) | TEST(DeletingReferenceCount, Other) {
function TEST (line 128) | TEST(EmplacedReferenceCount, Data) {
function TEST (line 139) | TEST(EmplacedReferenceCount, MessageLite) {
function TEST (line 151) | TEST(EmplacedReferenceCount, Other) {
FILE: common/internal/signature.cc
type cel::common_internal (line 30) | namespace cel::common_internal {
function AppendEscaped (line 34) | void AppendEscaped(std::string* result, std::string_view str, bool esc...
function AppendTypeDesc (line 76) | absl::Status AppendTypeDesc(std::string* result, const Type& type) {
function AppendTypeParameters (line 165) | absl::Status AppendTypeParameters(std::string* result, const Type& typ...
function MakeTypeSignature (line 181) | absl::StatusOr<std::string> MakeTypeSignature(const Type& type) {
function MakeOverloadSignature (line 187) | absl::StatusOr<std::string> MakeOverloadSignature(
FILE: common/internal/signature.h
function namespace (line 25) | namespace cel::common_internal {
FILE: common/internal/signature_test.cc
type cel::common_internal (line 27) | namespace cel::common_internal {
type TypeSignatureTestCase (line 41) | struct TypeSignatureTestCase {
function TEST_P (line 49) | TEST_P(TypeSignatureTest, TypeSignature) {
function GetTypeSignatureTestCases (line 62) | std::vector<TypeSignatureTestCase> GetTypeSignatureTestCases() {
type OverloadSignatureTestCase (line 136) | struct OverloadSignatureTestCase {
function TEST_P (line 146) | TEST_P(OverloadSignatureTest, OverloadSignature) {
function GetOverloadSignatureTestCases (line 160) | std::vector<OverloadSignatureTestCase> GetOverloadSignatureTestCases() {
FILE: common/internal/value_conversion.cc
type cel::test (line 41) | namespace cel::test {
function ToString (line 48) | std::string ToString(ExprValueKind kind_case) {
function FromObject (line 79) | absl::StatusOr<Value> FromObject(
function MapValueFromExpr (line 107) | absl::StatusOr<MapValue> MapValueFromExpr(
function ListValueFromExpr (line 126) | absl::StatusOr<ListValue> ListValueFromExpr(
function MapValueToExpr (line 142) | absl::StatusOr<ExprMapValue> MapValueToExpr(
function ListValueToExpr (line 174) | absl::StatusOr<ExprListValue> ListValueToExpr(
function ToProtobufAny (line 194) | absl::StatusOr<google::protobuf::Any> ToProtobufAny(
function FromExprValue (line 211) | absl::StatusOr<Value> FromExprValue(
function ToExprValue (line 248) | absl::StatusOr<cel::expr::Value> ToExprValue(
FILE: common/internal/value_conversion.h
function namespace (line 37) | namespace cel::test {
FILE: common/kind.cc
type cel (line 19) | namespace cel {
function KindToString (line 21) | absl::string_view KindToString(Kind kind) {
FILE: common/kind.h
function Kind (line 25) | enum class Kind : uint8_t {
FILE: common/kind_test.cc
type cel (line 24) | namespace cel {
function TEST (line 31) | TEST(Kind, ToString) {
function TEST (line 60) | TEST(Kind, TypeKindRoundtrip) {
function TEST (line 64) | TEST(Kind, ValueKindRoundtrip) {
function TEST (line 68) | TEST(Kind, IsTypeKind) {
function TEST (line 74) | TEST(Kind, IsValueKind) {
function TEST (line 80) | TEST(Kind, Equality) {
function TEST (line 94) | TEST(TypeKind, ToString) {
function TEST (line 98) | TEST(ValueKind, ToString) {
FILE: common/legacy_value.cc
type cel (line 70) | namespace cel {
function InvalidMapKeyTypeError (line 84) | absl::Status InvalidMapKeyTypeError(ValueKind kind) {
function MessageWrapper (line 89) | MessageWrapper AsMessageWrapper(
class CelListIterator (line 95) | class CelListIterator final : public ValueIterator {
method CelListIterator (line 97) | explicit CelListIterator(const CelList* cel_list)
method HasNext (line 100) | bool HasNext() override { return index_ < size_; }
method Next (line 102) | absl::Status Next(const google::protobuf::DescriptorPool* absl_nonnu...
method Next1 (line 117) | absl::StatusOr<bool> Next1(
method Next2 (line 136) | absl::StatusOr<bool> Next2(
class CelMapIterator (line 164) | class CelMapIterator final : public ValueIterator {
method CelMapIterator (line 166) | explicit CelMapIterator(const CelMap* cel_map)
method HasNext (line 169) | bool HasNext() override { return index_ < size_; }
method Next (line 171) | absl::Status Next(const google::protobuf::DescriptorPool* absl_nonnu...
method Next1 (line 187) | absl::StatusOr<bool> Next1(
method Next2 (line 207) | absl::StatusOr<bool> Next2(
method ProjectKeys (line 236) | absl::Status ProjectKeys(google::protobuf::Arena* arena) {
type common_internal (line 251) | namespace common_internal {
function CelValue (line 255) | CelValue LegacyTrivialStructValue(google::protobuf::Arena* absl_nonn...
function CelValue (line 275) | CelValue LegacyTrivialListValue(google::protobuf::Arena* absl_nonnul...
function CelValue (line 313) | CelValue LegacyTrivialMapValue(google::protobuf::Arena* absl_nonnull...
function UnsafeLegacyValue (line 353) | google::api::expr::runtime::CelValue UnsafeLegacyValue(
type common_internal (line 395) | namespace common_internal {
function CelValue (line 255) | CelValue LegacyTrivialStructValue(google::protobuf::Arena* absl_nonn...
function CelValue (line 275) | CelValue LegacyTrivialListValue(google::protobuf::Arena* absl_nonnul...
function CelValue (line 313) | CelValue LegacyTrivialMapValue(google::protobuf::Arena* absl_nonnull...
function UnsafeLegacyValue (line 353) | google::api::expr::runtime::CelValue UnsafeLegacyValue(
function ModernValue (line 1030) | absl::Status ModernValue(google::protobuf::Arena* arena,
function LegacyValue (line 1104) | absl::StatusOr<google::api::expr::runtime::CelValue> LegacyValue(
type interop_internal (line 1154) | namespace interop_internal {
function FromLegacyValue (line 1156) | absl::StatusOr<Value> FromLegacyValue(google::protobuf::Arena* arena,
function ToLegacyValue (line 1210) | absl::StatusOr<google::api::expr::runtime::CelValue> ToLegacyValue(
function Value (line 1258) | Value LegacyValueToModernValueOrDie(
function LegacyValueToModernValueOrDie (line 1266) | std::vector<Value> LegacyValueToModernValueOrDie(
function ModernValueToLegacyValueOrDie (line 1279) | google::api::expr::runtime::CelValue ModernValueToLegacyValueOrDie(
function TypeValue (line 1286) | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
FILE: common/legacy_value.h
function namespace (line 32) | namespace cel {
function NullValue (line 70) | inline NullValue CreateNullValue() { return NullValue{}; }
function ListValue (line 82) | inline ListValue CreateLegacyListValue(
function MapValue (line 87) | inline MapValue CreateLegacyMapValue(
function TimestampValue (line 96) | inline TimestampValue CreateTimestampValue(absl::Time value) {
FILE: common/memory.cc
type cel (line 27) | namespace cel {
function MemoryManager (line 76) | MemoryManager MemoryManager::Unmanaged() {
FILE: common/memory.h
function namespace (line 41) | namespace cel {
function namespace (line 292) | namespace common_internal {
function Owner (line 305) | struct ArenaTraits<Owner> {
function class (line 315) | class Borrower final {
function Borrower (line 319) | static Borrower Allocator(Allocator<> allocator) noexcept {
function Borrower (line 324) | static Borrower Arena(google::protobuf::Arena* absl_nonnull arena
function Borrower (line 332) | static Borrower ReferenceCount(
function ptr_ (line 357) | Borrower(const Owner& owner ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
function explicit (line 380) | explicit operator bool() const noexcept { return !Owner::IsNone(ptr_); }
function reset (line 388) | void reset() noexcept { ptr_ = 0; }
type Borrowable (line 400) | struct Borrowable
function explicit (line 404) | constexpr explicit Borrower(uintptr_t ptr) noexcept : ptr_(ptr) {}
function Owner (line 429) | inline Owner::Owner(Borrower borrower) noexcept
function namespace (line 432) | namespace common_internal {
function ABSL_ATTRIBUTE_TRIVIAL_ABI (line 473) | ABSL_ATTRIBUTE_TRIVIAL_ABI [[nodiscard]] Unique final {
function namespace (line 739) | namespace std {
function namespace (line 755) | namespace cel {
function noexcept (line 868) | const noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND {
function reset (line 873) | void reset() noexcept {
function noexcept (line 878) | const noexcept { return owner_.arena(); }
type Ownable (line 896) | struct Ownable
function T (line 909) | T* get() const noexcept { return value_; }
function element_type (line 937) | static element_type* to_address(const pointer& p) noexcept {
function namespace (line 944) | namespace cel {
function namespace (line 1039) | namespace common_internal {
function Borrowed (line 1053) | Borrowed final {
function noexcept (line 1139) | const noexcept {
function reset (line 1144) | void reset() noexcept {
function noexcept (line 1149) | const noexcept {
type Borrowable (line 1163) | struct Borrowable
function T (line 1169) | T* get() const noexcept { return value_; }
function element_type (line 1195) | static element_type* to_address(pointer p) noexcept { return p.value_; }
function namespace (line 1200) | namespace cel {
function noexcept (line 1278) | const noexcept { return Own(); }
function class (line 1305) | class ReferenceCountingMemoryManager final {
function class (line 1327) | class PoolingMemoryManager final {
function Deallocate (line 1354) | static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, siz...
function OwnCustomDestructor (line 1364) | static bool OwnCustomDestructor(google::protobuf::Arena* absl_nonnull ar...
function DefaultDestructor (line 1373) | void DefaultDestructor(void* ptr) {
function class (line 1401) | class MemoryManager final {
FILE: common/memory_test.cc
type cel (line 36) | namespace cel {
function TEST (line 45) | TEST(Owner, None) {
function TEST (line 50) | TEST(Owner, Allocator) {
function TEST (line 56) | TEST(Owner, Arena) {
function TEST (line 62) | TEST(Owner, ReferenceCount) {
function TEST (line 69) | TEST(Owner, Equality) {
function TEST (line 81) | TEST(Borrower, None) {
function TEST (line 86) | TEST(Borrower, Allocator) {
function TEST (line 92) | TEST(Borrower, Arena) {
function TEST (line 98) | TEST(Borrower, ReferenceCount) {
function TEST (line 105) | TEST(Borrower, Equality) {
function TEST (line 118) | TEST(OwnerBorrower, CopyConstruct) {
function TEST (line 129) | TEST(OwnerBorrower, MoveConstruct) {
function TEST (line 139) | TEST(OwnerBorrower, CopyAssign) {
function TEST (line 151) | TEST(OwnerBorrower, MoveAssign) {
function TEST (line 162) | TEST(Unique, ToAddress) {
class OwnedTest (line 169) | class OwnedTest : public TestWithParam<AllocatorKind> {
method GetAllocator (line 171) | Allocator<> GetAllocator() {
function TEST_P (line 184) | TEST_P(OwnedTest, Default) {
class TestData (line 192) | class TestData final : public Data {
method TestData (line 197) | TestData() noexcept : Data() {}
method TestData (line 199) | explicit TestData(google::protobuf::Arena* absl_nullable arena) noex...
function TEST_P (line 203) | TEST_P(OwnedTest, AllocateSharedData) {
function TEST_P (line 210) | TEST_P(OwnedTest, AllocateSharedMessageLite) {
function TEST_P (line 217) | TEST_P(OwnedTest, WrapSharedData) {
function TEST_P (line 225) | TEST_P(OwnedTest, WrapSharedMessageLite) {
function TEST_P (line 233) | TEST_P(OwnedTest, SharedFromUniqueData) {
function TEST_P (line 240) | TEST_P(OwnedTest, SharedFromUniqueMessageLite) {
function TEST_P (line 247) | TEST_P(OwnedTest, CopyConstruct) {
function TEST_P (line 254) | TEST_P(OwnedTest, MoveConstruct) {
function TEST_P (line 261) | TEST_P(OwnedTest, CopyConstructOther) {
function TEST_P (line 268) | TEST_P(OwnedTest, MoveConstructOther) {
function TEST_P (line 275) | TEST_P(OwnedTest, ConstructBorrowed) {
function TEST_P (line 282) | TEST_P(OwnedTest, ConstructOwner) {
function TEST_P (line 289) | TEST_P(OwnedTest, ConstructNullPtr) {
function TEST_P (line 294) | TEST_P(OwnedTest, CopyAssign) {
function TEST_P (line 302) | TEST_P(OwnedTest, MoveAssign) {
function TEST_P (line 310) | TEST_P(OwnedTest, CopyAssignOther) {
function TEST_P (line 318) | TEST_P(OwnedTest, MoveAssignOther) {
function TEST_P (line 326) | TEST_P(OwnedTest, AssignBorrowed) {
function TEST_P (line 334) | TEST_P(OwnedTest, AssignUnique) {
function TEST_P (line 340) | TEST_P(OwnedTest, AssignNullPtr) {
class BorrowedTest (line 352) | class BorrowedTest : public TestWithParam<AllocatorKind> {
method GetAllocator (line 354) | Allocator<> GetAllocator() {
function TEST_P (line 367) | TEST_P(BorrowedTest, Default) {
function TEST_P (line 375) | TEST_P(BorrowedTest, CopyConstruct) {
function TEST_P (line 383) | TEST_P(BorrowedTest, MoveConstruct) {
function TEST_P (line 391) | TEST_P(BorrowedTest, CopyConstructOther) {
function TEST_P (line 399) | TEST_P(BorrowedTest, MoveConstructOther) {
function TEST_P (line 407) | TEST_P(BorrowedTest, ConstructNullPtr) {
function TEST_P (line 412) | TEST_P(BorrowedTest, CopyAssign) {
function TEST_P (line 421) | TEST_P(BorrowedTest, MoveAssign) {
function TEST_P (line 430) | TEST_P(BorrowedTest, CopyAssignOther) {
function TEST_P (line 439) | TEST_P(BorrowedTest, MoveAssignOther) {
function TEST_P (line 448) | TEST_P(BorrowedTest, AssignOwned) {
function TEST_P (line 455) | TEST_P(BorrowedTest, AssignNullPtr) {
FILE: common/memory_testing.h
function namespace (line 27) | namespace cel::common_internal {
FILE: common/minimal_descriptor_database.cc
type cel (line 21) | namespace cel {
FILE: common/minimal_descriptor_database.h
function namespace (line 21) | namespace cel {
FILE: common/minimal_descriptor_database_test.cc
type cel (line 21) | namespace cel {
function TEST (line 26) | TEST(GetMinimalDescriptorDatabase, NullValue) {
function TEST (line 33) | TEST(GetMinimalDescriptorDatabase, BoolValue) {
function TEST (line 40) | TEST(GetMinimalDescriptorDatabase, Int32Value) {
function TEST (line 47) | TEST(GetMinimalDescriptorDatabase, Int64Value) {
function TEST (line 54) | TEST(GetMinimalDescriptorDatabase, UInt32Value) {
function TEST (line 61) | TEST(GetMinimalDescriptorDatabase, UInt64Value) {
function TEST (line 68) | TEST(GetMinimalDescriptorDatabase, FloatValue) {
function TEST (line 75) | TEST(GetMinimalDescriptorDatabase, DoubleValue) {
function TEST (line 82) | TEST(GetMinimalDescriptorDatabase, BytesValue) {
function TEST (line 89) | TEST(GetMinimalDescriptorDatabase, StringValue) {
function TEST (line 96) | TEST(GetMinimalDescriptorDatabase, Any) {
function TEST (line 103) | TEST(GetMinimalDescriptorDatabase, Duration) {
function TEST (line 110) | TEST(GetMinimalDescriptorDatabase, Timestamp) {
function TEST (line 117) | TEST(GetMinimalDescriptorDatabase, Value) {
function TEST (line 124) | TEST(GetMinimalDescriptorDatabase, ListValue) {
function TEST (line 131) | TEST(GetMinimalDescriptorDatabase, Struct) {
FILE: common/minimal_descriptor_pool.cc
type cel (line 22) | namespace cel {
function AddMinimumRequiredDescriptorsToPool (line 29) | absl::Status AddMinimumRequiredDescriptorsToPool(
FILE: common/minimal_descriptor_pool.h
function namespace (line 22) | namespace cel {
FILE: common/minimal_descriptor_pool_test.cc
type cel (line 21) | namespace cel {
function TEST (line 27) | TEST(GetMinimalDescriptorPool, NullValue) {
function TEST (line 33) | TEST(GetMinimalDescriptorPool, BoolValue) {
function TEST (line 41) | TEST(GetMinimalDescriptorPool, Int32Value) {
function TEST (line 49) | TEST(GetMinimalDescriptorPool, Int64Value) {
function TEST (line 57) | TEST(GetMinimalDescriptorPool, UInt32Value) {
function TEST (line 65) | TEST(GetMinimalDescriptorPool, UInt64Value) {
function TEST (line 73) | TEST(GetMinimalDescriptorPool, FloatValue) {
function TEST (line 81) | TEST(GetMinimalDescriptorPool, DoubleValue) {
function TEST (line 89) | TEST(GetMinimalDescriptorPool, BytesValue) {
function TEST (line 97) | TEST(GetMinimalDescriptorPool, StringValue) {
function TEST (line 105) | TEST(GetMinimalDescriptorPool, Any) {
function TEST (line 112) | TEST(GetMinimalDescriptorPool, Duration) {
function TEST (line 120) | TEST(GetMinimalDescriptorPool, Timestamp) {
function TEST (line 128) | TEST(GetMinimalDescriptorPool, Value) {
function TEST (line 135) | TEST(GetMinimalDescriptorPool, ListValue) {
function TEST (line 143) | TEST(GetMinimalDescriptorPool, Struct) {
function TEST (line 150) | TEST(AddMinimumRequiredDescriptorsToPool, Adds) {
FILE: common/native_type.h
function namespace (line 20) | namespace cel {
FILE: common/navigable_ast.cc
type cel (line 33) | namespace cel {
function NodeKind (line 42) | NodeKind GetNodeKind(const Expr& expr) {
function ChildKind (line 68) | ChildKind GetChildKind(const NavigableAstNodeData& parent_node,
class NavigableExprBuilderVisitor (line 111) | class NavigableExprBuilderVisitor : public cel::AstVisitorBase {
method NavigableExprBuilderVisitor (line 113) | NavigableExprBuilderVisitor(
method NavigableAstNodeData (line 121) | NavigableAstNodeData& NodeDataAt(size_t index) {
method PreVisitExpr (line 125) | void PreVisitExpr(const Expr& expr) override {
method PreVisitComprehensionSubexpression (line 156) | void PreVisitComprehensionSubexpression(
method PostVisitExpr (line 162) | void PostVisitExpr(const Expr& expr) override {
method Consume (line 175) | std::unique_ptr<NavigableAstMetadata> Consume() && {
function NavigableAst (line 190) | NavigableAst NavigableAst::Build(const Expr& expr) {
FILE: common/navigable_ast.h
function namespace (line 22) | namespace cel {
FILE: common/navigable_ast_test.cc
type cel (line 31) | namespace cel {
function Parse (line 39) | absl::StatusOr<std::unique_ptr<Ast>> Parse(absl::string_view expr) {
function TEST (line 45) | TEST(NavigableAst, Basic) {
function TEST (line 63) | TEST(NavigableAst, DefaultCtorEmpty) {
function TEST (line 85) | TEST(NavigableAst, FindById) {
function TEST (line 103) | TEST(NavigableAst, ToleratesNonUnique) {
function TEST (line 122) | TEST(NavigableAst, FindByExprPtr) {
function TEST (line 137) | TEST(NavigableAst, Children) {
function TEST (line 168) | TEST(NavigableAst, UnspecifiedExpr) {
function TEST (line 181) | TEST(NavigableAst, ParentRelationSelect) {
function TEST (line 194) | TEST(NavigableAst, ParentRelationCallReceiver) {
function TEST (line 207) | TEST(NavigableAst, ParentRelationCreateStruct) {
function TEST (line 222) | TEST(NavigableAst, ParentRelationCreateMap) {
function TEST (line 240) | TEST(NavigableAst, ParentRelationCreateList) {
FILE: common/operators.cc
type google::api::expr::common (line 25) | namespace google::api::expr::common {
function LookupPrecedence (line 168) | int LookupPrecedence(absl::string_view op) {
function LookupUnaryOperator (line 177) | absl::optional<std::string> LookupUnaryOperator(absl::string_view op) {
function LookupBinaryOperator (line 186) | absl::optional<std::string> LookupBinaryOperator(absl::string_view op) {
function LookupOperator (line 195) | absl::optional<std::string> LookupOperator(absl::string_view op) {
function ReverseLookupOperator (line 204) | absl::optional<std::string> ReverseLookupOperator(absl::string_view op) {
function IsOperatorSamePrecedence (line 213) | bool IsOperatorSamePrecedence(absl::string_view op,
function IsOperatorLowerPrecedence (line 221) | bool IsOperatorLowerPrecedence(absl::string_view op,
function IsOperatorLeftRecursive (line 229) | bool IsOperatorLeftRecursive(absl::string_view op) {
FILE: common/operators.h
function namespace (line 25) | namespace google::api::expr::common {
FILE: common/optional_ref.h
function namespace (line 28) | namespace cel {
FILE: common/reference.cc
type cel (line 19) | namespace cel {
function VariableReference (line 21) | const VariableReference& VariableReference::default_instance() {
function FunctionReference (line 26) | const FunctionReference& FunctionReference::default_instance() {
FILE: common/reference.h
function namespace (line 28) | namespace cel {
function class (line 78) | class FunctionReference final {
function class (line 124) | class Reference final {
function ABSL_MUST_USE_RESULT (line 152) | ABSL_MUST_USE_RESULT ReferenceKind release_kind() {
function ABSL_MUST_USE_RESULT (line 159) | ABSL_MUST_USE_RESULT bool has_variable() const {
function set_variable (line 171) | void set_variable(VariableReference variable) {
function ABSL_MUST_USE_RESULT (line 182) | ABSL_MUST_USE_RESULT VariableReference release_variable() {
function ABSL_MUST_USE_RESULT (line 191) | ABSL_MUST_USE_RESULT bool has_function() const {
function set_function (line 203) | void set_function(FunctionReference function) {
function ABSL_MUST_USE_RESULT (line 214) | ABSL_MUST_USE_RESULT FunctionReference release_function() {
function Reference (line 242) | inline Reference MakeVariableReference(std::string name) {
function Reference (line 249) | inline Reference MakeConstantVariableReference(std::string name,
function Reference (line 258) | inline Reference MakeFunctionReference(std::string name,
FILE: common/reference_count.h
function namespace (line 20) | namespace cel {
FILE: common/reference_test.cc
type cel (line 24) | namespace cel {
function TEST (line 33) | TEST(VariableReference, Value) {
function TEST (line 46) | TEST(VariableReference, Equality) {
function TEST (line 53) | TEST(FunctionReference, Overloads) {
function TEST (line 64) | TEST(FunctionReference, Equality) {
function TEST (line 71) | TEST(Reference, Name) {
function TEST (line 80) | TEST(Reference, Variable) {
function TEST (line 88) | TEST(Reference, Function) {
function TEST (line 100) | TEST(Reference, Equality) {
FILE: common/source.cc
type cel (line 44) | namespace cel {
function SourcePosition (line 46) | SourcePosition SourceContentView::size() const {
type common_internal (line 161) | namespace common_internal {
class SourceImpl (line 163) | class SourceImpl : public Source {
method SourceImpl (line 165) | SourceImpl(std::string description,
method description (line 170) | absl::string_view description() const final { return description_; }
method line_offsets (line 172) | absl::Span<const SourcePosition> line_offsets() const final {
class AsciiSource (line 183) | class AsciiSource final : public SourceImpl {
method AsciiSource (line 185) | AsciiSource(std::string description,
method ContentView (line 191) | ContentView content() const override {
class Latin1Source (line 199) | class Latin1Source final : public SourceImpl {
method Latin1Source (line 201) | Latin1Source(std::string description,
method ContentView (line 207) | ContentView content() const override {
class BasicPlaneSource (line 215) | class BasicPlaneSource final : public SourceImpl {
method BasicPlaneSource (line 217) | BasicPlaneSource(std::string description,
method ContentView (line 223) | ContentView content() const override {
class SupplementalPlaneSource (line 231) | class SupplementalPlaneSource final : public SourceImpl {
method SupplementalPlaneSource (line 233) | SupplementalPlaneSource(std::string description,
method ContentView (line 239) | ContentView content() const override {
type SourceTextTraits (line 248) | struct SourceTextTraits
type SourceTextTraits<absl::string_view> (line 251) | struct SourceTextTraits<absl::string_view> {
method iterator_type (line 254) | static iterator_type Begin(absl::string_view text) { return text; }
method Advance (line 256) | static void Advance(iterator_type& it, size_t n) { it.remove_prefi...
method AppendTo (line 258) | static void AppendTo(std::vector<uint8_t>& out, absl::string_view ...
method ToVector (line 264) | static std::vector<char> ToVector(absl::string_view in) {
type SourceTextTraits<absl::Cord> (line 273) | struct SourceTextTraits<absl::Cord> {
method iterator_type (line 276) | static iterator_type Begin(const absl::Cord& text) {
method Advance (line 280) | static void Advance(iterator_type& it, size_t n) {
method AppendTo (line 284) | static void AppendTo(std::vector<uint8_t>& out, const absl::Cord& ...
method ToVector (line 297) | static std::vector<char> ToVector(const absl::Cord& in) {
function NewSourceImpl (line 308) | absl::StatusOr<SourcePtr> NewSourceImpl(std::string description, con...
FILE: common/source.h
function namespace (line 32) | namespace cel {
function final (line 59) | struct SourceLocation final {
function class (line 74) | class SourceContentView final {
function class (line 118) | class Source {
FILE: common/source_test.cc
function TEST (line 29) | TEST(SourceRange, Default) {
function TEST (line 35) | TEST(SourceRange, Equality) {
function TEST (line 40) | TEST(SourceLocation, Default) {
function TEST (line 46) | TEST(SourceLocation, Equality) {
function TEST (line 51) | TEST(StringSource, Description) {
function TEST (line 59) | TEST(StringSource, Content) {
function TEST (line 68) | TEST(StringSource, PositionAndLocation) {
FILE: common/standard_definitions.h
function namespace (line 21) | namespace cel {
FILE: common/type.cc
type cel (line 34) | namespace cel {
function Type (line 39) | Type Type::Message(const Descriptor* absl_nonnull descriptor) {
function Type (line 76) | Type Type::Enum(const google::protobuf::EnumDescriptor* absl_nonnull d...
function TypeKind (line 105) | TypeKind Type::kind() const { return kTypeToKindArray[variant_.index()...
function ABSL_ATTRIBUTE_LIFETIME_BOUND (line 107) | absl::string_view Type::name() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
function TypeParameters (line 123) | TypeParameters Type::GetParameters() const {
function GetOrNullopt (line 157) | absl::optional<T> GetOrNullopt(const common_internal::TypeVariant& var...
function T (line 296) | T GetOrDie(const common_internal::TypeVariant& variant) {
function AnyType (line 302) | AnyType Type::GetAny() const {
function BoolType (line 307) | BoolType Type::GetBool() const {
function BoolWrapperType (line 312) | BoolWrapperType Type::GetBoolWrapper() const {
function BytesType (line 317) | BytesType Type::GetBytes() const {
function BytesWrapperType (line 322) | BytesWrapperType Type::GetBytesWrapper() const {
function DoubleType (line 327) | DoubleType Type::GetDouble() const {
function DoubleWrapperType (line 332) | DoubleWrapperType Type::GetDoubleWrapper() const {
function DurationType (line 337) | DurationType Type::GetDuration() const {
function DynType (line 342) | DynType Type::GetDyn() const {
function EnumType (line 347) | EnumType Type::GetEnum() const {
function ErrorType (line 352) | ErrorType Type::GetError() const {
function FunctionType (line 357) | FunctionType Type::GetFunction() const {
function IntType (line 362) | IntType Type::GetInt() const {
function IntWrapperType (line 367) | IntWrapperType Type::GetIntWrapper() const {
function ListType (line 372) | ListType Type::GetList() const {
function MapType (line 377) | MapType Type::GetMap() const {
function MessageType (line 382) | MessageType Type::GetMessage() const {
function NullType (line 387) | NullType Type::GetNull() const {
function OpaqueType (line 392) | OpaqueType Type::GetOpaque() const {
function OptionalType (line 397) | OptionalType Type::GetOptional() const {
function StringType (line 402) | StringType Type::GetString() const {
function StringWrapperType (line 407) | StringWrapperType Type::GetStringWrapper() const {
function StructType (line 412) | StructType Type::GetStruct() const {
function TimestampType (line 425) | TimestampType Type::GetTimestamp() const {
function TypeParamType (line 430) | TypeParamType Type::GetTypeParam() const {
function TypeType (line 435) | TypeType Type::GetType() const {
function UintType (line 440) | UintType Type::GetUint() const {
function UintWrapperType (line 445) | UintWrapperType Type::GetUintWrapper() const {
function UnknownType (line 450) | UnknownType Type::GetUnknown() const {
function Type (line 455) | Type Type::Unwrap() const {
function Type (line 474) | Type Type::Wrap() const {
type common_internal (line 493) | namespace common_internal {
function Type (line 495) | Type SingularMessageFieldType(
function Type (line 651) | Type LegacyRuntimeType(absl::string_view name) {
function Type (line 555) | Type Type::Field(const google::protobuf::FieldDescriptor* absl_nonnull...
function Type (line 587) | Type StructTypeField::GetType() const {
type common_internal (line 632) | namespace common_internal {
function Type (line 495) | Type SingularMessageFieldType(
function Type (line 651) | Type LegacyRuntimeType(absl::string_view name) {
FILE: common/type.h
function namespace (line 72) | namespace cel {
function H (line 157) | H AbslHashValue(H state, const Type& type) {
function IsBool (line 177) | bool IsBool() const { return absl::holds_alternative<BoolType>(variant_); }
function IsBytes (line 183) | bool IsBytes() const { return absl::holds_alternative<BytesType>(variant...
function IsDouble (line 189) | bool IsDouble() const {
function IsDuration (line 197) | bool IsDuration() const {
function IsEnum (line 203) | bool IsEnum() const { return absl::holds_alternative<EnumType>(variant_); }
function IsFunction (line 207) | bool IsFunction() const {
function IsIntWrapper (line 213) | bool IsIntWrapper() const {
function IsMap (line 219) | bool IsMap() const { return absl::holds_alternative<MapType>(variant_); }
function IsNull (line 225) | bool IsNull() const { return absl::holds_alternative<NullType>(variant_); }
function IsString (line 233) | bool IsString() const {
function IsStruct (line 241) | bool IsStruct() const {
function IsTypeParam (line 251) | bool IsTypeParam() const {
function IsUint (line 257) | bool IsUint() const { return absl::holds_alternative<UintType>(variant_); }
function IsUnknown (line 263) | bool IsUnknown() const {
function AnyType (line 668) | AnyType GetAny() const;
function Type (line 901) | inline Type JsonType() { return DynType(); }
function class (line 919) | class TypeParameters final {
function TypeParameters (line 1016) | inline TypeParameters AnyType::GetParameters() { return {}; }
function TypeParameters (line 1018) | inline TypeParameters BoolType::GetParameters() { return {}; }
function TypeParameters (line 1020) | inline TypeParameters BoolWrapperType::GetParameters() { return {}; }
function TypeParameters (line 1022) | inline TypeParameters BytesType::GetParameters() { return {}; }
function TypeParameters (line 1024) | inline TypeParameters BytesWrapperType::GetParameters() { return {}; }
function TypeParameters (line 1026) | inline TypeParameters DoubleType::GetParameters() { return {}; }
function TypeParameters (line 1028) | inline TypeParameters DoubleWrapperType::GetParameters() { return {}; }
function TypeParameters (line 1030) | inline TypeParameters DurationType::GetParameters() { return {}; }
function TypeParameters (line 1032) | inline TypeParameters DynType::GetParameters() { return {}; }
function TypeParameters (line 1034) | inline TypeParameters EnumType::GetParameters() { return {}; }
function TypeParameters (line 1036) | inline TypeParameters ErrorType::GetParameters() { return {}; }
function TypeParameters (line 1038) | inline TypeParameters IntType::GetParameters() { return {}; }
function TypeParameters (line 1040) | inline TypeParameters IntWrapperType::GetParameters() { return {}; }
function TypeParameters (line 1042) | inline TypeParameters MessageType::GetParameters() { return {}; }
function TypeParameters (line 1044) | inline TypeParameters NullType::GetParameters() { return {}; }
function TypeParameters (line 1046) | inline TypeParameters OptionalType::GetParameters() const
function TypeParameters (line 1053) | inline TypeParameters StringWrapperType::GetParameters() { return {}; }
function TypeParameters (line 1055) | inline TypeParameters TimestampType::GetParameters() { return {}; }
function TypeParameters (line 1057) | inline TypeParameters TypeParamType::GetParameters() { return {}; }
function TypeParameters (line 1059) | inline TypeParameters UintType::GetParameters() { return {}; }
function TypeParameters (line 1061) | inline TypeParameters UintWrapperType::GetParameters() { return {}; }
function TypeParameters (line 1063) | inline TypeParameters UnknownType::GetParameters() { return {}; }
function namespace (line 1065) | namespace common_internal {
function class (line 1111) | class StructTypeField final {
function H (line 1247) | H AbslHashValue(H state, const ListType& type) {
function H (line 1257) | H AbslHashValue(H state, const MapType& type) {
FILE: common/type_introspector.cc
type cel (line 30) | namespace cel {
function MakeBasicStructTypeField (line 34) | common_internal::BasicStructTypeField MakeBasicStructTypeField(
type FieldNameComparer (line 39) | struct FieldNameComparer {
type FieldNumberComparer (line 62) | struct FieldNumberComparer {
type WellKnownType (line 83) | struct WellKnownType {
method WellKnownType (line 84) | WellKnownType(
method WellKnownType (line 94) | explicit WellKnownType(const Type& type) : WellKnownType(type, {}) {}
method FieldByName (line 102) | absl::optional<StructTypeField> FieldByName(absl::string_view name) ...
method FieldByNumber (line 112) | absl::optional<StructTypeField> FieldByNumber(int64_t number) const {
function WellKnownTypesMap (line 125) | const WellKnownTypesMap& GetWellKnownTypesMap() {
function FindWellKnownType (line 240) | absl::optional<Type> FindWellKnownType(absl::string_view name) {
function FindWellKnownTypeEnumConstant (line 248) | absl::optional<TypeIntrospector::EnumConstant> FindWellKnownTypeEnumCo...
function FindWellKnownTypeFieldByName (line 257) | absl::optional<StructTypeField> FindWellKnownTypeFieldByName(
function ListFieldsForWellKnownType (line 266) | absl::optional<std::vector<TypeIntrospector::StructTypeFieldListing>>
FILE: common/type_introspector.h
function namespace (line 26) | namespace cel {
FILE: common/type_kind.h
function namespace (line 26) | namespace cel {
FILE: common/type_proto.cc
type cel (line 35) | namespace cel {
function MaybeWellKnownType (line 44) | absl::optional<Type> MaybeWellKnownType(absl::string_view type_name) {
function ToProtoAbstractType (line 80) | absl::Status ToProtoAbstractType(const cel::OpaqueType& type,
function ToProtoMapType (line 95) | absl::Status ToProtoMapType(const cel::MapType& type,
function ToProtoListType (line 106) | absl::Status ToProtoListType(const cel::ListType& type,
function ToProtoTypeType (line 115) | absl::Status ToProtoTypeType(const cel::TypeType& type,
function TypeToProtoInternal (line 129) | absl::Status TypeToProtoInternal(const cel::Type& type,
function TypeFromProto (line 211) | absl::StatusOr<Type> TypeFromProto(
function TypeToProto (line 329) | absl::Status TypeToProto(const Type& type, TypePb* absl_nonnull type_p...
FILE: common/type_proto.h
function namespace (line 26) | namespace cel {
FILE: common/type_proto_test.cc
type cel (line 32) | namespace cel {
type RoundTrip (line 39) | enum class RoundTrip {
type TestCase (line 44) | struct TestCase {
class TypeFromProtoTest (line 50) | class TypeFromProtoTest : public ::testing::TestWithParam<TestCase> {}
function TEST_P (line 52) | TEST_P(TypeFromProtoTest, FromProtoWorks) {
function TEST_P (line 73) | TEST_P(TypeFromProtoTest, RoundTripProtoWorks) {
FILE: common/type_reflector.h
function namespace (line 26) | namespace cel {
FILE: common/type_reflector_test.cc
type cel (line 32) | namespace cel {
function TEST_F (line 162) | TEST_F(TypeReflectorTest, NewListValueBuilderCoverage_Dynamic) {
function TEST_F (line 173) | TEST_F(TypeReflectorTest, NewMapValueBuilderCoverage_DynamicDynamic) {
function TEST_F (line 189) | TEST_F(TypeReflectorTest, NewMapValueBuilderCoverage_StaticDynamic) {
function TEST_F (line 198) | TEST_F(TypeReflectorTest, NewMapValueBuilderCoverage_DynamicStatic) {
function TEST_F (line 207) | TEST_F(TypeReflectorTest, NewValueBuilder_BoolValue) {
function TEST_F (line 233) | TEST_F(TypeReflectorTest, NewValueBuilder_Int32Value) {
function TEST_F (line 267) | TEST_F(TypeReflectorTest, NewValueBuilder_Int64Value) {
function TEST_F (line 293) | TEST_F(TypeReflectorTest, NewValueBuilder_UInt32Value) {
function TEST_F (line 327) | TEST_F(TypeReflectorTest, NewValueBuilder_UInt64Value) {
function TEST_F (line 353) | TEST_F(TypeReflectorTest, NewValueBuilder_FloatValue) {
function TEST_F (line 379) | TEST_F(TypeReflectorTest, NewValueBuilder_DoubleValue) {
function TEST_F (line 405) | TEST_F(TypeReflectorTest, NewValueBuilder_StringValue) {
function TEST_F (line 431) | TEST_F(TypeReflectorTest, NewValueBuilder_BytesValue) {
function TEST_F (line 457) | TEST_F(TypeReflectorTest, NewValueBuilder_Duration) {
function TEST_F (line 502) | TEST_F(TypeReflectorTest, NewValueBuilder_Timestamp) {
function TEST_F (line 547) | TEST_F(TypeReflectorTest, NewValueBuilder_Any) {
FILE: common/type_test.cc
type cel (line 24) | namespace cel {
function TEST (line 33) | TEST(Type, Default) {
function TEST (line 38) | TEST(Type, Enum) {
function TEST (line 51) | TEST(Type, Field) {
function TEST (line 162) | TEST(Type, Kind) {
function TEST (line 231) | TEST(Type, GetParameters) {
function TEST (line 298) | TEST(Type, Is) {
function TEST (line 374) | TEST(Type, As) {
function T (line 460) | T DoGet(const Type& type) {
function TEST (line 464) | TEST(Type, Get) {
function TEST (line 554) | TEST(Type, VerifyTypeImplementsAbslHashCorrectly) {
function TEST (line 621) | TEST(Type, Unwrap) {
function TEST (line 631) | TEST(Type, Wrap) {
FILE: common/type_testing.h
function namespace (line 18) | namespace cel::common_internal {
FILE: common/typeinfo.cc
type cel (line 35) | namespace cel {
type FreeDeleter (line 40) | struct FreeDeleter {
FILE: common/typeinfo.h
function namespace (line 45) | namespace cel {
function class (line 107) | class TypeInfo final {
function H (line 143) | H AbslHashValue(H state, TypeInfo id) {
function explicit (line 157) | constexpr explicit TypeInfo(const std::type_info* absl_nullable rep)
function explicit (line 162) | constexpr explicit TypeInfo(const void* absl_nullable rep) : rep_(rep) {}
function namespace (line 169) | namespace common_internal {
function IndexFor (line 202) | size_t IndexFor() {
function Size (line 208) | static size_t Size() {
FILE: common/typeinfo_test.cc
type cel (line 24) | namespace cel {
type Type1 (line 31) | struct Type1 {}
type Type2 (line 33) | struct Type2 {}
type Type3 (line 35) | struct Type3 {}
function TEST (line 37) | TEST(TypeInfo, ImplementsAbslHashCorrectly) {
function TEST (line 43) | TEST(TypeInfo, Ostream) {
function TEST (line 53) | TEST(TypeInfo, AbslStringify) {
type TestType (line 58) | struct TestType {}
type NativeTypeTraits<TestType> (line 63) | struct NativeTypeTraits<TestType> final {
method TypeInfo (line 64) | static TypeInfo Id(const TestType&) { return cel::TypeId<TestType>(); }
function TEST (line 69) | TEST(TypeInfo, Of) {
FILE: common/types/any_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/any_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(AnyType, Kind) {
function TEST (line 29) | TEST(AnyType, Name) {
function TEST (line 34) | TEST(AnyType, DebugString) {
function TEST (line 47) | TEST(AnyType, Hash) {
function TEST (line 51) | TEST(AnyType, Equal) {
FILE: common/types/basic_struct_type.cc
type cel (line 22) | namespace cel {
function IsWellKnownMessageType (line 24) | bool IsWellKnownMessageType(absl::string_view name) {
FILE: common/types/basic_struct_type.h
function namespace (line 30) | namespace cel {
FILE: common/types/basic_struct_type_test.cc
type cel::common_internal (line 19) | namespace cel::common_internal {
function TEST (line 25) | TEST(BasicStructType, Kind) {
function TEST (line 29) | TEST(BasicStructType, Default) {
function TEST (line 36) | TEST(BasicStructType, Name) {
FILE: common/types/bool_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/bool_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(BoolType, Kind) {
function TEST (line 29) | TEST(BoolType, Name) {
function TEST (line 34) | TEST(BoolType, DebugString) {
function TEST (line 47) | TEST(BoolType, Hash) {
function TEST (line 51) | TEST(BoolType, Equal) {
FILE: common/types/bool_wrapper_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/bool_wrapper_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(BoolWrapperType, Kind) {
function TEST (line 29) | TEST(BoolWrapperType, Name) {
function TEST (line 34) | TEST(BoolWrapperType, DebugString) {
function TEST (line 47) | TEST(BoolWrapperType, Hash) {
function TEST (line 51) | TEST(BoolWrapperType, Equal) {
FILE: common/types/bytes_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/bytes_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(BytesType, Kind) {
function TEST (line 29) | TEST(BytesType, Name) {
function TEST (line 34) | TEST(BytesType, DebugString) {
function TEST (line 47) | TEST(BytesType, Hash) {
function TEST (line 51) | TEST(BytesType, Equal) {
FILE: common/types/bytes_wrapper_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/bytes_wrapper_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(BytesWrapperType, Kind) {
function TEST (line 29) | TEST(BytesWrapperType, Name) {
function TEST (line 34) | TEST(BytesWrapperType, DebugString) {
function TEST (line 47) | TEST(BytesWrapperType, Hash) {
function TEST (line 51) | TEST(BytesWrapperType, Equal) {
FILE: common/types/double_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/double_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(DoubleType, Kind) {
function TEST (line 29) | TEST(DoubleType, Name) {
function TEST (line 34) | TEST(DoubleType, DebugString) {
function TEST (line 47) | TEST(DoubleType, Hash) {
function TEST (line 51) | TEST(DoubleType, Equal) {
FILE: common/types/double_wrapper_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/double_wrapper_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(DoubleWrapperType, Kind) {
function TEST (line 29) | TEST(DoubleWrapperType, Name) {
function TEST (line 34) | TEST(DoubleWrapperType, DebugString) {
function TEST (line 47) | TEST(DoubleWrapperType, Hash) {
function TEST (line 52) | TEST(DoubleWrapperType, Equal) {
FILE: common/types/duration_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/duration_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(DurationType, Kind) {
function TEST (line 29) | TEST(DurationType, Name) {
function TEST (line 34) | TEST(DurationType, DebugString) {
function TEST (line 47) | TEST(DurationType, Hash) {
function TEST (line 51) | TEST(DurationType, Equal) {
FILE: common/types/dyn_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/dyn_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(DynType, Kind) {
function TEST (line 29) | TEST(DynType, Name) {
function TEST (line 34) | TEST(DynType, DebugString) {
function TEST (line 47) | TEST(DynType, Hash) {
function TEST (line 51) | TEST(DynType, Equal) {
FILE: common/types/enum_type.cc
type cel (line 23) | namespace cel {
function IsWellKnownEnumType (line 27) | bool IsWellKnownEnumType(const EnumDescriptor* absl_nonnull descriptor) {
FILE: common/types/enum_type.h
function namespace (line 34) | namespace cel {
function namespace (line 113) | namespace std {
FILE: common/types/enum_type_test.cc
type cel (line 22) | namespace cel {
function TEST (line 30) | TEST(EnumType, Kind) { EXPECT_EQ(EnumType::kind(), TypeKind::kEnum); }
function TEST (line 32) | TEST(EnumType, Default) {
function TEST (line 39) | TEST(EnumType, Descriptor) {
FILE: common/types/error_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/error_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(ErrorType, Kind) {
function TEST (line 29) | TEST(ErrorType, Name) {
function TEST (line 34) | TEST(ErrorType, DebugString) {
function TEST (line 47) | TEST(ErrorType, Hash) {
function TEST (line 51) | TEST(ErrorType, Equal) {
FILE: common/types/function_type.cc
type cel (line 28) | namespace cel {
type TypeFormatter (line 32) | struct TypeFormatter {
function FunctionDebugString (line 38) | std::string FunctionDebugString(const Type& result,
type common_internal (line 46) | namespace common_internal {
function FunctionType (line 67) | FunctionType(
function TypeParameters (line 74) | TypeParameters FunctionType::GetParameters() const {
function Type (line 79) | const Type& FunctionType::result() const {
FILE: common/types/function_type.h
function namespace (line 31) | namespace cel {
FILE: common/types/function_type_pool.cc
type cel::common_internal (line 20) | namespace cel::common_internal {
function FunctionType (line 22) | FunctionType FunctionTypePool::InternFunctionType(const Type& result,
FILE: common/types/function_type_pool.h
function namespace (line 34) | namespace cel::common_internal {
FILE: common/types/function_type_test.cc
type cel (line 22) | namespace cel {
function TEST (line 25) | TEST(FunctionType, Kind) {
function TEST (line 33) | TEST(FunctionType, Name) {
function TEST (line 40) | TEST(FunctionType, DebugString) {
function TEST (line 54) | TEST(FunctionType, Hash) {
function TEST (line 60) | TEST(FunctionType, Equal) {
FILE: common/types/int_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/int_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(IntType, Kind) {
function TEST (line 29) | TEST(IntType, Name) {
function TEST (line 34) | TEST(IntType, DebugString) {
function TEST (line 47) | TEST(IntType, Hash) {
function TEST (line 51) | TEST(IntType, Equal) {
FILE: common/types/int_wrapper_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/int_wrapper_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(IntWrapperType, Kind) {
function TEST (line 29) | TEST(IntWrapperType, Name) {
function TEST (line 34) | TEST(IntWrapperType, DebugString) {
function TEST (line 47) | TEST(IntWrapperType, Hash) {
function TEST (line 51) | TEST(IntWrapperType, Equal) {
FILE: common/types/legacy_type_introspector.h
function namespace (line 22) | namespace cel::common_internal {
FILE: common/types/list_type.cc
type cel (line 26) | namespace cel {
type common_internal (line 28) | namespace common_internal {
function TypeParameters (line 57) | TypeParameters ListType::GetParameters() const {
function Type (line 61) | Type ListType::GetElement() const {
function Type (line 75) | Type ListType::element() const { return GetElement(); }
FILE: common/types/list_type.h
function namespace (line 34) | namespace cel {
function ListType (line 111) | inline ListType JsonListType() { return ListType(); }
FILE: common/types/list_type_pool.cc
type cel::common_internal (line 19) | namespace cel::common_internal {
function ListType (line 21) | ListType ListTypePool::InternListType(const Type& element) {
FILE: common/types/list_type_pool.h
function namespace (line 29) | namespace cel::common_internal {
function const (line 54) | struct Equaler {
function const (line 65) | bool operator()(const Type& lhs, const ListType& rhs) const {
function const (line 69) | bool operator()(const Type& lhs, const Type& rhs) const {
FILE: common/types/list_type_test.cc
type cel (line 22) | namespace cel {
function TEST (line 25) | TEST(ListType, Default) {
function TEST (line 30) | TEST(ListType, Kind) {
function TEST (line 36) | TEST(ListType, Name) {
function TEST (line 42) | TEST(ListType, DebugString) {
function TEST (line 56) | TEST(ListType, Hash) {
function TEST (line 62) | TEST(ListType, Equal) {
FILE: common/types/map_type.cc
type cel (line 26) | namespace cel {
type common_internal (line 28) | namespace common_internal {
function TypeParameters (line 68) | TypeParameters MapType::GetParameters() const {
function Type (line 84) | Type MapType::GetKey() const {
function Type (line 99) | Type MapType::key() const { return GetKey(); }
function Type (line 101) | Type MapType::GetValue() const {
function Type (line 116) | Type MapType::value() const { return GetValue(); }
function MapType (line 118) | MapType JsonMapType() {
FILE: common/types/map_type.h
function namespace (line 34) | namespace cel {
FILE: common/types/map_type_pool.cc
type cel::common_internal (line 19) | namespace cel::common_internal {
function MapType (line 21) | MapType MapTypePool::InternMapType(const Type& key, const Type& value) {
FILE: common/types/map_type_pool.h
function namespace (line 31) | namespace cel::common_internal {
FILE: common/types/map_type_test.cc
type cel (line 22) | namespace cel {
function TEST (line 25) | TEST(MapType, Default) {
function TEST (line 31) | TEST(MapType, Kind) {
function TEST (line 38) | TEST(MapType, Name) {
function TEST (line 45) | TEST(MapType, DebugString) {
function TEST (line 59) | TEST(MapType, Hash) {
function TEST (line 65) | TEST(MapType, Equal) {
FILE: common/types/message_type.cc
type cel (line 25) | namespace cel {
function IsWellKnownMessageType (line 29) | bool IsWellKnownMessageType(const Descriptor* absl_nonnull descriptor) {
function Type (line 90) | Type MessageTypeField::GetType() const {
FILE: common/types/message_type.h
function namespace (line 35) | namespace cel {
function namespace (line 120) | namespace std {
function namespace (line 135) | namespace cel {
function namespace (line 185) | namespace std {
FILE: common/types/message_type_test.cc
type cel (line 22) | namespace cel {
function TEST (line 32) | TEST(MessageType, Kind) { EXPECT_EQ(MessageType::kind(), TypeKind::kSt...
function TEST (line 34) | TEST(MessageType, Default) {
function TEST (line 41) | TEST(MessageType, Descriptor) {
function TEST (line 63) | TEST(MessageTypeField, Descriptor) {
FILE: common/types/null_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/null_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(NullType, Kind) {
function TEST (line 29) | TEST(NullType, Name) {
function TEST (line 34) | TEST(NullType, DebugString) {
function TEST (line 47) | TEST(NullType, Hash) {
function TEST (line 51) | TEST(NullType, Equal) {
FILE: common/types/opaque_type.cc
type cel (line 32) | namespace cel {
function OpaqueDebugString (line 36) | std::string OpaqueDebugString(absl::string_view name,
type common_internal (line 52) | namespace common_internal {
function OpaqueType (line 74) | OpaqueType(
function TypeParameters (line 87) | TypeParameters OpaqueType::GetParameters() const {
function OptionalType (line 104) | OptionalType OpaqueType::GetOptional() const {
FILE: common/types/opaque_type.h
function namespace (line 34) | namespace cel {
FILE: common/types/opaque_type_pool.cc
type cel::common_internal (line 21) | namespace cel::common_internal {
function OpaqueType (line 23) | OpaqueType OpaqueTypePool::InternOpaqueType(absl::string_view name,
FILE: common/types/opaque_type_pool.h
function namespace (line 34) | namespace cel::common_internal {
FILE: common/types/opaque_type_test.cc
type cel (line 22) | namespace cel {
function TEST (line 25) | TEST(OpaqueType, Kind) {
function TEST (line 33) | TEST(OpaqueType, Name) {
function TEST (line 41) | TEST(OpaqueType, DebugString) {
function TEST (line 60) | TEST(OpaqueType, Hash) {
function TEST (line 66) | TEST(OpaqueType, Equal) {
FILE: common/types/optional_type.cc
type cel (line 21) | namespace cel {
type common_internal (line 23) | namespace common_internal {
type OptionalTypeData (line 27) | struct OptionalTypeData final {
function Type (line 66) | Type OptionalType::GetParameter() const { return GetParameters().front...
FILE: common/types/optional_type.h
function namespace (line 36) | namespace cel {
FILE: common/types/optional_type_test.cc
type cel (line 22) | namespace cel {
function TEST (line 25) | TEST(OptionalType, Default) {
function TEST (line 30) | TEST(OptionalType, Kind) {
function TEST (line 36) | TEST(OptionalType, Name) {
function TEST (line 42) | TEST(OptionalType, DebugString) {
function TEST (line 56) | TEST(OptionalType, Parameter) {
function TEST (line 61) | TEST(OptionalType, Hash) {
function TEST (line 67) | TEST(OptionalType, Equal) {
FILE: common/types/string_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/string_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(StringType, Kind) {
function TEST (line 29) | TEST(StringType, Name) {
function TEST (line 34) | TEST(StringType, DebugString) {
function TEST (line 47) | TEST(StringType, Hash) {
function TEST (line 51) | TEST(StringType, Equal) {
FILE: common/types/string_wrapper_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/string_wrapper_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(StringWrapperType, Kind) {
function TEST (line 29) | TEST(StringWrapperType, Name) {
function TEST (line 34) | TEST(StringWrapperType, DebugString) {
function TEST (line 47) | TEST(StringWrapperType, Hash) {
function TEST (line 52) | TEST(StringWrapperType, Equal) {
FILE: common/types/struct_type.cc
type cel (line 25) | namespace cel {
function TypeParameters (line 38) | TypeParameters StructType::GetParameters() const {
function MessageType (line 67) | MessageType StructType::GetMessage() const {
FILE: common/types/struct_type.h
function namespace (line 36) | namespace cel {
function TypeKind (line 85) | static TypeKind kind() { return kKind; }
function IsMessage (line 93) | bool IsMessage() const {
FILE: common/types/struct_type_test.cc
type cel (line 25) | namespace cel {
class StructTypeTest (line 30) | class StructTypeTest : public Test {
method SetUp (line 32) | void SetUp() override {
method GetDescriptor (line 43) | GetDescriptor() const {
method MessageType (line 47) | MessageType GetMessageType() const { return MessageType(GetDescripto...
method GetBasicStructType (line 49) | common_internal::BasicStructType GetBasicStructType() const {
function TEST (line 57) | TEST(StructType, Kind) { EXPECT_EQ(StructType::kind(), TypeKind::kStru...
function TEST_F (line 59) | TEST_F(StructTypeTest, Name) {
function TEST_F (line 65) | TEST_F(StructTypeTest, DebugString) {
function TEST_F (line 72) | TEST_F(StructTypeTest, Hash) {
function TEST_F (line 77) | TEST_F(StructTypeTest, Equal) {
FILE: common/types/timestamp_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/timestamp_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(TimestampType, Kind) {
function TEST (line 29) | TEST(TimestampType, Name) {
function TEST (line 34) | TEST(TimestampType, DebugString) {
function TEST (line 47) | TEST(TimestampType, Hash) {
function TEST (line 51) | TEST(TimestampType, Equal) {
FILE: common/types/type_param_type.h
function namespace (line 29) | namespace cel {
FILE: common/types/type_param_type_test.cc
type cel (line 22) | namespace cel {
function TEST (line 25) | TEST(TypeParamType, Kind) {
function TEST (line 30) | TEST(TypeParamType, Name) {
function TEST (line 35) | TEST(TypeParamType, DebugString) {
function TEST (line 48) | TEST(TypeParamType, Hash) {
function TEST (line 52) | TEST(TypeParamType, Equal) {
FILE: common/types/type_pool.cc
type cel::common_internal (line 24) | namespace cel::common_internal {
function StructType (line 26) | StructType TypePool::MakeStructType(absl::string_view name) {
function FunctionType (line 38) | FunctionType TypePool::MakeFunctionType(const Type& result,
function ListType (line 44) | ListType TypePool::MakeListType(const Type& element) {
function MapType (line 52) | MapType TypePool::MakeMapType(const Type& key, const Type& value) {
function OpaqueType (line 63) | OpaqueType TypePool::MakeOpaqueType(absl::string_view name,
function OptionalType (line 77) | OptionalType TypePool::MakeOptionalType(const Type& parameter) {
function TypeParamType (line 82) | TypeParamType TypePool::MakeTypeParamType(absl::string_view name) {
function TypeType (line 86) | TypeType TypePool::MakeTypeType(const Type& type) {
FILE: common/types/type_pool.h
function namespace (line 37) | namespace cel::common_internal {
FILE: common/types/type_pool_test.cc
type cel::common_internal (line 22) | namespace cel::common_internal {
function TEST (line 28) | TEST(TypePool, MakeStructType) {
function TEST (line 41) | TEST(TypePool, MakeFunctionType) {
function TEST (line 48) | TEST(TypePool, MakeListType) {
function TEST (line 57) | TEST(TypePool, MakeMapType) {
function TEST (line 66) | TEST(TypePool, MakeOpaqueType) {
function TEST (line 73) | TEST(TypePool, MakeOptionalType) {
function TEST (line 81) | TEST(TypePool, MakeTypeParamType) {
function TEST (line 87) | TEST(TypePool, MakeTypeType) {
FILE: common/types/type_type.cc
type cel (line 25) | namespace cel {
type common_internal (line 27) | namespace common_internal {
type TypeTypeData (line 29) | struct TypeTypeData final {
method TypeTypeData (line 30) | static TypeTypeData* Create(google::protobuf::Arena* absl_nonnull ...
method TypeTypeData (line 35) | explicit TypeTypeData(const Type& type) : type(type) {}
method TypeTypeData (line 37) | TypeTypeData() = delete;
method TypeTypeData (line 38) | TypeTypeData(const TypeTypeData&) = delete;
method TypeTypeData (line 39) | TypeTypeData(TypeTypeData&&) = delete;
method TypeTypeData (line 40) | TypeTypeData& operator=(const TypeTypeData&) = delete;
method TypeTypeData (line 41) | TypeTypeData& operator=(TypeTypeData&&) = delete;
function TypeType (line 58) | TypeType(common_internal::TypeTypeData::Create(arena, parameter)) {}
function TypeParameters (line 60) | TypeParameters TypeType::GetParameters() const {
function Type (line 67) | Type TypeType::GetType() const {
FILE: common/types/type_type.h
function namespace (line 31) | namespace cel {
FILE: common/types/type_type_pool.cc
type cel::common_internal (line 19) | namespace cel::common_internal {
function TypeType (line 21) | TypeType TypeTypePool::InternTypeType(const Type& type) {
FILE: common/types/type_type_pool.h
function namespace (line 30) | namespace cel::common_internal {
function const (line 56) | struct Equaler {
function const (line 70) | bool operator()(const Type& lhs, const TypeType& rhs) const {
function const (line 75) | bool operator()(const Type& lhs, const Type& rhs) const {
FILE: common/types/type_type_test.cc
type cel (line 22) | namespace cel {
function TEST (line 25) | TEST(TypeType, Kind) {
function TEST (line 30) | TEST(TypeType, Name) {
function TEST (line 35) | TEST(TypeType, DebugString) {
function TEST (line 48) | TEST(TypeType, Hash) {
function TEST (line 52) | TEST(TypeType, Equal) {
FILE: common/types/types.h
function namespace (line 25) | namespace cel {
FILE: common/types/uint_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/uint_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(UintType, Kind) {
function TEST (line 29) | TEST(UintType, Name) {
function TEST (line 34) | TEST(UintType, DebugString) {
function TEST (line 47) | TEST(UintType, Hash) {
function TEST (line 51) | TEST(UintType, Equal) {
FILE: common/types/uint_wrapper_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/uint_wrapper_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(UintWrapperType, Kind) {
function TEST (line 29) | TEST(UintWrapperType, Name) {
function TEST (line 34) | TEST(UintWrapperType, DebugString) {
function TEST (line 47) | TEST(UintWrapperType, Hash) {
function TEST (line 51) | TEST(UintWrapperType, Equal) {
FILE: common/types/unknown_type.h
function namespace (line 28) | namespace cel {
FILE: common/types/unknown_type_test.cc
type cel (line 21) | namespace cel {
function TEST (line 24) | TEST(UnknownType, Kind) {
function TEST (line 29) | TEST(UnknownType, Name) {
function TEST (line 34) | TEST(UnknownType, DebugString) {
function TEST (line 47) | TEST(UnknownType, Hash) {
function TEST (line 51) | TEST(UnknownType, Equal) {
FILE: common/unknown.h
function namespace (line 20) | namespace cel {
FILE: common/value.cc
type cel (line 61) | namespace cel {
function Type (line 76) | Type Value::GetRuntimeType() const {
type IsMonostate (line 118) | struct IsMonostate : std::is_same<absl::remove_cvref_t<T>, absl::monos...
type HasCloneMethod (line 287) | struct HasCloneMethod : std::false_type {}
function Value (line 296) | Value Value::Clone(google::protobuf::Arena* absl_nonnull arena) const {
function Value (line 317) | Value NonNullEnumValue(const google::protobuf::EnumValueDescriptor* ab...
function Value (line 322) | Value NonNullEnumValue(const google::protobuf::EnumDescriptor* absl_no...
function Value (line 336) | Value Value::Enum(const google::protobuf::EnumValueDescriptor* absl_no...
function Value (line 345) | Value Value::Enum(const google::protobuf::EnumDescriptor* absl_nonnull...
type common_internal (line 355) | namespace common_internal {
function BoolMapFieldKeyAccessor (line 359) | void BoolMapFieldKeyAccessor(const google::protobuf::MapKey& key,
function Int32MapFieldKeyAccessor (line 370) | void Int32MapFieldKeyAccessor(const google::protobuf::MapKey& key,
function Int64MapFieldKeyAccessor (line 381) | void Int64MapFieldKeyAccessor(const google::protobuf::MapKey& key,
function UInt32MapFieldKeyAccessor (line 392) | void UInt32MapFieldKeyAccessor(const google::protobuf::MapKey& key,
function UInt64MapFieldKeyAccessor (line 403) | void UInt64MapFieldKeyAccessor(const google::protobuf::MapKey& key,
function StringMapFieldKeyAccessor (line 414) | void StringMapFieldKeyAccessor(const google::protobuf::MapKey& key,
function MapFieldKeyAccessorFor (line 432) | absl::StatusOr<MapFieldKeyAccessor> MapFieldKeyAccessorFor(
function DoubleMapFieldValueAccessor (line 455) | void DoubleMapFieldValueAccessor(
function FloatMapFieldValueAccessor (line 474) | void FloatMapFieldValueAccessor(
function Int64MapFieldValueAccessor (line 493) | void Int64MapFieldValueAccessor(
function UInt64MapFieldValueAccessor (line 512) | void UInt64MapFieldValueAccessor(
function Int32MapFieldValueAccessor (line 531) | void Int32MapFieldValueAccessor(
function UInt32MapFieldValueAccessor (line 550) | void UInt32MapFieldValueAccessor(
function BoolMapFieldValueAccessor (line 569) | void BoolMapFieldValueAccessor(
function StringMapFieldValueAccessor (line 588) | void StringMapFieldValueAccessor(
function MessageMapFieldValueAccessor (line 611) | void MessageMapFieldValueAccessor(
function BytesMapFieldValueAccessor (line 631) | void BytesMapFieldValueAccessor(
function EnumMapFieldValueAccessor (line 654) | void EnumMapFieldValueAccessor(
function NullMapFieldValueAccessor (line 673) | void NullMapFieldValueAccessor(
function MapFieldValueAccessorFor (line 695) | absl::StatusOr<MapFieldValueAccessor> MapFieldValueAccessorFor(
function DoubleRepeatedFieldAccessor (line 746) | void DoubleRepeatedFieldAccessor(
function FloatRepeatedFieldAccessor (line 770) | void FloatRepeatedFieldAccessor(
function Int64RepeatedFieldAccessor (line 794) | void Int64RepeatedFieldAccessor(
function UInt64RepeatedFieldAccessor (line 818) | void UInt64RepeatedFieldAccessor(
function Int32RepeatedFieldAccessor (line 842) | void Int32RepeatedFieldAccessor(
function UInt32RepeatedFieldAccessor (line 866) | void UInt32RepeatedFieldAccessor(
function BoolRepeatedFieldAccessor (line 890) | void BoolRepeatedFieldAccessor(
function StringRepeatedFieldAccessor (line 914) | void StringRepeatedFieldAccessor(
function MessageRepeatedFieldAccessor (line 955) | void MessageRepeatedFieldAccessor(
function BytesRepeatedFieldAccessor (line 981) | void BytesRepeatedFieldAccessor(
function EnumRepeatedFieldAccessor (line 1022) | void EnumRepeatedFieldAccessor(
function NullRepeatedFieldAccessor (line 1048) | void NullRepeatedFieldAccessor(
function RepeatedFieldAccessorFor (line 1075) | absl::StatusOr<RepeatedFieldAccessor> RepeatedFieldAccessorFor(
function Value (line 1130) | Value VistWellKnownTypeValue(std::nullptr_t) { return NullValue(); }
function Value (line 1132) | Value VistWellKnownTypeValue(bool value) { return BoolValue(value); }
function Value (line 1134) | Value VistWellKnownTypeValue(int32_t value) { return IntValue(value); }
function Value (line 1136) | Value VistWellKnownTypeValue(int64_t value) { return IntValue(value); }
function Value (line 1138) | Value VistWellKnownTypeValue(uint32_t value) { return UintValue(value); }
function Value (line 1140) | Value VistWellKnownTypeValue(uint64_t value) { return UintValue(value); }
function Value (line 1142) | Value VistWellKnownTypeValue(float value) { return DoubleValue(value); }
function Value (line 1144) | Value VistWellKnownTypeValue(double value) { return DoubleValue(value); }
function Value (line 1146) | Value VistWellKnownTypeValue(absl::Duration value) {
function Value (line 1150) | Value VistWellKnownTypeValue(absl::Time value) { return TimestampValue...
type OwningWellKnownTypesValueVisitor (line 1152) | struct OwningWellKnownTypesValueVisitor {
method Value (line 1156) | Value operator()(well_known_types::BytesValue&& value) const {
method Value (line 1177) | Value operator()(well_known_types::StringValue&& value) const {
method Value (line 1198) | Value operator()(well_known_types::ListValue&& value) const {
method Value (line 1217) | Value operator()(well_known_types::Struct&& value) const {
method Value (line 1236) | Value operator()(Unique<google::protobuf::Message> value) const {
method Value (line 1246) | Value operator()(T t) const {
type BorrowingWellKnownTypesValueVisitor (line 1251) | struct BorrowingWellKnownTypesValueVisitor {
method Value (line 1256) | Value operator()(well_known_types::BytesValue&& value) const {
method Value (line 1274) | Value operator()(well_known_types::StringValue&& value) const {
method Value (line 1292) | Value operator()(well_known_types::ListValue&& value) const {
method Value (line 1311) | Value operator()(well_known_types::Struct&& value) const {
method Value (line 1329) | Value operator()(Unique<google::protobuf::Message>&& value) const {
method Value (line 1339) | Value operator()(T t) const {
function Value (line 1346) | Value Value::FromMessage(
function Value (line 1374) | Value Value::FromMessage(
function Value (line 1402) | Value Value::WrapMessage(
function Value (line 1436) | Value Value::WrapMessageUnsafe(
function IsWellKnownMessageWrapperType (line 1470) | bool IsWellKnownMessageWrapperType(
function Value (line 1497) | Value WrapFieldImpl(
function Value (line 1634) | Value WrapRepeatedFieldImpl(
function Value (line 1752) | Value WrapMapFieldValueImpl(
function Value (line 1833) | Value Value::WrapField(
function Value (line 1848) | Value Value::WrapFieldUnsafe(
function Value (line 1863) | Value Value::WrapRepeatedField(
function Value (line 1878) | Value Value::WrapRepeatedFieldUnsafe(
function StringValue (line 1893) | StringValue Value::WrapMapFieldKeyString(
function Value (line 1909) | Value Value::WrapMapFieldValue(
function Value (line 1924) | Value Value::WrapMapFieldValueUnsafe(
function BytesValue (line 2351) | const BytesValue& Value::GetBytes() const& {
function BytesValue (line 2356) | BytesValue Value::GetBytes() && {
function DoubleValue (line 2361) | DoubleValue Value::GetDouble() const {
function DurationValue (line 2366) | DurationValue Value::GetDuration() const {
function ErrorValue (line 2371) | const ErrorValue& Value::GetError() const& {
function ErrorValue (line 2376) | ErrorValue Value::GetError() && {
function IntValue (line 2381) | IntValue Value::GetInt() const {
function ListValue (line 2393) | ListValue Value::GetList() const& {
function ListValue (line 2414) | ListValue Value::GetList() && {
function MapValue (line 2435) | MapValue Value::GetMap() const& {
function MapValue (line 2456) | MapValue Value::GetMap() && {
function MessageValue (line 2477) | MessageValue Value::GetMessage() const& {
function MessageValue (line 2482) | MessageValue Value::GetMessage() && {
function NullValue (line 2487) | NullValue Value::GetNull() const {
function OpaqueValue (line 2492) | const OpaqueValue& Value::GetOpaque() const& {
function OpaqueValue (line 2497) | OpaqueValue Value::GetOpaque() && {
function OptionalValue (line 2502) | const OptionalValue& Value::GetOptional() const& {
function OptionalValue (line 2507) | OptionalValue Value::GetOptional() && {
function ParsedJsonListValue (line 2512) | const ParsedJsonListValue& Value::GetParsedJsonList() const& {
function ParsedJsonListValue (line 2517) | ParsedJsonListValue Value::GetParsedJsonList() && {
function ParsedJsonMapValue (line 2522) | const ParsedJsonMapValue& Value::GetParsedJsonMap() const& {
function ParsedJsonMapValue (line 2527) | ParsedJsonMapValue Value::GetParsedJsonMap() && {
function CustomListValue (line 2532) | const CustomListValue& Value::GetCustomList() const& {
function CustomListValue (line 2537) | CustomListValue Value::GetCustomList() && {
function CustomMapValue (line 2542) | const CustomMapValue& Value::GetCustomMap() const& {
function CustomMapValue (line 2547) | CustomMapValue Value::GetCustomMap() && {
function ParsedMapFieldValue (line 2552) | const ParsedMapFieldValue& Value::GetParsedMapField() const& {
function ParsedMapFieldValue (line 2557) | ParsedMapFieldValue Value::GetParsedMapField() && {
function ParsedMessageValue (line 2562) | const ParsedMessageValue& Value::GetParsedMessage() const& {
function ParsedMessageValue (line 2567) | ParsedMessageValue Value::GetParsedMessage() && {
function ParsedRepeatedFieldValue (line 2572) | const ParsedRepeatedFieldValue& Value::GetParsedRepeatedField() const& {
function ParsedRepeatedFieldValue (line 2577) | ParsedRepeatedFieldValue Value::GetParsedRepeatedField() && {
function CustomStructValue (line 2582) | const CustomStructValue& Value::GetCustomStruct() const& {
function CustomStructValue (line 2587) | CustomStructValue Value::GetCustomStruct() && {
function StringValue (line 2592) | const StringValue& Value::GetString() const& {
function StringValue (line 2597) | StringValue Value::GetString() && {
function StructValue (line 2602) | StructValue Value::GetStruct() const& {
function StructValue (line 2620) | StructValue Value::GetStruct() && {
function TimestampValue (line 2637) | TimestampValue Value::GetTimestamp() const {
function TypeValue (line 2642) | const TypeValue& Value::GetType() const& {
function TypeValue (line 2647) | TypeValue Value::GetType() && {
function UintValue (line 2652) | UintValue Value::GetUint() const {
function UnknownValue (line 2657) | const UnknownValue& Value::GetUnknown() const& {
function UnknownValue (line 2662) | UnknownValue Value::GetUnknown() && {
class EmptyValueIterator (line 2669) | class EmptyValueIterator final : public ValueIterator {
method HasNext (line 2671) | bool HasNext() override { return false; }
method Next (line 2673) | absl::Status Next(const google::protobuf::DescriptorPool* absl_nonnu...
method Next1 (line 2687) | absl::StatusOr<bool> Next1(
method Next2 (line 2700) | absl::StatusOr<bool> Next2(
function absl_nonnull (line 2716) | absl_nonnull std::unique_ptr<ValueIterator> NewEmptyValueIterator() {
function absl_nonnull (line 2720) | absl_nonnull ListValueBuilderPtr
function absl_nonnull (line 2726) | absl_nonnull MapValueBuilderPtr
function absl_nullable (line 2732) | absl_nullable StructValueBuilderPtr NewStructValueBuilder(
type HasCloneMethod<T, std::void_t<decltype(std::declval<const T>().Clone(
std::declval<google::protobuf::Arena* absl_nonnull>()))>> (line 290) | struct HasCloneMethod<T, std::void_t<decltype(std::declval<const T>().Cl...
FILE: common/value.h
function namespace (line 92) | namespace cel {
function namespace (line 2616) | namespace common_internal {
function absl (line 2822) | inline absl::StatusOr<Value> ValueIterator::Next(
function absl (line 2835) | inline absl::StatusOr<absl::optional<Value>> ValueIterator::Next1(
function class (line 2872) | class ValueBuilder {
function namespace (line 2910) | namespace common_internal {
FILE: common/value_kind.h
function namespace (line 25) | namespace cel {
FILE: common/value_test.cc
type cel (line 36) | namespace cel {
function TEST (line 51) | TEST(Value, GeneratedEnum) {
function TEST (line 56) | TEST(Value, DynamicEnum) {
function TEST (line 72) | TEST(Value, DynamicClosedEnum) {
function TEST (line 98) | TEST(Value, Is) {
function T (line 170) | constexpr T& AsLValueRef(T& t ABSL_ATTRIBUTE_LIFETIME_BOUND) {
function T (line 175) | constexpr const T& AsConstLValueRef(T& t ABSL_ATTRIBUTE_LIFETIME_BOUND) {
function T (line 180) | constexpr T&& AsRValueRef(T& t ABSL_ATTRIBUTE_LIFETIME_BOUND) {
function T (line 185) | constexpr const T&& AsConstRValueRef(T& t ABSL_ATTRIBUTE_LIFETIME_BOUN...
function TEST (line 189) | TEST(Value, As) {
function DoGet (line 597) | decltype(auto) DoGet(From&& from) {
function TEST (line 601) | TEST(Value, Get) {
function TEST (line 960) | TEST(Value, NumericHeterogeneousEquality) {
function TEST_F (line 978) | TEST_F(ValueIteratorTest, Empty) {
function TEST_F (line 985) | TEST_F(ValueIteratorTest, Empty1) {
function TEST_F (line 991) | TEST_F(ValueIteratorTest, Empty2) {
FILE: common/value_testing.cc
type cel (line 28) | namespace cel {
function PrintTo (line 30) | void PrintTo(const Value& value, std::ostream* os) { *os << value << "...
type test (line 32) | namespace test {
function ValueKind (line 38) | constexpr ValueKind ToValueKind() {
class SimpleTypeMatcherImpl (line 72) | class SimpleTypeMatcherImpl : public testing::MatcherInterface<const...
method SimpleTypeMatcherImpl (line 76) | explicit SimpleTypeMatcherImpl(MatcherType&& matcher)
method MatchAndExplain (line 79) | bool MatchAndExplain(const Value& v,
method DescribeTo (line 85) | void DescribeTo(std::ostream* os) const override {
class StringTypeMatcherImpl (line 96) | class StringTypeMatcherImpl : public testing::MatcherInterface<const...
method StringTypeMatcherImpl (line 100) | explicit StringTypeMatcherImpl(MatcherType matcher)
method MatchAndExplain (line 103) | bool MatchAndExplain(const Value& v,
method DescribeTo (line 108) | void DescribeTo(std::ostream* os) const override {
class AbstractTypeMatcherImpl (line 119) | class AbstractTypeMatcherImpl : public testing::MatcherInterface<con...
method AbstractTypeMatcherImpl (line 123) | explicit AbstractTypeMatcherImpl(MatcherType&& matcher)
method MatchAndExplain (line 126) | bool MatchAndExplain(const Value& v,
method DescribeTo (line 131) | void DescribeTo(std::ostream* os) const override {
class OptionalValueMatcherImpl (line 141) | class OptionalValueMatcherImpl
method OptionalValueMatcherImpl (line 144) | explicit OptionalValueMatcherImpl(ValueMatcher matcher)
method MatchAndExplain (line 147) | bool MatchAndExplain(const Value& v,
method DescribeTo (line 161) | void DescribeTo(std::ostream* os) const override {
function ValueMatcher (line 184) | ValueMatcher BoolValueIs(Matcher<bool> m) {
function ValueMatcher (line 188) | ValueMatcher IntValueIs(Matcher<int64_t> m) {
function ValueMatcher (line 193) | ValueMatcher UintValueIs(Matcher<uint64_t> m) {
function ValueMatcher (line 198) | ValueMatcher DoubleValueIs(Matcher<double> m) {
function ValueMatcher (line 203) | ValueMatcher TimestampValueIs(Matcher<absl::Time> m) {
function ValueMatcher (line 208) | ValueMatcher DurationValueIs(Matcher<absl::Duration> m) {
function ValueMatcher (line 213) | ValueMatcher ErrorValueIs(Matcher<absl::Status> m) {
function ValueMatcher (line 218) | ValueMatcher StringValueIs(Matcher<std::string> m) {
function ValueMatcher (line 222) | ValueMatcher BytesValueIs(Matcher<std::string> m) {
function ValueMatcher (line 226) | ValueMatcher MapValueIs(Matcher<MapValue> m) {
function ValueMatcher (line 230) | ValueMatcher ListValueIs(Matcher<ListValue> m) {
function ValueMatcher (line 234) | ValueMatcher StructValueIs(Matcher<StructValue> m) {
function ValueMatcher (line 238) | ValueMatcher OptionalValueIs(ValueMatcher m) {
function ValueMatcher (line 242) | ValueMatcher OptionalValueIsEmpty() { return OptionalValueIsEmptyImp...
FILE: common/value_testing.h
function namespace (line 45) | namespace cel {
function ListValueElementsMatcher (line 170) | inline ListValueElementsMatcher ListValueElements(
function class (line 181) | class MapValueElementsMatcher {
function DescribeTo (line 214) | void DescribeTo(std::ostream* os) const { *os << m_; }
function DescribeNegationTo (line 215) | void DescribeNegationTo(std::ostream* os) const { *os << m_; }
function MapValueElementsMatcher (line 227) | inline MapValueElementsMatcher MapValueElements(
function namespace (line 242) | namespace cel::common_internal {
FILE: common/value_testing_test.cc
type cel::test (line 25) | namespace cel::test {
function TEST (line 34) | TEST(BoolValueIs, Match) { EXPECT_THAT(BoolValue(true), BoolValueIs(tr...
function TEST (line 36) | TEST(BoolValueIs, NoMatch) {
function TEST (line 41) | TEST(BoolValueIs, NonMatchMessage) {
function TEST (line 47) | TEST(IntValueIs, Match) { EXPECT_THAT(IntValue(42), IntValueIs(42)); }
function TEST (line 49) | TEST(IntValueIs, NoMatch) {
function TEST (line 54) | TEST(IntValueIs, NonMatchMessage) {
function TEST (line 60) | TEST(UintValueIs, Match) { EXPECT_THAT(UintValue(42), UintValueIs(42)); }
function TEST (line 62) | TEST(UintValueIs, NoMatch) {
function TEST (line 67) | TEST(UintValueIs, NonMatchMessage) {
function TEST (line 73) | TEST(DoubleValueIs, Match) {
function TEST (line 77) | TEST(DoubleValueIs, NoMatch) {
function TEST (line 82) | TEST(DoubleValueIs, NonMatchMessage) {
function TEST (line 88) | TEST(DurationValueIs, Match) {
function TEST (line 93) | TEST(DurationValueIs, NoMatch) {
function TEST (line 99) | TEST(DurationValueIs, NonMatchMessage) {
function TEST (line 105) | TEST(TimestampValueIs, Match) {
function TEST (line 110) | TEST(TimestampValueIs, NoMatch) {
function TEST (line 117) | TEST(TimestampValueIs, NonMatchMessage) {
function TEST (line 126) | TEST(StringValueIs, Match) {
function TEST (line 130) | TEST(StringValueIs, NoMatch) {
function TEST (line 135) | TEST(StringValueIs, NonMatchMessage) {
function TEST (line 141) | TEST(BytesValueIs, Match) {
function TEST (line 145) | TEST(BytesValueIs, NoMatch) {
function TEST (line 150) | TEST(BytesValu
Condensed preview — 1115 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (9,522K chars).
[
{
"path": ".bazelrc",
"chars": 1502,
"preview": "common --enable_platform_specific_config\n\nbuild --enable_bzlmod\nbuild --compilation_mode=fastbuild\n\nbuild:linux --cxxopt"
},
{
"path": ".bazelversion",
"chars": 6,
"preview": "7.3.2\n"
},
{
"path": ".bcr/README.md",
"chars": 1491,
"preview": "# BCR Publishing Templates\n\nThis directory contains templates used by the\n[Publish to BCR](https://github.com/bazel-cont"
},
{
"path": ".bcr/metadata.template.json",
"chars": 672,
"preview": "{\n \"homepage\": \"https://cel.dev\",\n \"maintainers\": [\n {\n \"email\": \"ferstl@intrinsic.ai\",\n \"github\": \"ferst"
},
{
"path": ".bcr/presubmit.yml",
"chars": 370,
"preview": "matrix:\n platform:\n - debian11\n - ubuntu2004\n bazel:\n - 8.x\n - 7.x\ntasks:\n verify_targets:\n name: Verify build"
},
{
"path": ".bcr/source.template.json",
"chars": 138,
"preview": "{\n \"integrity\": \"\",\n \"strip_prefix\": \"cel-cpp-{VERSION}\",\n \"url\": \"https://github.com/{OWNER}/{REPO}/archive/refs/tag"
},
{
"path": ".github/workflows/publish_to_bcr.yml",
"chars": 344,
"preview": "name: Publish to BCR\n\non:\n push:\n tags:\n - \"v*.*.*\"\n\npermissions:\n id-token: write\n attestations: write\n con"
},
{
"path": ".gitignore",
"chars": 141,
"preview": "bazel-bin\nbazel-eval\nbazel-genfiles\nbazel-out\nbazel-testlogs\nbazel-cel-cpp\n*~\nclang.bazelrc\nuser.bazelrc\nlocal_tsan.baze"
},
{
"path": "BUILD.bazel",
"chars": 54,
"preview": "package(default_visibility = [\"//visibility:public\"])\n"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 1200,
"preview": "# Contributor Code of Conduct\n## Version 0.1.1 (adapted from 0.3b-angular)\n\nAs contributors and maintainers of the Commo"
},
{
"path": "CONTRIBUTING.md",
"chars": 1414,
"preview": "# How to Contribute\n\nWe'd love to accept your patches and contributions to this project. There are\na few guidelines you "
},
{
"path": "Dockerfile",
"chars": 1729,
"preview": "# This Dockerfile is used to create a container around gcc9 and bazel for\n# building the CEL C++ library on GitHub.\n#\n# "
},
{
"path": "LICENSE",
"chars": 11358,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "MODULE.bazel",
"chars": 2157,
"preview": "module(\n name = \"cel-cpp\",\n)\n\nbazel_dep(\n name = \"bazel_skylib\",\n version = \"1.9.0\",\n)\nbazel_dep(\n name = \"g"
},
{
"path": "README.md",
"chars": 326,
"preview": "# C++ Implementations of the Common Expression Language\n\nFor background on the Common Expression Language see the [cel-s"
},
{
"path": "base/BUILD",
"chars": 3511,
"preview": "# Copyright 2021 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "base/ast.h",
"chars": 762,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/attribute.cc",
"chars": 9374,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/attribute.h",
"chars": 8878,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/attribute_set.h",
"chars": 3130,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/builtins.h",
"chars": 3578,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/function.h",
"chars": 783,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/function_adapter.h",
"chars": 814,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/function_descriptor.h",
"chars": 826,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/function_result.h",
"chars": 2438,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/function_result_set.cc",
"chars": 987,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/function_result_set.h",
"chars": 3391,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/internal/BUILD",
"chars": 1412,
"preview": "# Copyright 2021 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "base/internal/memory_manager_testing.cc",
"chars": 949,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/internal/memory_manager_testing.h",
"chars": 1725,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/internal/message_wrapper.h",
"chars": 1179,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/internal/operators.h",
"chars": 3239,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/internal/unknown_set.cc",
"chars": 1051,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/internal/unknown_set.h",
"chars": 4346,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/kind.h",
"chars": 985,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/operators.cc",
"chars": 10353,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/operators.h",
"chars": 16189,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/operators_test.cc",
"chars": 8160,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "base/type_provider.h",
"chars": 861,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "bazel/BUILD",
"chars": 1070,
"preview": "load(\"@rules_cc//cc:cc_binary.bzl\", \"cc_binary\")\nload(\"@rules_java//java:defs.bzl\", \"java_binary\")\n\njava_binary(\n nam"
},
{
"path": "bazel/antlr.bzl",
"chars": 4387,
"preview": "# Copyright 2021 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "bazel/antlr.patch",
"chars": 900,
"preview": "--- BUILD.bazel\n+++ BUILD.bazel\n@@ -17,21 +17,21 @@\n cc_library(\n name = \"antlr4-cpp-runtime\",\n srcs = glob([\"ru"
},
{
"path": "bazel/cat_param_file.cc",
"chars": 1884,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "bazel/cel_cc_embed.bzl",
"chars": 1491,
"preview": "# Copyright 2024 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "bazel/cel_cc_embed.cc",
"chars": 2550,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "bazel/cel_proto_transitive_descriptor_set.bzl",
"chars": 1940,
"preview": "# Copyright 2024 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "bazel/deps.bzl",
"chars": 9163,
"preview": "\"\"\"\nLegacy workspace dependencies of cel-cpp.\n\nDependencies are now managed by MODULE.bazel. The values here are not upd"
},
{
"path": "checker/BUILD",
"chars": 7271,
"preview": "load(\"@rules_cc//cc:cc_library.bzl\", \"cc_library\")\nload(\"@rules_cc//cc:cc_test.bzl\", \"cc_test\")\n\n# Copyright 2024 Google"
},
{
"path": "checker/checker_options.h",
"chars": 4576,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/BUILD",
"chars": 9785,
"preview": "# Copyright 2024 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "checker/internal/builtins_arena.cc",
"chars": 958,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/builtins_arena.h",
"chars": 1072,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/descriptor_pool_type_introspector.cc",
"chars": 8867,
"preview": "// Copyright 2026 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/descriptor_pool_type_introspector.h",
"chars": 3961,
"preview": "// Copyright 2026 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/descriptor_pool_type_introspector_test.cc",
"chars": 6666,
"preview": "// Copyright 2026 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/format_type_name.cc",
"chars": 5310,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/format_type_name.h",
"chars": 1070,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/format_type_name_test.cc",
"chars": 4456,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/namespace_generator.cc",
"chars": 6125,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/namespace_generator.h",
"chars": 4310,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/namespace_generator_test.cc",
"chars": 5523,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/test_ast_helpers.cc",
"chars": 1464,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/test_ast_helpers.h",
"chars": 1044,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/test_ast_helpers_test.cc",
"chars": 1240,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_check_env.cc",
"chars": 4272,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_check_env.h",
"chars": 8154,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_checker_builder_impl.cc",
"chars": 17607,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_checker_builder_impl.h",
"chars": 5734,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_checker_builder_impl_test.cc",
"chars": 13790,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_checker_impl.cc",
"chars": 47852,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_checker_impl.h",
"chars": 2001,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_checker_impl_test.cc",
"chars": 103583,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_inference_context.cc",
"chars": 21974,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_inference_context.h",
"chars": 8784,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/internal/type_inference_context_test.cc",
"chars": 31349,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/optional.cc",
"chars": 9251,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/optional.h",
"chars": 1003,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/optional_test.cc",
"chars": 14020,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/standard_library.cc",
"chars": 40558,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/standard_library.h",
"chars": 960,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/standard_library_test.cc",
"chars": 20612,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_check_issue.cc",
"chars": 1886,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_check_issue.h",
"chars": 2262,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_check_issue_test.cc",
"chars": 1825,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_checker.cc",
"chars": 1275,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_checker.h",
"chars": 2378,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_checker_builder.h",
"chars": 6286,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_checker_builder_factory.cc",
"chars": 2133,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_checker_builder_factory.h",
"chars": 2326,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_checker_builder_factory_test.cc",
"chars": 32080,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_checker_subset_factory.cc",
"chars": 1977,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_checker_subset_factory.h",
"chars": 1711,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/type_checker_subset_factory_test.cc",
"chars": 3999,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/validation_result.cc",
"chars": 1028,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/validation_result.h",
"chars": 3800,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "checker/validation_result_test.cc",
"chars": 2814,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "cloudbuild.yaml",
"chars": 1346,
"preview": "steps:\n- name: 'gcr.io/cel-analysis/gcc9@sha256:4d5ff2e55224398807235a44b57e9c5793e922ac46e9ff428536bb8f8e5790ce'\n args"
},
{
"path": "codelab/BUILD",
"chars": 9239,
"preview": "# Copyright 2021 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "codelab/Dockerfile",
"chars": 651,
"preview": "ARG DEBIAN_IMAGE=\"marketplace.gcr.io/google/debian11:latest\"\nFROM ${DEBIAN_IMAGE}\n\nARG BAZELISK_RELEASE=\"https://github."
},
{
"path": "codelab/README.md",
"chars": 15118,
"preview": "# What is CEL?\nCommon Expression Language (CEL) is an expression language that’s fast, portable, and safe to execute in "
},
{
"path": "codelab/cel_compiler.h",
"chars": 1631,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/cel_compiler_test.cc",
"chars": 5331,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise1.cc",
"chars": 3138,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise1.h",
"chars": 1123,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise10.cc",
"chars": 4326,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise10.h",
"chars": 1455,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise10_test.cc",
"chars": 2514,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise1_test.cc",
"chars": 1331,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise2.cc",
"chars": 5616,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise2.h",
"chars": 1583,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise2_test.cc",
"chars": 3211,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise3_test.cc",
"chars": 5055,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise4.cc",
"chars": 4977,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise4.h",
"chars": 1248,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/exercise4_test.cc",
"chars": 2333,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/network_functions.cc",
"chars": 19309,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/network_functions.h",
"chars": 7083,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/network_functions_test.cc",
"chars": 12217,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/solutions/BUILD",
"chars": 5889,
"preview": "# Copyright 2021 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "codelab/solutions/exercise1.cc",
"chars": 4377,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/solutions/exercise10.cc",
"chars": 4805,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/solutions/exercise2.cc",
"chars": 5806,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/solutions/exercise3_test.cc",
"chars": 4292,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "codelab/solutions/exercise4.cc",
"chars": 6999,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/BUILD",
"chars": 31678,
"preview": "# Copyright 2021 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "common/allocator.h",
"chars": 21781,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/allocator_test.cc",
"chars": 7449,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/any.cc",
"chars": 1174,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/any.h",
"chars": 3014,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/any_test.cc",
"chars": 2538,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/arena.h",
"chars": 3755,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/arena_string.h",
"chars": 11490,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/arena_string_pool.h",
"chars": 2872,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/arena_string_pool_test.cc",
"chars": 2526,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/arena_string_test.cc",
"chars": 4670,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/arena_string_view.h",
"chars": 7582,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/arena_string_view_test.cc",
"chars": 4165,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/BUILD",
"chars": 4779,
"preview": "load(\"@rules_cc//cc:cc_library.bzl\", \"cc_library\")\nload(\"@rules_cc//cc:cc_test.bzl\", \"cc_test\")\n\n# Copyright 2025 Google"
},
{
"path": "common/ast/constant_proto.cc",
"chars": 4885,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/constant_proto.h",
"chars": 1402,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/expr_proto.cc",
"chars": 18691,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/expr_proto.h",
"chars": 1121,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/expr_proto_test.cc",
"chars": 8670,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/metadata.cc",
"chars": 7591,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/metadata.h",
"chars": 28128,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/metadata_test.cc",
"chars": 9823,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/navigable_ast_internal.h",
"chars": 10227,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/navigable_ast_internal_test.cc",
"chars": 3532,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/navigable_ast_kinds.cc",
"chars": 2367,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/navigable_ast_kinds.h",
"chars": 1966,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/source_info_proto.cc",
"chars": 3198,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast/source_info_proto.h",
"chars": 1199,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast.cc",
"chars": 2729,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast.h",
"chars": 6002,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_proto.cc",
"chars": 19100,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_proto.h",
"chars": 1881,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_proto_test.cc",
"chars": 30041,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_rewrite.cc",
"chars": 12199,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_rewrite.h",
"chars": 4717,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_rewrite_test.cc",
"chars": 20063,
"preview": "// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_test.cc",
"chars": 6476,
"preview": "// Copyright 2022 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_traverse.cc",
"chars": 11967,
"preview": "// Copyright 2018 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_traverse.h",
"chars": 3193,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_traverse_test.cc",
"chars": 15855,
"preview": "// Copyright 2018 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_visitor.h",
"chars": 4212,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/ast_visitor_base.h",
"chars": 3044,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/casting.h",
"chars": 2512,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/constant.cc",
"chars": 2947,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/constant.h",
"chars": 15066,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/constant_test.cc",
"chars": 10481,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/container.cc",
"chars": 4938,
"preview": "// Copyright 2026 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/container.h",
"chars": 4606,
"preview": "// Copyright 2026 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/container_test.cc",
"chars": 4916,
"preview": "// Copyright 2026 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/data.h",
"chars": 4134,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/data_test.cc",
"chars": 2047,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/decl.cc",
"chars": 6598,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/decl.h",
"chars": 12474,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/decl_proto.cc",
"chars": 3206,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/decl_proto.h",
"chars": 2009,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/decl_proto_test.cc",
"chars": 4920,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/decl_proto_v1alpha1.cc",
"chars": 2664,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/decl_proto_v1alpha1.h",
"chars": 2247,
"preview": "// Copyright 2025 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/decl_test.cc",
"chars": 10294,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/expr.cc",
"chars": 10946,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/expr.h",
"chars": 46218,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/expr_factory.h",
"chars": 13029,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/expr_test.cc",
"chars": 22463,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/function_descriptor.cc",
"chars": 2787,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/function_descriptor.h",
"chars": 4790,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/BUILD",
"chars": 5398,
"preview": "# Copyright 2023 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this f"
},
{
"path": "common/internal/byte_string.cc",
"chars": 33336,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/byte_string.h",
"chars": 21573,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/byte_string_test.cc",
"chars": 46798,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/casting.h",
"chars": 9794,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/metadata.h",
"chars": 1744,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/reference_count.cc",
"chars": 3799,
"preview": "// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/reference_count.h",
"chars": 14203,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/reference_count_test.cc",
"chars": 4806,
"preview": "// Copyright 2023 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/signature.cc",
"chars": 6505,
"preview": "// Copyright 2026 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
},
{
"path": "common/internal/signature.h",
"chars": 1973,
"preview": "// Copyright 2026 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
}
]
// ... and 915 more files (download for full content)
About this extraction
This page contains the full source code of the google/cel-cpp GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1115 files (8.7 MB), approximately 2.3M tokens, and a symbol index with 8962 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.