OSS export.

PiperOrigin-RevId: 453225470

Author: kyessenov

.bazelrc

@@ -1,4 +1,5 @@
 build --cxxopt=-std=c++17
+build --cxxopt=-fsized-deallocation
 
 # Enable matchers in googletest
 build --define absl=1

base/type.h

@@ -92,6 +92,14 @@ class Type : public base_internal::Resource {
 
   virtual std::string DebugString() const;
 
+  // Called by base_internal::TypeHandleBase.
+  // Note GCC does not consider a friend member as a member of a friend.
+  virtual bool Equals(const Type& other) const;
+
+  // Called by base_internal::TypeHandleBase.
+  // Note GCC does not consider a friend member as a member of a friend.
+  virtual void HashValue(absl::HashState state) const;
+
  private:
   friend class NullType;
   friend class ErrorType;
@@ -126,12 +134,6 @@ class Type : public base_internal::Resource {
 
   using base_internal::Resource::Ref;
   using base_internal::Resource::Unref;
-
-  // Called by base_internal::TypeHandleBase.
-  virtual bool Equals(const Type& other) const;
-
-  // Called by base_internal::TypeHandleBase.
-  virtual void HashValue(absl::HashState state) const;
 };
 
 class NullType final : public Type {
@@ -140,6 +142,9 @@ class NullType final : public Type {
 
   absl::string_view name() const override { return "null_type"; }
 
+  // Note GCC does not consider a friend member as a member of a friend.
+  ABSL_ATTRIBUTE_PURE_FUNCTION static const NullType& Get();
+
  private:
   friend class NullValue;
   friend class TypeFactory;
@@ -151,8 +156,6 @@ class NullType final : public Type {
   // Persistent.
   static bool Is(const Type& type) { return type.kind() == Kind::kNullType; }
 
-  ABSL_ATTRIBUTE_PURE_FUNCTION static const NullType& Get();
-
   NullType() = default;
 
   NullType(const NullType&) = delete;

base/value.cc

@@ -407,10 +407,6 @@ struct BytesValueDebugStringVisitor final {
   }
 
   std::string operator()(const absl::Cord& value) const {
-    absl::string_view flat;
-    if (value.GetFlat(&flat)) {
-      return internal::FormatBytesLiteral(flat);
-    }
     return internal::FormatBytesLiteral(static_cast<std::string>(value));
   }
 };
@@ -421,10 +417,6 @@ struct StringValueDebugStringVisitor final {
   }
 
   std::string operator()(const absl::Cord& value) const {
-    absl::string_view flat;
-    if (value.GetFlat(&flat)) {
-      return internal::FormatStringLiteral(flat);
-    }
     return internal::FormatStringLiteral(static_cast<std::string>(value));
   }
 };

base/value.h

@@ -84,6 +84,14 @@ class Value : public base_internal::Resource {
 
   virtual std::string DebugString() const = 0;
 
+  // Called by base_internal::ValueHandleBase.
+  // Note GCC does not consider a friend member as a member of a friend.
+  virtual bool Equals(const Value& other) const = 0;
+
+  // Called by base_internal::ValueHandleBase.
+  // Note GCC does not consider a friend member as a member of a friend.
+  virtual void HashValue(absl::HashState state) const = 0;
+
  private:
   friend class NullValue;
   friend class ErrorValue;
@@ -127,12 +135,6 @@ class Value : public base_internal::Resource {
 
   // Called by base_internal::ValueHandleBase for inlined values.
   virtual void MoveTo(Value& address);
-
-  // Called by base_internal::ValueHandleBase.
-  virtual bool Equals(const Value& other) const = 0;
-
-  // Called by base_internal::ValueHandleBase.
-  virtual void HashValue(absl::HashState state) const = 0;
 };
 
 class NullValue final : public Value, public base_internal::ResourceInlined {
@@ -145,6 +147,9 @@ class NullValue final : public Value, public base_internal::ResourceInlined {
 
   std::string DebugString() const override;
 
+  // Note GCC does not consider a friend member as a member of a friend.
+  ABSL_ATTRIBUTE_PURE_FUNCTION static const NullValue& Get();
+
  private:
   friend class ValueFactory;
   template <typename T>
@@ -157,8 +162,6 @@ class NullValue final : public Value, public base_internal::ResourceInlined {
   // Persistent.
   static bool Is(const Value& value) { return value.kind() == Kind::kNullType; }
 
-  ABSL_ATTRIBUTE_PURE_FUNCTION static const NullValue& Get();
-
   NullValue() = default;
   NullValue(const NullValue&) = default;
   NullValue(NullValue&&) = default;

bazel/BUILD

@@ -1 +1,9 @@
+load("@rules_java//java:defs.bzl", "java_binary")
+
 package(default_visibility = ["//visibility:public"])
+
+java_binary(
+    name = "antlr4_tool",
+    main_class = "org.antlr.v4.Tool",
+    runtime_deps = ["@antlr4_jar//jar"],
+)

bazel/antlr.bzl

@@ -16,25 +16,17 @@
 Generate C++ parser and lexer from a grammar file.
 """
 
-load("@rules_antlr//antlr:antlr4.bzl", "antlr")
-
-def antlr_cc_library(name, src, package = None, listener = False, visitor = True):
+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
-      listener: generate ANTLR listener (default: False)
-      visitor: generate ANTLR visitor (default: True)
     """
     generated = name + "_grammar"
-    antlr(
+    antlr_library(
         name = generated,
-        srcs = [src],
-        language = "Cpp",
-        listener = listener,
-        visitor = visitor,
+        src = src,
         package = package,
     )
     native.cc_library(
@@ -46,3 +38,65 @@ def antlr_cc_library(name, src, package = None, listener = False, visitor = True
         ],
         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(
+        arguments = [antlr_args],
+        inputs = [ctx.file.src],
+        outputs = [output],
+        executable = ctx.executable._tool,
+        progress_message = "Processing ANTLR grammar",
+    )
+
+    files = []
+    for suffix in suffixes:
+        header = ctx.actions.declare_file(basename + suffix + ".h")
+        source = ctx.actions.declare_file(basename + suffix + ".cpp")
+        generated = output.path + "/" + ctx.file.src.path[:-3] + suffix
+
+        ctx.actions.run_shell(
+            mnemonic = "CopyHeader" + suffix,
+            inputs = [output],
+            outputs = [header],
+            command = 'cp "{generated}" "{out}"'.format(generated = generated + ".h", out = header.path),
+        )
+        ctx.actions.run_shell(
+            mnemonic = "CopySource" + suffix,
+            inputs = [output],
+            outputs = [source],
+            command = '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 = "host",  # buildifier: disable=attr-cfg
+            default = Label("//bazel:antlr4_tool"),
+        ),
+    },
+)

bazel/deps.bzl

@@ -2,7 +2,7 @@
 Main dependencies of cel-cpp.
 """
 
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive", "http_jar")
 
 def base_deps():
     """Base evaluator and test dependencies."""
@@ -49,17 +49,17 @@ def base_deps():
         sha256 = RE2_SHA256,
     )
 
-    PROTOBUF_VERSION = "3.19.2"
-    PROTOBUF_SHA = "4dd35e788944b7686aac898f77df4e9a54da0ca694b8801bd6b2a9ffc1b3085e"
+    PROTOBUF_VERSION = "3.21.1"
+    PROTOBUF_SHA = "a295dd3b9551d3e2749a9969583dea110c6cdcc39d02088f7c7bb1100077e081"
     http_archive(
         name = "com_google_protobuf",
         sha256 = PROTOBUF_SHA,
         strip_prefix = "protobuf-" + PROTOBUF_VERSION,
         urls = ["https://github.com/protocolbuffers/protobuf/archive/v" + PROTOBUF_VERSION + ".tar.gz"],
     )
 
-    GOOGLEAPIS_GIT_SHA = "77066268d1fd5d72278afc2aef1ebc1d2112cca6"  # Oct 01, 2021
-    GOOGLEAPIS_SHA = "dca75efd11a6295618dba919ad52fe551ba8bb85778d331a38c2bca282234296"
+    GOOGLEAPIS_GIT_SHA = "f19049fdd8dfc8b6eba387f4ef6d1d8b4d0103e7"  # May 31, 2022
+    GOOGLEAPIS_SHA = "cbda1073fe2eb3b7a5a41fd940a592cfe1861895580c13bf25066896f9e9bede"
     http_archive(
         name = "com_google_googleapis",
         sha256 = GOOGLEAPIS_SHA,
@@ -69,15 +69,10 @@ def base_deps():
 
 def parser_deps():
     """ANTLR dependency for the parser."""
-    http_archive(
-        name = "rules_antlr",
-        sha256 = "26e6a83c665cf6c1093b628b3a749071322f0f70305d12ede30909695ed85591",
-        strip_prefix = "rules_antlr-0.5.0",
-        urls = ["https://github.com/marcohu/rules_antlr/archive/0.5.0.tar.gz"],
-    )
 
-    ANTLR4_RUNTIME_GIT_SHA = "70b2edcf98eb612a92d3dbaedb2ce0b69533b0cb"  # Dec 7, 2021
-    ANTLR4_RUNTIME_SHA = "fae73909f95e1320701e29ac03bab9233293fb5b90d3ce857279f1b46b614c83"
+    # Apr 15, 2022
+    ANTLR4_VERSION = "4.10.1"
+
     http_archive(
         name = "antlr4_runtimes",
         build_file_content = """
@@ -89,9 +84,14 @@ cc_library(
     includes = ["runtime/Cpp/runtime/src"],
 )
   """,
-        sha256 = ANTLR4_RUNTIME_SHA,
-        strip_prefix = "antlr4-" + ANTLR4_RUNTIME_GIT_SHA,
-        urls = ["https://github.com/antlr/antlr4/archive/" + ANTLR4_RUNTIME_GIT_SHA + ".tar.gz"],
+        sha256 = "a320568b738e42735946bebc5d9d333170e14a251c5734e8b852ad1502efa8a2",
+        strip_prefix = "antlr4-" + ANTLR4_VERSION,
+        urls = ["https://github.com/antlr/antlr4/archive/v" + ANTLR4_VERSION + ".tar.gz"],
+    )
+    http_jar(
+        name = "antlr4_jar",
+        urls = ["https://www.antlr.org/download/antlr-" + ANTLR4_VERSION + "-complete.jar"],
+        sha256 = "41949d41f20d31d5b8277187735dd755108df52b38db6c865108d3382040f918",
     )
 
 def flatbuffers_deps():
@@ -124,10 +124,10 @@ def cel_spec_deps():
         ],
     )
 
-    CEL_SPEC_GIT_SHA = "c9ae91b24fdaf869d7c59a9f64863249a6a2905e"  # 9/22/2021
+    CEL_SPEC_GIT_SHA = "6040c0a6df9601751e628405706bac18948b8eb3"  # 3/31/2022
     http_archive(
         name = "com_google_cel_spec",
-        sha256 = "a911c4a5c5cea1c29dc57463cfea5614025654e6bb67a6aeebc57af3d132c8e4",
+        sha256 = "6b4ca28de8d8a3038a96c393774c2ab65abd6a57cb50295dddea406b2eeafc9e",
         strip_prefix = "cel-spec-" + CEL_SPEC_GIT_SHA,
         urls = ["https://github.com/google/cel-spec/archive/" + CEL_SPEC_GIT_SHA + ".zip"],
     )

bazel/deps_extra.bzl

@@ -4,7 +4,6 @@ Transitive dependencies.
 
 load("@com_google_protobuf//:protobuf_deps.bzl", "protobuf_deps")
 load("@com_google_googleapis//:repository_rules.bzl", "switched_rules_by_language")
-load("@rules_antlr//antlr:repositories.bzl", "rules_antlr_dependencies")
 load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_dependencies")
 load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies", "go_repository")
 
@@ -50,5 +49,4 @@ def cel_cpp_deps_extra():
         cc = True,
         go = True,  # cel-spec requirement
     )
-    rules_antlr_dependencies("4.8")
     cel_spec_deps_extra()

eval/compiler/flat_expr_builder_test.cc

@@ -63,6 +63,10 @@ namespace google::api::expr::runtime {
 
 namespace {
 
+using ::google::api::expr::v1alpha1::CheckedExpr;
+using ::google::api::expr::v1alpha1::Expr;
+using ::google::api::expr::v1alpha1::ParsedExpr;
+using ::google::api::expr::v1alpha1::SourceInfo;
 using testing::Eq;
 using testing::HasSubstr;
 using cel::internal::StatusIs;
@@ -75,7 +79,7 @@ template <class MessageClass>
 absl::Status ReadBinaryProtoFromDisk(absl::string_view file_name,
                                      MessageClass& message) {
   std::ifstream file;
-  file.open(file_name, std::fstream::in);
+  file.open(std::string(file_name), std::fstream::in);
   if (!file.is_open()) {
     return absl::NotFoundError(absl::StrFormat("Failed to open file '%s': %s",
                                                file_name, strerror(errno)));
@@ -1890,9 +1894,8 @@ TEST(FlatExprBuilderTest, CustomDescriptorPoolForSelect) {
 
 std::pair<google::protobuf::Message*, const google::protobuf::Reflection*> CreateTestMessage(
     const google::protobuf::DescriptorPool& descriptor_pool,
-    google::protobuf::MessageFactory& message_factory, absl::string_view message_type) {
-  const google::protobuf::Descriptor* desc =
-      descriptor_pool.FindMessageTypeByName(message_type);
+    google::protobuf::MessageFactory& message_factory, absl::string_view name) {
+  const google::protobuf::Descriptor* desc = descriptor_pool.FindMessageTypeByName(name.data());
   const google::protobuf::Message* message_prototype = message_factory.GetPrototype(desc);
   google::protobuf::Message* message = message_prototype->New();
   const google::protobuf::Reflection* refl = message->GetReflection();

eval/compiler/qualified_reference_resolver.cc

@@ -28,6 +28,7 @@ namespace {
 using ::google::api::expr::v1alpha1::Constant;
 using ::google::api::expr::v1alpha1::Expr;
 using ::google::api::expr::v1alpha1::Reference;
+using ::google::api::expr::v1alpha1::SourceInfo;
 
 // Determines if function is implemented with custom evaluation step instead of
 // registered.