Fixes for bazel msvc build.

- update antlr patch to strip version file (may shadow std <version>)
- address misc unsupported features for msvc
- add basic msvc bazel config to bazelrc

PiperOrigin-RevId: 850497501

Author: jnthntatum

.bazelrc

@@ -1,9 +1,20 @@
-build --cxxopt=-std=c++17 --host_cxxopt=-std=c++17
-build --cxxopt=-fsized-deallocation
+common --enable_platform_specific_config
+
 build --enable_bzlmod
-build --copt=-Wno-deprecated-declarations
 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
+
 test --test_output=errors
 
 # Enable matchers in googletest

.gitignore

@@ -8,3 +8,4 @@ bazel-cel-cpp
 clang.bazelrc
 user.bazelrc
 local_tsan.bazelrc
+MODULE.bazel.lock

bazel/antlr.patch

@@ -22,4 +22,9 @@
          "@com_google_absl//absl/container:flat_hash_set",
          "@com_google_absl//absl/synchronization",
      ],
- )
+ )
+
+--- VERSION
++++ /dev/null
+@@ -1,1 +1,0 @@
+-4.13.2

common/BUILD

@@ -846,6 +846,7 @@ cc_test(
         "arena_string_test.cc",
         "arena_string_view_test.cc",
     ],
