// Protocol Buffers - Google's data interchange format // Copyright 2023 Google LLC. All rights reserved. // // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file or at // https://developers.google.com/open-source/licenses/bsd #include "google/protobuf/compiler/hpb/gen_accessors.h" #include #include "absl/container/flat_hash_set.h" #include "absl/strings/match.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" #include "google/protobuf/compiler/hpb/gen_repeated_fields.h" #include "google/protobuf/compiler/hpb/gen_utils.h" #include "google/protobuf/compiler/hpb/keywords.h" #include "google/protobuf/compiler/hpb/names.h" #include "google/protobuf/compiler/hpb/output.h" #include "google/protobuf/descriptor.h" #include "upb_generator/c/names.h" #include "upb_generator/minitable/names.h" namespace google::protobuf::hpb_generator { namespace protobuf = ::proto2; using NameToFieldDescriptorMap = absl::flat_hash_map; void WriteFieldAccessorHazzer(const protobuf::Descriptor* desc, const protobuf::FieldDescriptor* field, absl::string_view resolved_field_name, absl::string_view resolved_upbc_name, Output& output); void WriteFieldAccessorClear(const protobuf::Descriptor* desc, const protobuf::FieldDescriptor* field, absl::string_view resolved_field_name, absl::string_view resolved_upbc_name, Output& output); void WriteMapFieldAccessors(const protobuf::Descriptor* desc, const protobuf::FieldDescriptor* field, absl::string_view resolved_field_name, absl::string_view resolved_upbc_name, Output& output); void WriteMapAccessorDefinitions(const protobuf::Descriptor* message, const protobuf::FieldDescriptor* field, absl::string_view resolved_field_name, absl::string_view class_name, Output& output); // Returns C++ class member name by resolving naming conflicts across // proto field names (such as clear_ prefixes) and keyword collisions. // // The Upb C generator prefixes all accessors with package and class names // avoiding collisions. Therefore we need to use raw field names when calling // into C accessors but need to fully resolve conflicts for C++ class members. std::string ResolveFieldName(const protobuf::FieldDescriptor* field, const NameToFieldDescriptorMap& field_names); upb::generator::NameMangler CreateNameMangler( const protobuf::Descriptor* message) { return upb::generator::NameMangler(upb::generator::GetCppFields(message)); } NameToFieldDescriptorMap CreateFieldNameMap( const protobuf::Descriptor* message) { NameToFieldDescriptorMap field_names; for (int i = 0; i < message->field_count(); i++) { const protobuf::FieldDescriptor* field = message->field(i); field_names.emplace(field->name(), field); } return field_names; } void WriteFieldAccessorsInHeader(const protobuf::Descriptor* desc, Output& output) { // Generate const methods. OutputIndenter i(output); auto field_names = CreateFieldNameMap(desc); auto mangler = CreateNameMangler(desc); for (const auto* field : FieldNumberOrder(desc)) { std::string resolved_field_name = ResolveFieldName(field, field_names); std::string resolved_upbc_name = mangler.ResolveFieldName(field->name()); WriteFieldAccessorHazzer(desc, field, resolved_field_name, resolved_upbc_name, output); WriteFieldAccessorClear(desc, field, resolved_field_name, resolved_upbc_name, output); if (field->is_map()) { WriteMapFieldAccessors(desc, field, resolved_field_name, resolved_upbc_name, output); } else if (desc->options().map_entry()) { // TODO Implement map entry } else if (field->is_repeated()) { WriteRepeatedFieldsInMessageHeader(desc, field, resolved_field_name, resolved_upbc_name, output); } else { // non-repeated. if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING) { output(R"cc( $0 $1() const; void set_$1($0 value); )cc", CppConstType(field), resolved_field_name); } else if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) { output(R"cc( $1 $2() const; $0 mutable_$2(); )cc", MessagePtrConstType(field, /* const */ false), MessagePtrConstType(field, /* const */ true), resolved_field_name); } else { output( R"cc( inline $0 $1() const { return $2_$3(msg_); } inline void set_$1($0 value) { return $2_set_$3(msg_, value); } )cc", CppConstType(field), resolved_field_name, MessageName(desc), resolved_upbc_name); } } } } void WriteFieldAccessorHazzer(const protobuf::Descriptor* desc, const protobuf::FieldDescriptor* field, const absl::string_view resolved_field_name, const absl::string_view resolved_upbc_name, Output& output) { // Generate hazzer (if any). if (field->has_presence()) { // Has presence. output("inline bool has_$0() const { return $1_has_$2(msg_); }\n", resolved_field_name, MessageName(desc), resolved_upbc_name); } } void WriteFieldAccessorClear(const protobuf::Descriptor* desc, const protobuf::FieldDescriptor* field, const absl::string_view resolved_field_name, const absl::string_view resolved_upbc_name, Output& output) { if (field->has_presence()) { output("void clear_$0() { $2_clear_$1(msg_); }\n", resolved_field_name, resolved_upbc_name, MessageName(desc)); } } void WriteMapFieldAccessors(const protobuf::Descriptor* desc, const protobuf::FieldDescriptor* field, const absl::string_view resolved_field_name, const absl::string_view resolved_upbc_name, Output& output) { const protobuf::Descriptor* entry = field->message_type(); const protobuf::FieldDescriptor* key = entry->FindFieldByNumber(1); const protobuf::FieldDescriptor* val = entry->FindFieldByNumber(2); output( R"cc( inline size_t $0_size() const { return $1_$3_size(msg_); } inline void clear_$0() { $1_clear_$3(msg_); } void delete_$0($2 key); )cc", resolved_field_name, MessageName(desc), CppConstType(key), resolved_upbc_name); if (val->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) { output( R"cc( bool set_$0($1 key, $3 value); bool set_$0($1 key, $4 value); absl::StatusOr<$3> get_$0($1 key); )cc", resolved_field_name, CppConstType(key), CppConstType(val), MessagePtrConstType(val, /* is_const */ true), MessagePtrConstType(val, /* is_const */ false)); } else { output( R"cc( bool set_$0($1 key, $2 value); absl::StatusOr<$2> get_$0($1 key); )cc", resolved_field_name, CppConstType(key), CppConstType(val)); } } void WriteAccessorsInSource(const protobuf::Descriptor* desc, Output& output) { std::string class_name = ClassName(desc); absl::StrAppend(&class_name, "Access"); output("namespace internal {\n"); const char arena_expression[] = "arena_"; auto field_names = CreateFieldNameMap(desc); auto mangler = CreateNameMangler(desc); // Generate const methods. OutputIndenter i(output); for (const auto* field : FieldNumberOrder(desc)) { std::string resolved_field_name = ResolveFieldName(field, field_names); std::string resolved_upbc_name = mangler.ResolveFieldName(field->name()); if (field->is_map()) { WriteMapAccessorDefinitions(desc, field, resolved_field_name, class_name, output); } else if (desc->options().map_entry()) { // TODO Implement map entry } else if (field->is_repeated()) { if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) { WriteRepeatedMessageAccessor(desc, field, resolved_field_name, class_name, output); } else if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING) { WriteRepeatedStringAccessor(desc, field, resolved_field_name, class_name, output); } else { WriteRepeatedScalarAccessor(desc, field, resolved_field_name, class_name, output); } } else { // non-repeated field. if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING) { output( R"cc( $1 $0::$2() const { return hpb::interop::upb::FromUpbStringView($3_$4(msg_)); } )cc", class_name, CppConstType(field), resolved_field_name, MessageName(desc), resolved_upbc_name); // Set string. output( R"cc( void $0::set_$2($1 value) { $4_set_$3(msg_, hpb::interop::upb::CopyToUpbStringView(value, $5)); } )cc", class_name, CppConstType(field), resolved_field_name, resolved_upbc_name, MessageName(desc), arena_expression); } else if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) { output( R"cc( $1 $0::$2() const { if (!has_$2()) { return $4::default_instance(); } return ::hpb::interop::upb::MakeCHandle<$4>( (upb_Message*)($3_$5(msg_)), arena_); } )cc", class_name, MessagePtrConstType(field, /* is_const */ true), resolved_field_name, MessageName(desc), MessageBaseType(field, /* maybe_const */ false), resolved_upbc_name); output( R"cc( $1 $0::mutable_$2() { return hpb::interop::upb::MakeHandle<$4>( (upb_Message*)($3_mutable_$5(msg_, $6)), $6); } )cc", class_name, MessagePtrConstType(field, /* is_const */ false), resolved_field_name, MessageName(desc), MessageBaseType(field, /* maybe_const */ false), resolved_upbc_name, arena_expression); } } } output("\n"); output("} // namespace internal\n\n"); } void WriteMapAccessorDefinitions(const protobuf::Descriptor* message, const protobuf::FieldDescriptor* field, const absl::string_view resolved_field_name, const absl::string_view class_name, Output& output) { const protobuf::Descriptor* entry = field->message_type(); const protobuf::FieldDescriptor* key = entry->FindFieldByNumber(1); const protobuf::FieldDescriptor* val = entry->FindFieldByNumber(2); absl::string_view upbc_name = field->name(); absl::string_view converted_key_name = "key"; absl::string_view optional_conversion_code = ""; if (key->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING) { // Insert conversion from absl::string_view to upb_StringView. // Creates upb_StringView on stack to prevent allocation. converted_key_name = "upb_key"; optional_conversion_code = "upb_StringView upb_key = {key.data(), key.size()};\n"; } if (val->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) { output( R"cc( bool $0::set_$1($2 key, $3 value) { upb_Message* clone = upb_Message_DeepClone( ::hpb::internal::PrivateAccess::GetInternalMsg(value), &$9, arena_); $6return $4_$8_set(msg_, $7, ($5*)clone, arena_); } )cc", class_name, resolved_field_name, CppConstType(key), MessagePtrConstType(val, /* is_const */ true), MessageName(message), MessageName(val->message_type()), optional_conversion_code, converted_key_name, upbc_name, ::upb::generator::MiniTableMessageVarName( val->message_type()->full_name())); output( R"cc( bool $0::set_$1($2 key, $3 value) { upb_Message* clone = upb_Message_DeepClone( ::hpb::internal::PrivateAccess::GetInternalMsg(value), &$9, arena_); $6return $4_$8_set(msg_, $7, ($5*)clone, arena_); } )cc", class_name, resolved_field_name, CppConstType(key), MessagePtrConstType(val, /* is_const */ false), MessageName(message), MessageName(val->message_type()), optional_conversion_code, converted_key_name, upbc_name, ::upb::generator::MiniTableMessageVarName( val->message_type()->full_name())); output( R"cc( absl::StatusOr<$3> $0::get_$1($2 key) { $5* msg_value; $7bool success = $4_$9_get(msg_, $8, &msg_value); if (success) { return ::hpb::interop::upb::MakeCHandle<$6>(UPB_UPCAST(msg_value), arena_); } return absl::NotFoundError(""); } )cc", class_name, resolved_field_name, CppConstType(key), MessagePtrConstType(val, /* is_const */ true), MessageName(message), MessageName(val->message_type()), QualifiedClassName(val->message_type()), optional_conversion_code, converted_key_name, upbc_name); output( R"cc( void $0::delete_$1($2 key) { $6$4_$8_delete(msg_, $7); } )cc", class_name, resolved_field_name, CppConstType(key), MessagePtrConstType(val, /* is_const */ false), MessageName(message), MessageName(val->message_type()), optional_conversion_code, converted_key_name, upbc_name); } else if (val->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING) { output( R"cc( bool $0::set_$1($2 key, $3 value) { $5return $4_$7_set( msg_, $6, hpb::interop::upb::CopyToUpbStringView(value, arena_), arena_); } )cc", class_name, resolved_field_name, CppConstType(key), CppConstType(val), MessageName(message), optional_conversion_code, converted_key_name, upbc_name); output( R"cc( absl::StatusOr<$3> $0::get_$1($2 key) { upb_StringView value; $5bool success = $4_$7_get(msg_, $6, &value); if (success) { return absl::string_view(value.data, value.size); } return absl::NotFoundError(""); } )cc", class_name, resolved_field_name, CppConstType(key), CppConstType(val), MessageName(message), optional_conversion_code, converted_key_name, upbc_name); output( R"cc( void $0::delete_$1($2 key) { $5$4_$7_delete(msg_, $6); } )cc", class_name, resolved_field_name, CppConstType(key), CppConstType(val), MessageName(message), optional_conversion_code, converted_key_name, upbc_name); } else { output( R"cc( bool $0::set_$1($2 key, $3 value) { $5return $4_$7_set(msg_, $6, value, arena_); } )cc", class_name, resolved_field_name, CppConstType(key), CppConstType(val), MessageName(message), optional_conversion_code, converted_key_name, upbc_name); output( R"cc( absl::StatusOr<$3> $0::get_$1($2 key) { $3 value; $5bool success = $4_$7_get(msg_, $6, &value); if (success) { return value; } return absl::NotFoundError(""); } )cc", class_name, resolved_field_name, CppConstType(key), CppConstType(val), MessageName(message), optional_conversion_code, converted_key_name, upbc_name); output( R"cc( void $0::delete_$1($2 key) { $5$4_$7_delete(msg_, $6); } )cc", class_name, resolved_field_name, CppConstType(key), CppConstType(val), MessageName(message), optional_conversion_code, converted_key_name, upbc_name); } } void WriteUsingAccessorsInHeader(const protobuf::Descriptor* desc, MessageClassType handle_type, Output& output) { bool read_only = handle_type == MessageClassType::kMessageCProxy; // Generate const methods. OutputIndenter i(output); std::string class_name = ClassName(desc); auto field_names = CreateFieldNameMap(desc); for (const auto* field : FieldNumberOrder(desc)) { std::string resolved_field_name = ResolveFieldName(field, field_names); // Generate hazzer (if any). if (field->has_presence()) { output("using $0Access::has_$1;\n", class_name, resolved_field_name); if (!read_only) { output("using $0Access::clear_$1;\n", class_name, resolved_field_name); } } if (field->is_map()) { output( R"cc( using $0Access::$1_size; using $0Access::get_$1; )cc", class_name, resolved_field_name); if (!read_only) { output( R"cc( using $0Access::clear_$1; using $0Access::delete_$1; using $0Access::set_$1; )cc", class_name, resolved_field_name); } } else if (desc->options().map_entry()) { // TODO Implement map entry } else if (field->is_repeated()) { WriteRepeatedFieldUsingAccessors(field, class_name, resolved_field_name, output, read_only); } else { if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) { output("using $0Access::$1;\n", ClassName(desc), resolved_field_name); if (!read_only) { output("using $0Access::mutable_$1;\n", class_name, resolved_field_name); } } else { output("using $0Access::$1;\n", class_name, resolved_field_name); if (!read_only) { output("using $0Access::set_$1;\n", class_name, resolved_field_name); } } } } for (int i = 0; i < desc->real_oneof_decl_count(); ++i) { const protobuf::OneofDescriptor* oneof = desc->oneof_decl(i); output("using $0Access::$1_case;\n", class_name, oneof->name()); output("using $0Access::$1Case;\n", class_name, ToCamelCase(oneof->name(), /*lower_first=*/false)); for (int j = 0; j < oneof->field_count(); ++j) { const protobuf::FieldDescriptor* field = oneof->field(j); output("using $0Access::k$1;\n", class_name, ToCamelCase(field->name(), /*lower_first=*/false), field->number()); } output("using $0Access::$1_NOT_SET;\n", class_name, absl::AsciiStrToUpper(oneof->name())); } } void WriteOneofAccessorsInHeader(const protobuf::Descriptor* desc, Output& output) { // Generate const methods. OutputIndenter i(output); std::string class_name = ClassName(desc); auto field_names = CreateFieldNameMap(desc); for (int i = 0; i < desc->real_oneof_decl_count(); ++i) { const protobuf::OneofDescriptor* oneof = desc->oneof_decl(i); output("enum $0Case {\n", ToCamelCase(oneof->name(), /*lower_first=*/false)); for (int j = 0; j < oneof->field_count(); ++j) { const protobuf::FieldDescriptor* field = oneof->field(j); output(" k$0 = $1,\n", ToCamelCase(field->name(), /*lower_first=*/false), field->number()); } output(" $0_NOT_SET = 0,\n", absl::AsciiStrToUpper(oneof->name())); output("};\n\n"); output("$0Case $1_case() const {\n", ToCamelCase(oneof->name(), /*lower_first=*/false), oneof->name()); for (int j = 0; j < oneof->field_count(); ++j) { const protobuf::FieldDescriptor* field = oneof->field(j); std::string resolved_field_name = ResolveFieldName(field, field_names); output(" if (has_$0()) { return k$1; }\n", resolved_field_name, ToCamelCase(field->name(), /*lower_first=*/false)); } output(" return $0_NOT_SET;\n", absl::AsciiStrToUpper(oneof->name())); output("}\n;"); } } std::string ResolveFieldName(const protobuf::FieldDescriptor* field, const NameToFieldDescriptorMap& field_names) { // C++ implementation specific reserved names. static const auto& kReservedNames = *new absl::flat_hash_set({ "msg", "msg_", "arena", "arena_", }); // C++ specific prefixes used by code generator for field access. static constexpr absl::string_view kClearMethodPrefix = "clear_"; static constexpr absl::string_view kSetMethodPrefix = "set_"; static constexpr absl::string_view kHasMethodPrefix = "has_"; static constexpr absl::string_view kDeleteMethodPrefix = "delete_"; static constexpr absl::string_view kAddToRepeatedMethodPrefix = "add_"; static constexpr absl::string_view kResizeArrayMethodPrefix = "resize_"; // List of generated accessor prefixes to check against. // Example: // optional repeated string phase = 236; // optional bool clear_phase = 237; static constexpr absl::string_view kAccessorPrefixes[] = { kClearMethodPrefix, kDeleteMethodPrefix, kAddToRepeatedMethodPrefix, kResizeArrayMethodPrefix, kSetMethodPrefix, kHasMethodPrefix}; absl::string_view field_name = field->name(); if (kReservedNames.count(field_name) > 0) { if (absl::EndsWith(field_name, "_")) { return absl::StrCat(field_name, "_"); } else { return absl::StrCat(field_name, "__"); } } for (const auto prefix : kAccessorPrefixes) { // If field name starts with a prefix such as clear_ and the proto // contains a field name with trailing end, depending on type of field // (repeated, map, message) we have a conflict to resolve. if (absl::StartsWith(field_name, prefix)) { auto match = field_names.find(field_name.substr(prefix.size())); if (match != field_names.end()) { const auto* candidate = match->second; if (candidate->is_repeated() || candidate->is_map() || (candidate->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING && prefix == kClearMethodPrefix) || prefix == kSetMethodPrefix || prefix == kHasMethodPrefix) { return absl::StrCat(field_name, "_"); } } } } return ResolveKeywordConflict(field_name); } } // namespace protobuf } // namespace google::hpb_generator