Check-in bootstrapped Java features for Bazel and CMake PiperOrigin-RevId: 573014410
diff --git a/cmake/install.cmake b/cmake/install.cmake index c52f692..998c2e3 100644 --- a/cmake/install.cmake +++ b/cmake/install.cmake
@@ -68,10 +68,18 @@ ${cpp_features_proto_proto_srcs} ${descriptor_proto_proto_srcs} ${plugin_proto_proto_srcs} + ${java_features_proto_proto_srcs} ) foreach(_header ${protobuf_HEADERS}) - string(REPLACE "${protobuf_SOURCE_DIR}/src" "" _header ${_header}) - get_filename_component(_extract_from "${protobuf_SOURCE_DIR}/src/${_header}" ABSOLUTE) + string(FIND ${_header} "${protobuf_SOURCE_DIR}/src" _find_src) + string(FIND ${_header} "${protobuf_SOURCE_DIR}" _find_nosrc) + if (_find_src GREATER -1) + set(_from_dir "${protobuf_SOURCE_DIR}/src") + elseif (_find_nosrc GREATER -1) + set(_from_dir "${protobuf_SOURCE_DIR}") + endif() + string(REPLACE "${_from_dir}" "" _header ${_header}) + get_filename_component(_extract_from "${_from_dir}/${_header}" ABSOLUTE) get_filename_component(_extract_name ${_header} NAME) get_filename_component(_extract_to "${CMAKE_INSTALL_INCLUDEDIR}/${_header}" DIRECTORY) install(FILES "${_extract_from}"
diff --git a/cmake/tests.cmake b/cmake/tests.cmake index 1f21ed0..6b7707b 100644 --- a/cmake/tests.cmake +++ b/cmake/tests.cmake
@@ -204,7 +204,8 @@ set(_exclude_hdrs "${protobuf_SOURCE_DIR}/src/google/protobuf/cpp_features.pb.h" "${protobuf_SOURCE_DIR}/src/google/protobuf/descriptor.pb.h" - "${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/plugin.pb.h") + "${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/plugin.pb.h" + "${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/java_features.pb.h") # Exclude test library headers. list(APPEND _exclude_hdrs ${test_util_hdrs} ${lite_test_util_hdrs} ${common_test_hdrs}
diff --git a/java/core/BUILD.bazel b/java/core/BUILD.bazel index 8f2bfe3..70fe8fa 100644 --- a/java/core/BUILD.bazel +++ b/java/core/BUILD.bazel
@@ -163,6 +163,13 @@ srcs = LITE_SRCS, ) +proto_library( + name = "java_features_proto", + srcs = ["src/main/java/com/google/protobuf/java_features.proto"], + visibility = ["//pkg:__pkg__"], + deps = ["//:descriptor_proto"], +) + internal_gen_well_known_protos_java( name = "gen_well_known_protos_java", deps = [
diff --git a/pkg/BUILD.bazel b/pkg/BUILD.bazel index 1d24e44..340fbaf 100644 --- a/pkg/BUILD.bazel +++ b/pkg/BUILD.bazel
@@ -113,6 +113,8 @@ "//src/google/protobuf:cpp_features_proto": "cpp_features_proto", "//src/google/protobuf:descriptor_proto": "descriptor_proto", "//src/google/protobuf/compiler:plugin_proto": "plugin_proto", + "//java/core:java_features_proto": "java_features_proto,src/google/protobuf/compiler/java/", + # Test libraries: ":common_test": "common_test", ":lite_test_util": "lite_test_util",
diff --git a/pkg/build_systems.bzl b/pkg/build_systems.bzl index 7de918f..fb234fc 100644 --- a/pkg/build_systems.bzl +++ b/pkg/build_systems.bzl
@@ -1,5 +1,6 @@ -# Starlark utilities for working with other build systems +"""Starlark utilities for working with other build systems.""" +load("@bazel_skylib//lib:paths.bzl", "paths") load("@rules_pkg//:providers.bzl", "PackageFilegroupInfo", "PackageFilesInfo") load(":cc_dist_library.bzl", "CcFileList") @@ -129,7 +130,10 @@ out = ctx.outputs.out fragments = [] - for srcrule, libname in ctx.attr.src_libs.items(): + for srcrule, value in ctx.attr.src_libs.items(): + split_value = value.split(",") + libname = split_value[0] + gencode_dir = split_value[1] if len(split_value) == 2 else "" if CcFileList in srcrule: cc_file_list = srcrule[CcFileList] @@ -170,13 +174,13 @@ srcrule.label, libname + "_srcs", ctx.attr.source_prefix, - proto_file_list.srcs, + [gencode_dir + paths.basename(s) if gencode_dir else s for s in proto_file_list.srcs], ), fragment_generator( srcrule.label, libname + "_hdrs", ctx.attr.source_prefix, - proto_file_list.hdrs, + [gencode_dir + paths.basename(s) if gencode_dir else s for s in proto_file_list.hdrs], ), ]) @@ -232,14 +236,14 @@ ), "src_libs": attr.label_keyed_string_dict( doc = ( - "A dict, {target: libname} of libraries to include. " + + "A dict, {target: libname[,gencode_dir]} of libraries to include. " + "Targets can be C++ rules (like `cc_library` or `cc_test`), " + "`proto_library` rules, files, `filegroup` rules, `pkg_files` " + "rules, or `pkg_filegroup` rules. " + "The libname is a string, and used to construct the variable " + "name in the `out` file holding the target's sources. " + "For generated files, the output root (like `bazel-bin/`) is not " + - "included. " + + "included. gencode_dir is used instead of target's location if provided." + "For `pkg_files` and `pkg_filegroup` rules, the destination path " + "is used." ),
diff --git a/src/google/protobuf/compiler/java/BUILD.bazel b/src/google/protobuf/compiler/java/BUILD.bazel index 33c9e8d..a6e78f0 100644 --- a/src/google/protobuf/compiler/java/BUILD.bazel +++ b/src/google/protobuf/compiler/java/BUILD.bazel
@@ -57,6 +57,7 @@ "file.cc", "generator.cc", "generator_factory.cc", + "java_features.pb.cc", "kotlin_generator.cc", "map_field.cc", "map_field_lite.cc", @@ -87,6 +88,7 @@ "file.h", "generator.h", "generator_factory.h", + "java_features.pb.h", "kotlin_generator.h", "map_field.h", "map_field_lite.h", @@ -113,6 +115,7 @@ deps = [ ":names", ":names_internal", + "//src/google/protobuf:arena", "//src/google/protobuf:descriptor_legacy", "//src/google/protobuf:protobuf_nowkt", "//src/google/protobuf/compiler:code_generator",
diff --git a/src/google/protobuf/compiler/java/java_features.pb.cc b/src/google/protobuf/compiler/java/java_features.pb.cc new file mode 100644 index 0000000..99ab9eb --- /dev/null +++ b/src/google/protobuf/compiler/java/java_features.pb.cc
@@ -0,0 +1,383 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: google/protobuf/compiler/java/java_features.proto + +#include "google/protobuf/compiler/java/java_features.pb.h" + +#include <algorithm> +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +#include "google/protobuf/generated_message_tctable_impl.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace pb { + +inline constexpr JavaFeatures::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + legacy_closed_enum_{false}, + utf8_validation_{static_cast< ::pb::JavaFeatures_Utf8Validation >(0)} {} + +template <typename> +PROTOBUF_CONSTEXPR JavaFeatures::JavaFeatures(::_pbi::ConstantInitialized) + : _impl_(::_pbi::ConstantInitialized()) {} +struct JavaFeaturesDefaultTypeInternal { + PROTOBUF_CONSTEXPR JavaFeaturesDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~JavaFeaturesDefaultTypeInternal() {} + union { + JavaFeatures _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOC_EXPORT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 JavaFeaturesDefaultTypeInternal _JavaFeatures_default_instance_; +} // namespace pb +static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto[1]; +static const ::_pb::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto[1]; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto = nullptr; +const ::uint32_t TableStruct_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( + protodesc_cold) = { + PROTOBUF_FIELD_OFFSET(::pb::JavaFeatures, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::JavaFeatures, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::pb::JavaFeatures, _impl_.legacy_closed_enum_), + PROTOBUF_FIELD_OFFSET(::pb::JavaFeatures, _impl_.utf8_validation_), + 0, + 1, +}; + +static const ::_pbi::MigrationSchema + schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + {0, 10, -1, sizeof(::pb::JavaFeatures)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::pb::_JavaFeatures_default_instance_._instance, +}; +const char descriptor_table_protodef_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + "\n1google/protobuf/compiler/java/java_fea" + "tures.proto\022\002pb\032 google/protobuf/descrip" + "tor.proto\"\352\001\n\014JavaFeatures\022>\n\022legacy_clo" + "sed_enum\030\001 \001(\010B\"\210\001\001\230\001\004\230\001\001\242\001\t\022\004true\030\346\007\242\001\n" + "\022\005false\030\347\007\022R\n\017utf8_validation\030\002 \001(\0162\037.pb" + ".JavaFeatures.Utf8ValidationB\030\210\001\001\230\001\004\230\001\001\242" + "\001\014\022\007DEFAULT\030\346\007\"F\n\016Utf8Validation\022\033\n\027UTF8" + "_VALIDATION_UNKNOWN\020\000\022\013\n\007DEFAULT\020\001\022\n\n\006VE" + "RIFY\020\002:<\n\004java\022\033.google.protobuf.Feature" + "Set\030\351\007 \001(\0132\020.pb.JavaFeaturesB(\n\023com.goog" + "le.protobufB\021JavaFeaturesProto" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_deps[1] = + { + &::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto, +}; +static ::absl::once_flag descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto = { + false, + false, + 430, + descriptor_table_protodef_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto, + "google/protobuf/compiler/java/java_features.proto", + &descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_once, + descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_deps, + 1, + 1, + schemas, + file_default_instances, + TableStruct_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto::offsets, + file_level_metadata_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto, + file_level_enum_descriptors_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto, + file_level_service_descriptors_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto, +}; + +// This function exists to be marked as weak. +// It can significantly speed up compilation by breaking up LLVM's SCC +// in the .pb.cc translation units. Large translation units see a +// reduction of more than 35% of walltime for optimized builds. Without +// the weak attribute all the messages in the file, including all the +// vtables and everything they use become part of the same SCC through +// a cycle like: +// GetMetadata -> descriptor table -> default instances -> +// vtables -> GetMetadata +// By adding a weak function here we break the connection from the +// individual vtables back into the descriptor table. +PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_getter() { + return &descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto(&descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto); +namespace pb { +const ::google::protobuf::EnumDescriptor* JavaFeatures_Utf8Validation_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto); + return file_level_enum_descriptors_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto[0]; +} +PROTOBUF_CONSTINIT const uint32_t JavaFeatures_Utf8Validation_internal_data_[] = { + 196608u, 0u, }; +bool JavaFeatures_Utf8Validation_IsValid(int value) { + return 0 <= value && value <= 2; +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr JavaFeatures_Utf8Validation JavaFeatures::UTF8_VALIDATION_UNKNOWN; +constexpr JavaFeatures_Utf8Validation JavaFeatures::DEFAULT; +constexpr JavaFeatures_Utf8Validation JavaFeatures::VERIFY; +constexpr JavaFeatures_Utf8Validation JavaFeatures::Utf8Validation_MIN; +constexpr JavaFeatures_Utf8Validation JavaFeatures::Utf8Validation_MAX; +constexpr int JavaFeatures::Utf8Validation_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +// =================================================================== + +class JavaFeatures::_Internal { + public: + using HasBits = decltype(std::declval<JavaFeatures>()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(JavaFeatures, _impl_._has_bits_); + static void set_has_legacy_closed_enum(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_utf8_validation(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +JavaFeatures::JavaFeatures(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.JavaFeatures) +} +JavaFeatures::JavaFeatures( + ::google::protobuf::Arena* arena, const JavaFeatures& from) + : JavaFeatures(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE JavaFeatures::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void JavaFeatures::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast<char *>(&_impl_) + + offsetof(Impl_, legacy_closed_enum_), + 0, + offsetof(Impl_, utf8_validation_) - + offsetof(Impl_, legacy_closed_enum_) + + sizeof(Impl_::utf8_validation_)); +} +JavaFeatures::~JavaFeatures() { + // @@protoc_insertion_point(destructor:pb.JavaFeatures) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void JavaFeatures::SharedDtor() { + ABSL_DCHECK(GetArena() == nullptr); + _impl_.~Impl_(); +} + +PROTOBUF_NOINLINE void JavaFeatures::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.JavaFeatures) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.legacy_closed_enum_, 0, static_cast<::size_t>( + reinterpret_cast<char*>(&_impl_.utf8_validation_) - + reinterpret_cast<char*>(&_impl_.legacy_closed_enum_)) + sizeof(_impl_.utf8_validation_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* JavaFeatures::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> JavaFeatures::_table_ = { + { + PROTOBUF_FIELD_OFFSET(JavaFeatures, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_JavaFeatures_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // optional .pb.JavaFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + {::_pbi::TcParser::FastEr0S1, + {16, 1, 2, PROTOBUF_FIELD_OFFSET(JavaFeatures, _impl_.utf8_validation_)}}, + // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(JavaFeatures, _impl_.legacy_closed_enum_), 0>(), + {8, 0, 0, PROTOBUF_FIELD_OFFSET(JavaFeatures, _impl_.legacy_closed_enum_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + {PROTOBUF_FIELD_OFFSET(JavaFeatures, _impl_.legacy_closed_enum_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // optional .pb.JavaFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + {PROTOBUF_FIELD_OFFSET(JavaFeatures, _impl_.utf8_validation_), _Internal::kHasBitsOffset + 1, 0, + (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)}, + }}, {{ + {0, 3}, + }}, {{ + }}, +}; + +::uint8_t* JavaFeatures::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.JavaFeatures) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 1, this->_internal_legacy_closed_enum(), target); + } + + // optional .pb.JavaFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_utf8_validation(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.JavaFeatures) + return target; +} + +::size_t JavaFeatures::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.JavaFeatures) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + if (cached_has_bits & 0x00000001u) { + total_size += 2; + } + + // optional .pb.JavaFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_utf8_validation()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::google::protobuf::Message::ClassData JavaFeatures::_class_data_ = { + JavaFeatures::MergeImpl, + nullptr, // OnDemandRegisterArenaDtor +}; +const ::google::protobuf::Message::ClassData* JavaFeatures::GetClassData() const { + return &_class_data_; +} + +void JavaFeatures::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast<JavaFeatures*>(&to_msg); + auto& from = static_cast<const JavaFeatures&>(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:pb.JavaFeatures) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.legacy_closed_enum_ = from._impl_.legacy_closed_enum_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.utf8_validation_ = from._impl_.utf8_validation_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void JavaFeatures::CopyFrom(const JavaFeatures& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.JavaFeatures) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool JavaFeatures::IsInitialized() const { + return true; +} + +::_pbi::CachedSize* JavaFeatures::AccessCachedSize() const { + return &_impl_._cached_size_; +} +void JavaFeatures::InternalSwap(JavaFeatures* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(JavaFeatures, _impl_.utf8_validation_) + + sizeof(JavaFeatures::_impl_.utf8_validation_) + - PROTOBUF_FIELD_OFFSET(JavaFeatures, _impl_.legacy_closed_enum_)>( + reinterpret_cast<char*>(&_impl_.legacy_closed_enum_), + reinterpret_cast<char*>(&other->_impl_.legacy_closed_enum_)); +} + +::google::protobuf::Metadata JavaFeatures::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_getter, &descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_once, + file_level_metadata_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto[0]); +} +PROTOC_EXPORT PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FeatureSet, + ::google::protobuf::internal::MessageTypeTraits< ::pb::JavaFeatures >, 11, false> + java(kJavaFieldNumber, ::pb::JavaFeatures::default_instance(), nullptr); +// @@protoc_insertion_point(namespace_scope) +} // namespace pb +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc"
diff --git a/src/google/protobuf/compiler/java/java_features.pb.h b/src/google/protobuf/compiler/java/java_features.pb.h new file mode 100644 index 0000000..a3e62b9 --- /dev/null +++ b/src/google/protobuf/compiler/java/java_features.pb.h
@@ -0,0 +1,420 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: google/protobuf/compiler/java/java_features.proto +// Protobuf C++ Version: 4.24.0-main + +#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_2epb_2eh + +#include <limits> +#include <string> +#include <type_traits> +#include <utility> + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4024000 +#error "This file was generated by a newer version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please update" +#error "your headers." +#endif // PROTOBUF_VERSION + +#if 4024000 < PROTOBUF_MIN_PROTOC_VERSION +#error "This file was generated by an older version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please" +#error "regenerate this file with a newer version of protoc." +#endif // PROTOBUF_MIN_PROTOC_VERSION +#include "google/protobuf/port_undef.inc" +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/generated_enum_reflection.h" +#include "google/protobuf/unknown_field_set.h" +#include "google/protobuf/descriptor.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto PROTOC_EXPORT + +namespace google { +namespace protobuf { +namespace internal { +class AnyMetadata; +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct PROTOC_EXPORT TableStruct_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto { + static const ::uint32_t offsets[]; +}; +PROTOC_EXPORT extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto; +namespace pb { +class JavaFeatures; +struct JavaFeaturesDefaultTypeInternal; +PROTOC_EXPORT extern JavaFeaturesDefaultTypeInternal _JavaFeatures_default_instance_; +} // namespace pb +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace pb { +enum JavaFeatures_Utf8Validation : int { + JavaFeatures_Utf8Validation_UTF8_VALIDATION_UNKNOWN = 0, + JavaFeatures_Utf8Validation_DEFAULT = 1, + JavaFeatures_Utf8Validation_VERIFY = 2, +}; + +PROTOC_EXPORT bool JavaFeatures_Utf8Validation_IsValid(int value); +PROTOC_EXPORT extern const uint32_t JavaFeatures_Utf8Validation_internal_data_[]; +constexpr JavaFeatures_Utf8Validation JavaFeatures_Utf8Validation_Utf8Validation_MIN = static_cast<JavaFeatures_Utf8Validation>(0); +constexpr JavaFeatures_Utf8Validation JavaFeatures_Utf8Validation_Utf8Validation_MAX = static_cast<JavaFeatures_Utf8Validation>(2); +constexpr int JavaFeatures_Utf8Validation_Utf8Validation_ARRAYSIZE = 2 + 1; +PROTOC_EXPORT const ::google::protobuf::EnumDescriptor* +JavaFeatures_Utf8Validation_descriptor(); +template <typename T> +const std::string& JavaFeatures_Utf8Validation_Name(T value) { + static_assert(std::is_same<T, JavaFeatures_Utf8Validation>::value || + std::is_integral<T>::value, + "Incorrect type passed to Utf8Validation_Name()."); + return JavaFeatures_Utf8Validation_Name(static_cast<JavaFeatures_Utf8Validation>(value)); +} +template <> +inline const std::string& JavaFeatures_Utf8Validation_Name(JavaFeatures_Utf8Validation value) { + return ::google::protobuf::internal::NameOfDenseEnum<JavaFeatures_Utf8Validation_descriptor, + 0, 2>( + static_cast<int>(value)); +} +inline bool JavaFeatures_Utf8Validation_Parse(absl::string_view name, JavaFeatures_Utf8Validation* value) { + return ::google::protobuf::internal::ParseNamedEnum<JavaFeatures_Utf8Validation>( + JavaFeatures_Utf8Validation_descriptor(), name, value); +} + +// =================================================================== + + +// ------------------------------------------------------------------- + +class PROTOC_EXPORT JavaFeatures final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:pb.JavaFeatures) */ { + public: + inline JavaFeatures() : JavaFeatures(nullptr) {} + ~JavaFeatures() override; + template<typename = void> + explicit PROTOBUF_CONSTEXPR JavaFeatures(::google::protobuf::internal::ConstantInitialized); + + inline JavaFeatures(const JavaFeatures& from) + : JavaFeatures(nullptr, from) {} + JavaFeatures(JavaFeatures&& from) noexcept + : JavaFeatures() { + *this = ::std::move(from); + } + + inline JavaFeatures& operator=(const JavaFeatures& from) { + CopyFrom(from); + return *this; + } + inline JavaFeatures& operator=(JavaFeatures&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const JavaFeatures& default_instance() { + return *internal_default_instance(); + } + static inline const JavaFeatures* internal_default_instance() { + return reinterpret_cast<const JavaFeatures*>( + &_JavaFeatures_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(JavaFeatures& a, JavaFeatures& b) { + a.Swap(&b); + } + inline void Swap(JavaFeatures* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(JavaFeatures* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + JavaFeatures* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage<JavaFeatures>(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const JavaFeatures& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const JavaFeatures& from) { + JavaFeatures::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + ::google::protobuf::internal::CachedSize* AccessCachedSize() const final; + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void InternalSwap(JavaFeatures* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "pb.JavaFeatures"; + } + protected: + explicit JavaFeatures(::google::protobuf::Arena* arena); + JavaFeatures(::google::protobuf::Arena* arena, const JavaFeatures& from); + public: + + static const ClassData _class_data_; + const ::google::protobuf::Message::ClassData*GetClassData() const final; + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + using Utf8Validation = JavaFeatures_Utf8Validation; + static constexpr Utf8Validation UTF8_VALIDATION_UNKNOWN = JavaFeatures_Utf8Validation_UTF8_VALIDATION_UNKNOWN; + static constexpr Utf8Validation DEFAULT = JavaFeatures_Utf8Validation_DEFAULT; + static constexpr Utf8Validation VERIFY = JavaFeatures_Utf8Validation_VERIFY; + static inline bool Utf8Validation_IsValid(int value) { + return JavaFeatures_Utf8Validation_IsValid(value); + } + static constexpr Utf8Validation Utf8Validation_MIN = JavaFeatures_Utf8Validation_Utf8Validation_MIN; + static constexpr Utf8Validation Utf8Validation_MAX = JavaFeatures_Utf8Validation_Utf8Validation_MAX; + static constexpr int Utf8Validation_ARRAYSIZE = JavaFeatures_Utf8Validation_Utf8Validation_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* Utf8Validation_descriptor() { + return JavaFeatures_Utf8Validation_descriptor(); + } + template <typename T> + static inline const std::string& Utf8Validation_Name(T value) { + return JavaFeatures_Utf8Validation_Name(value); + } + static inline bool Utf8Validation_Parse(absl::string_view name, Utf8Validation* value) { + return JavaFeatures_Utf8Validation_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kLegacyClosedEnumFieldNumber = 1, + kUtf8ValidationFieldNumber = 2, + }; + // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + bool has_legacy_closed_enum() const; + void clear_legacy_closed_enum() ; + bool legacy_closed_enum() const; + void set_legacy_closed_enum(bool value); + + private: + bool _internal_legacy_closed_enum() const; + void _internal_set_legacy_closed_enum(bool value); + + public: + // optional .pb.JavaFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + bool has_utf8_validation() const; + void clear_utf8_validation() ; + ::pb::JavaFeatures_Utf8Validation utf8_validation() const; + void set_utf8_validation(::pb::JavaFeatures_Utf8Validation value); + + private: + ::pb::JavaFeatures_Utf8Validation _internal_utf8_validation() const; + void _internal_set_utf8_validation(::pb::JavaFeatures_Utf8Validation value); + + public: + // @@protoc_insertion_point(class_scope:pb.JavaFeatures) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 1, + 0, 2> + _table_; + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template <typename T> + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct PROTOC_EXPORT Impl_ { + + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from); + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + bool legacy_closed_enum_; + int utf8_validation_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto; +}; + +// =================================================================== + + + +static const int kJavaFieldNumber = 1001; +PROTOC_EXPORT extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FeatureSet, + ::google::protobuf::internal::MessageTypeTraits< ::pb::JavaFeatures >, 11, false > + java; + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// JavaFeatures + +// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { +inline bool JavaFeatures::has_legacy_closed_enum() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline void JavaFeatures::clear_legacy_closed_enum() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.legacy_closed_enum_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool JavaFeatures::legacy_closed_enum() const { + // @@protoc_insertion_point(field_get:pb.JavaFeatures.legacy_closed_enum) + return _internal_legacy_closed_enum(); +} +inline void JavaFeatures::set_legacy_closed_enum(bool value) { + _internal_set_legacy_closed_enum(value); + // @@protoc_insertion_point(field_set:pb.JavaFeatures.legacy_closed_enum) +} +inline bool JavaFeatures::_internal_legacy_closed_enum() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.legacy_closed_enum_; +} +inline void JavaFeatures::_internal_set_legacy_closed_enum(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.legacy_closed_enum_ = value; +} + +// optional .pb.JavaFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { +inline bool JavaFeatures::has_utf8_validation() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline void JavaFeatures::clear_utf8_validation() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.utf8_validation_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::pb::JavaFeatures_Utf8Validation JavaFeatures::utf8_validation() const { + // @@protoc_insertion_point(field_get:pb.JavaFeatures.utf8_validation) + return _internal_utf8_validation(); +} +inline void JavaFeatures::set_utf8_validation(::pb::JavaFeatures_Utf8Validation value) { + _internal_set_utf8_validation(value); + // @@protoc_insertion_point(field_set:pb.JavaFeatures.utf8_validation) +} +inline ::pb::JavaFeatures_Utf8Validation JavaFeatures::_internal_utf8_validation() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return static_cast<::pb::JavaFeatures_Utf8Validation>(_impl_.utf8_validation_); +} +inline void JavaFeatures::_internal_set_utf8_validation(::pb::JavaFeatures_Utf8Validation value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + assert(::pb::JavaFeatures_Utf8Validation_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.utf8_validation_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace pb + + +namespace google { +namespace protobuf { + +template <> +struct is_proto_enum<::pb::JavaFeatures_Utf8Validation> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::pb::JavaFeatures_Utf8Validation>() { + return ::pb::JavaFeatures_Utf8Validation_descriptor(); +} + +} // namespace protobuf +} // namespace google + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fjava_2fjava_5ffeatures_2eproto_2epb_2eh