+    tags = ["no_test_msvc"],
     deps = [
         ":arena_string",
         "//internal:testing",
@@ -875,6 +876,7 @@ cc_library(
 cc_test(
     name = "arena_string_pool_test",
     srcs = ["arena_string_pool_test.cc"],
+    tags = ["no_test_msvc"],
     deps = [
         ":arena_string_pool",
         "//internal:testing",

common/value.cc

@@ -1123,37 +1123,34 @@ absl::StatusOr<RepeatedFieldAccessor> RepeatedFieldAccessorFor(
 
 namespace {
 
-// WellKnownTypesValueVisitor is the base visitor for `well_known_types::Value`
-// which handles the primitive values which require no special handling based on
-// allocators.
-struct WellKnownTypesValueVisitor {
-  Value operator()(std::nullptr_t) const { return NullValue(); }
+// Overloads for `well_known_types::Value` which handles the primitive values
+// which require no special handling based on allocators.
+Value VistWellKnownTypeValue(std::nullptr_t) { return NullValue(); }
 
-  Value operator()(bool value) const { return BoolValue(value); }
+Value VistWellKnownTypeValue(bool value) { return BoolValue(value); }
 
-  Value operator()(int32_t value) const { return IntValue(value); }
+Value VistWellKnownTypeValue(int32_t value) { return IntValue(value); }
 
-  Value operator()(int64_t value) const { return IntValue(value); }
+Value VistWellKnownTypeValue(int64_t value) { return IntValue(value); }
 
-  Value operator()(uint32_t value) const { return UintValue(value); }
+Value VistWellKnownTypeValue(uint32_t value) { return UintValue(value); }
 
-  Value operator()(uint64_t value) const { return UintValue(value); }
+Value VistWellKnownTypeValue(uint64_t value) { return UintValue(value); }
 
-  Value operator()(float value) const { return DoubleValue(value); }
+Value VistWellKnownTypeValue(float value) { return DoubleValue(value); }
 
-  Value operator()(double value) const { return DoubleValue(value); }
+Value VistWellKnownTypeValue(double value) { return DoubleValue(value); }
 
-  Value operator()(absl::Duration value) const { return DurationValue(value); }
+Value VistWellKnownTypeValue(absl::Duration value) {
+  return DurationValue(value);
+}
 
-  Value operator()(absl::Time value) const { return TimestampValue(value); }
-};
+Value VistWellKnownTypeValue(absl::Time value) { return TimestampValue(value); }
 
-struct OwningWellKnownTypesValueVisitor : public WellKnownTypesValueVisitor {
+struct OwningWellKnownTypesValueVisitor {
   google::protobuf::Arena* absl_nullable arena;
   std::string* absl_nonnull scratch;
 
-  using WellKnownTypesValueVisitor::operator();
-
   Value operator()(well_known_types::BytesValue&& value) const {
     return absl::visit(absl::Overload(
                            [&](absl::string_view string) -> BytesValue {
@@ -1242,15 +1239,18 @@ struct OwningWellKnownTypesValueVisitor : public WellKnownTypesValueVisitor {
     }
     return ParsedMessageValue(value.release(), arena);
   }
+
+  template <typename T>
+  Value operator()(T t) const {
+    return VistWellKnownTypeValue(t);
+  }
 };
 
-struct BorrowingWellKnownTypesValueVisitor : public WellKnownTypesValueVisitor {
+struct BorrowingWellKnownTypesValueVisitor {
   const google::protobuf::Message* absl_nonnull message;
   google::protobuf::Arena* absl_nonnull arena;
   std::string* absl_nonnull scratch;
 
-  using WellKnownTypesValueVisitor::operator();
-
   Value operator()(well_known_types::BytesValue&& value) const {
     return absl::visit(
         absl::Overload(
@@ -1332,6 +1332,11 @@ struct BorrowingWellKnownTypesValueVisitor : public WellKnownTypesValueVisitor {
     }
     return ParsedMessageValue(value.release(), arena);
   }
+
+  template <typename T>
+  Value operator()(T t) const {
+    return VistWellKnownTypeValue(t);
+  }
 };
 
 }  // namespace
@@ -1354,13 +1359,13 @@ Value Value::FromMessage(
     return ErrorValue(std::move(status_or_adapted).status());
   }
   return absl::visit(
-      absl::Overload(
-          OwningWellKnownTypesValueVisitor{.arena = arena, .scratch = &scratch},
-          [&](absl::monostate) -> Value {
-            auto* cloned = message.New(arena);
-            cloned->CopyFrom(message);
-            return ParsedMessageValue(cloned, arena);
-          }),
+      absl::Overload(OwningWellKnownTypesValueVisitor{
+                         /* .arena = */ arena, /* .scratch = */ &scratch},
+                     [&](absl::monostate) -> Value {
+                       auto* cloned = message.New(arena);
+                       cloned->CopyFrom(message);
+                       return ParsedMessageValue(cloned, arena);
+                     }),
       std::move(status_or_adapted).value());
 }
 
@@ -1382,13 +1387,13 @@ Value Value::FromMessage(
     return ErrorValue(std::move(status_or_adapted).status());
   }
   return absl::visit(
-      absl::Overload(
-          OwningWellKnownTypesValueVisitor{.arena = arena, .scratch = &scratch},
-          [&](absl::monostate) -> Value {
-            auto* cloned = message.New(arena);
-            cloned->GetReflection()->Swap(cloned, &message);
-            return ParsedMessageValue(cloned, arena);
-          }),
+      absl::Overload(OwningWellKnownTypesValueVisitor{
+                         /* .arena = */ arena, /* .scratch = */ &scratch},
+                     [&](absl::monostate) -> Value {
+                       auto* cloned = message.New(arena);
+                       cloned->GetReflection()->Swap(cloned, &message);
+                       return ParsedMessageValue(cloned, arena);
+                     }),
       std::move(status_or_adapted).value());
 }
 
@@ -1412,17 +1417,17 @@ Value Value::WrapMessage(
     return ErrorValue(std::move(adapted_value).status());
   }
   return absl::visit(
-      absl::Overload(
-          BorrowingWellKnownTypesValueVisitor{
-              .message = message, .arena = arena, .scratch = &scratch},
-          [&](absl::monostate) -> Value {
-            if (message->GetArena() != arena) {
-              auto* cloned = message->New(arena);
-              cloned->CopyFrom(*message);
-              return ParsedMessageValue(cloned, arena);
-            }
-            return ParsedMessageValue(message, arena);
-          }),
+      absl::Overload(BorrowingWellKnownTypesValueVisitor{
+                         /* .message = */ message, /* .arena = */ arena,
+                         /* .scratch = */ &scratch},
+                     [&](absl::monostate) -> Value {
+                       if (message->GetArena() != arena) {
+                         auto* cloned = message->New(arena);
+                         cloned->CopyFrom(*message);
+                         return ParsedMessageValue(cloned, arena);
+                       }
+                       return ParsedMessageValue(message, arena);
+                     }),
       std::move(adapted_value).value());
 }
 
@@ -1446,15 +1451,15 @@ Value Value::WrapMessageUnsafe(
     return ErrorValue(std::move(adapted_value).status());
   }
   return absl::visit(
-      absl::Overload(
-          BorrowingWellKnownTypesValueVisitor{
-              .message = message, .arena = arena, .scratch = &scratch},
-          [&](absl::monostate) -> Value {
-            if (message->GetArena() != arena) {
-              return UnsafeParsedMessageValue(message);
-            }
-            return ParsedMessageValue(message, arena);
-          }),
+      absl::Overload(BorrowingWellKnownTypesValueVisitor{
+                         /* .message = */ message, /* .arena = */ arena,
+                         /* .scratch = */ &scratch},
+                     [&](absl::monostate) -> Value {
+                       if (message->GetArena() != arena) {
+                         return UnsafeParsedMessageValue(message);
+                       }
+                       return ParsedMessageValue(message, arena);
+                     }),
       std::move(adapted_value).value());
 }
 

common/values/error_value.h

@@ -132,7 +132,9 @@ class ABSL_ATTRIBUTE_TRIVIAL_ABI ErrorValue final
 
   ErrorValue(google::protobuf::Arena* absl_nonnull arena,
              const absl::Status* absl_nonnull status)
-      : arena_(arena), status_{.ptr = status} {}
+      : arena_(arena) {
+    status_.ptr = status;
+  }
 
   void CopyConstruct(const ErrorValue& other) {
     arena_ = other.arena_;

internal/BUILD

@@ -35,6 +35,7 @@ cc_library(
 cc_test(
     name = "align_test",
     srcs = ["align_test.cc"],
+    tags = ["no_test_msvc"],
     deps = [
         ":align",
         ":testing",
@@ -783,6 +784,7 @@ cc_library(
 cc_test(
     name = "message_equality_test",
     srcs = ["message_equality_test.cc"],
+    tags = ["no_test_msvc"],
     deps = [
         ":message_equality",
         ":message_type_name",

internal/json.cc

@@ -864,7 +864,7 @@ class MessageToJsonState {
       case FieldDescriptor::TYPE_GROUP:
         ABSL_FALLTHROUGH_INTENDED;
       case FieldDescriptor::TYPE_MESSAGE:
-        return ToJson(reflection->GetMessage(message, field), result);
+        return ToJson((reflection->GetMessage)(message, field), result);
       case FieldDescriptor::TYPE_BYTES:
         BytesValueToJson(
             well_known_types::GetBytesField(message, field, scratch_), result);

parser/BUILD

@@ -30,6 +30,9 @@ cc_library(
     copts = [
         "-fexceptions",
     ],
+    defines = [
+        "ANTLR4CPP_STATIC",
+    ],
     deps = [
         ":macro",
         ":macro_expr_factory",

parser/parser_test.cc

@@ -1485,7 +1485,7 @@ TEST_P(ExpressionTest, Parse) {
   macros.push_back(cel::OptFlatMapMacro());
   auto result = EnrichedParse(test_info.I, macros, "<input>", options);
   if (test_info.E.empty()) {
-    EXPECT_THAT(result, IsOk());
+    ASSERT_THAT(result, IsOk());
   } else {
     EXPECT_THAT(result, Not(IsOk()));
     EXPECT_EQ(test_info.E, result.status().message());