diff --git a/upb/def.c b/upb/def.c index e05af59047..233d7d9eb3 100644 --- a/upb/def.c +++ b/upb/def.c @@ -77,6 +77,7 @@ struct upb_fielddef { bool is_extension_; bool packed_; bool proto3_optional_; + bool has_json_name_; upb_descriptortype_t type_; upb_label_t label_; }; @@ -156,6 +157,7 @@ struct upb_filedef { const upb_filedef **deps; const int32_t* public_deps; + const int32_t* weak_deps; const upb_msgdef *top_lvl_msgs; const upb_enumdef *top_lvl_enums; const upb_fielddef *top_lvl_exts; @@ -165,6 +167,7 @@ struct upb_filedef { int dep_count; int public_dep_count; + int weak_dep_count; int top_lvl_msg_count; int top_lvl_enum_count; int top_lvl_ext_count; @@ -547,6 +550,10 @@ const char *upb_fielddef_jsonname(const upb_fielddef *f) { return f->json_name; } +bool upb_fielddef_hasjsonname(const upb_fielddef *f) { + return f->has_json_name_; +} + const upb_filedef *upb_fielddef_file(const upb_fielddef *f) { return f->file; } @@ -1047,10 +1054,18 @@ int upb_filedef_publicdepcount(const upb_filedef *f) { return f->public_dep_count; } +int upb_filedef_weakdepcount(const upb_filedef *f) { + return f->weak_dep_count; +} + const int32_t *_upb_filedef_publicdepnums(const upb_filedef *f) { return f->public_deps; } +const int32_t *_upb_filedef_weakdepnums(const upb_filedef *f) { + return f->weak_deps; +} + int upb_filedef_toplvlenumcount(const upb_filedef *f) { return f->top_lvl_enum_count; } @@ -1073,6 +1088,11 @@ const upb_filedef *upb_filedef_publicdep(const upb_filedef *f, int i) { return f->deps[f->public_deps[i]]; } +const upb_filedef *upb_filedef_weakdep(const upb_filedef *f, int i) { + UPB_ASSERT(0 <= i && i < f->public_dep_count); + return f->deps[f->weak_deps[i]]; +} + const upb_msgdef *upb_filedef_toplvlmsg(const upb_filedef *f, int i) { UPB_ASSERT(0 <= i && i < f->top_lvl_msg_count); return &f->top_lvl_msgs[i]; @@ -2152,8 +2172,10 @@ static void create_fielddef( if (google_protobuf_FieldDescriptorProto_has_json_name(field_proto)) { json_name = strviewdup( ctx, google_protobuf_FieldDescriptorProto_json_name(field_proto)); + f->has_json_name_ = true; } else { json_name = makejsonname(ctx, shortname); + f->has_json_name_ = false; } field_number = google_protobuf_FieldDescriptorProto_number(field_proto); @@ -2751,6 +2773,7 @@ static void build_filedef( const google_protobuf_ServiceDescriptorProto *const *services; const upb_strview *strs; const int32_t *public_deps; + const int32_t *weak_deps; size_t i, n; file->symtab = ctx->symtab; @@ -2843,6 +2866,18 @@ static void build_filedef( mutable_public_deps[i] = public_deps[i]; } + weak_deps = + google_protobuf_FileDescriptorProto_weak_dependency(file_proto, &n); + file->weak_dep_count = n; + file->weak_deps = symtab_alloc(ctx, sizeof(*file->weak_deps) * n); + int32_t *mutable_weak_deps = (int32_t*)file->weak_deps; + for (i = 0; i < n; i++) { + if (weak_deps[i] >= file->dep_count) { + symtab_errf(ctx, "public_dep %d is out of range", (int)public_deps[i]); + } + mutable_weak_deps[i] = weak_deps[i]; + } + /* Create enums. */ enums = google_protobuf_FileDescriptorProto_enum_type(file_proto, &n); file->top_lvl_enum_count = n; diff --git a/upb/def.h b/upb/def.h index 141affd830..7d379dc88a 100644 --- a/upb/def.h +++ b/upb/def.h @@ -121,6 +121,7 @@ upb_label_t upb_fielddef_label(const upb_fielddef *f); uint32_t upb_fielddef_number(const upb_fielddef *f); const char *upb_fielddef_name(const upb_fielddef *f); const char *upb_fielddef_jsonname(const upb_fielddef *f); +bool upb_fielddef_hasjsonname(const upb_fielddef *f); bool upb_fielddef_isextension(const upb_fielddef *f); bool upb_fielddef_packed(const upb_fielddef *f); const upb_filedef *upb_fielddef_file(const upb_fielddef *f); @@ -354,18 +355,21 @@ const char *upb_filedef_phpnamespace(const upb_filedef *f); upb_syntax_t upb_filedef_syntax(const upb_filedef *f); int upb_filedef_depcount(const upb_filedef *f); int upb_filedef_publicdepcount(const upb_filedef *f); +int upb_filedef_weakdepcount(const upb_filedef *f); int upb_filedef_toplvlmsgcount(const upb_filedef *f); int upb_filedef_toplvlenumcount(const upb_filedef *f); int upb_filedef_toplvlextcount(const upb_filedef *f); int upb_filedef_servicecount(const upb_filedef *f); const upb_filedef *upb_filedef_dep(const upb_filedef *f, int i); const upb_filedef *upb_filedef_publicdep(const upb_filedef *f, int i); +const upb_filedef *upb_filedef_weakdep(const upb_filedef *f, int i); const upb_msgdef *upb_filedef_toplvlmsg(const upb_filedef *f, int i); const upb_enumdef *upb_filedef_toplvlenum(const upb_filedef *f, int i); const upb_fielddef *upb_filedef_toplvlext(const upb_filedef *f, int i); const upb_servicedef *upb_filedef_service(const upb_filedef *f, int i); const upb_symtab *upb_filedef_symtab(const upb_filedef *f); const int32_t *_upb_filedef_publicdepnums(const upb_filedef *f); +const int32_t *_upb_filedef_weakdepnums(const upb_filedef *f); /* upb_methoddef **************************************************************/ diff --git a/upb/def.hpp b/upb/def.hpp index cc4c16b9df..c6db8e684e 100644 --- a/upb/def.hpp +++ b/upb/def.hpp @@ -40,6 +40,7 @@ namespace upb { typedef upb_msgval MessageValue; class EnumDefPtr; +class FileDefPtr; class MessageDefPtr; class OneofDefPtr; @@ -192,6 +193,8 @@ class MessageDefPtr { const upb_msgdef* ptr() const { return ptr_; } explicit operator bool() const { return ptr_ != nullptr; } + FileDefPtr file() const; + const char* full_name() const { return upb_msgdef_fullname(ptr_); } const char* name() const { return upb_msgdef_name(ptr_); } @@ -447,6 +450,10 @@ class SymbolTable { std::unique_ptr ptr_; }; +inline FileDefPtr MessageDefPtr::file() const { + return FileDefPtr(upb_msgdef_file(ptr_)); +} + inline MessageDefPtr FieldDefPtr::message_subdef() const { return MessageDefPtr(upb_fielddef_msgsubdef(ptr_)); } diff --git a/upb/util/BUILD b/upb/util/BUILD index 0b8fc0be25..94eb9d86c0 100644 --- a/upb/util/BUILD +++ b/upb/util/BUILD @@ -39,6 +39,8 @@ cc_test( deps = [ "@com_google_absl//absl/strings", "@com_google_googletest//:gtest_main", + "//:descriptor_upb_proto_reflection", + "@com_google_protobuf//:protobuf", ":def_to_proto", ":def_to_proto_test_upb_proto", ":def_to_proto_test_upb_proto_reflection", diff --git a/upb/util/def_to_proto.c b/upb/util/def_to_proto.c index 4c5c0afbf8..addab03397 100644 --- a/upb/util/def_to_proto.c +++ b/upb/util/def_to_proto.c @@ -79,17 +79,14 @@ static upb_strview qual_dup(toproto_ctx *ctx, const char *s) { UPB_PRINTF(2, 3) static upb_strview printf_dup(toproto_ctx *ctx, const char *fmt, ...) { - va_list args; - va_start(args, fmt); - size_t n = vsnprintf(NULL, 0, fmt, args); - va_end(args); - - char *p = upb_arena_malloc(ctx->arena, n + 1); + const size_t max = 32; + char *p = upb_arena_malloc(ctx->arena, max); CHK_OOM(p); - + va_list args; va_start(args, fmt); - vsnprintf(p, n, fmt, args); + size_t n = vsnprintf(p, max, fmt, args); va_end(args); + UPB_ASSERT(n < max); return (upb_strview){.data = p, .size = n}; } @@ -98,7 +95,11 @@ static upb_strview default_string(toproto_ctx *ctx, const upb_fielddef *f) { switch (upb_fielddef_type(f)) { case UPB_TYPE_BOOL: return strviewdup(ctx, d.bool_val ? "true" : "false"); - case UPB_TYPE_ENUM: // TODO: encode as string? + case UPB_TYPE_ENUM: { + const upb_enumdef *e = upb_fielddef_enumsubdef(f); + const upb_enumvaldef *ev = upb_enumdef_lookupnum(e, d.int32_val); + return strviewdup(ctx, upb_enumvaldef_name(ev)); + } case UPB_TYPE_INT64: return printf_dup(ctx, "%" PRId64, d.int64_val); case UPB_TYPE_UINT64: @@ -134,7 +135,10 @@ static google_protobuf_FieldDescriptorProto *fielddef_toproto( google_protobuf_FieldDescriptorProto_set_type(proto, upb_fielddef_descriptortype(f)); - // TODO: json_name (needs has_json_name from fielddef). + if (upb_fielddef_hasjsonname(f)) { + google_protobuf_FieldDescriptorProto_set_json_name( + proto, strviewdup(ctx, upb_fielddef_jsonname(f))); + } if (upb_fielddef_issubmsg(f)) { google_protobuf_FieldDescriptorProto_set_type_name( @@ -405,8 +409,15 @@ static google_protobuf_FileDescriptorProto *filedef_toproto( int32_t *public_deps = google_protobuf_FileDescriptorProto_resize_public_dependency(proto, n, ctx->arena); - const int32_t *proto_deps = _upb_filedef_publicdepnums(f); - memcpy(public_deps, proto_deps, n * sizeof(int32_t)); + const int32_t *public_dep_nums = _upb_filedef_publicdepnums(f); + memcpy(public_deps, public_dep_nums, n * sizeof(int32_t)); + + n = upb_filedef_weakdepcount(f); + int32_t *weak_deps = + google_protobuf_FileDescriptorProto_resize_weak_dependency(proto, n, + ctx->arena); + const int32_t *weak_dep_nums = _upb_filedef_weakdepnums(f); + memcpy(weak_deps, weak_dep_nums, n * sizeof(int32_t)); n = upb_filedef_toplvlmsgcount(f); google_protobuf_DescriptorProto **msgs = @@ -444,8 +455,6 @@ static google_protobuf_FileDescriptorProto *filedef_toproto( upb_filedef_options(f)); } - // TODO: public & weak dependencies. - return proto; } diff --git a/upb/util/def_to_proto_public_import_test.proto b/upb/util/def_to_proto_public_import_test.proto new file mode 100644 index 0000000000..10f1c11733 --- /dev/null +++ b/upb/util/def_to_proto_public_import_test.proto @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2009-2021, Google LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Google LLC nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +syntax = "proto3"; diff --git a/upb/util/def_to_proto_regular_import_test.proto b/upb/util/def_to_proto_regular_import_test.proto new file mode 100644 index 0000000000..10f1c11733 --- /dev/null +++ b/upb/util/def_to_proto_regular_import_test.proto @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2009-2021, Google LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Google LLC nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +syntax = "proto3"; diff --git a/upb/util/def_to_proto_test.cc b/upb/util/def_to_proto_test.cc new file mode 100644 index 0000000000..9d70d3e779 --- /dev/null +++ b/upb/util/def_to_proto_test.cc @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2009-2021, Google LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Google LLC nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "upb/util/def_to_proto.h" + +#include "gmock/gmock.h" +#include "google/protobuf/descriptor.pb.h" +#include "google/protobuf/descriptor.upbdefs.h" +#include "google/protobuf/dynamic_message.h" +#include "google/protobuf/util/message_differencer.h" +#include "gtest/gtest.h" +#include "upb/def.hpp" +#include "upb/upb.hpp" +#include "upb/util/def_to_proto_test.upbdefs.h" + +// Loads and retrieves a descriptor for `msgdef` into the given `pool`. +const google::protobuf::Descriptor* AddMessageDescriptor( + upb::MessageDefPtr msgdef, google::protobuf::DescriptorPool* pool) { + upb::Arena tmp_arena; + upb::FileDefPtr file = msgdef.file(); + google_protobuf_FileDescriptorProto* upb_proto = + upb_FileDef_ToProto(file.ptr(), tmp_arena.ptr()); + size_t size; + const char* buf = google_protobuf_FileDescriptorProto_serialize( + upb_proto, tmp_arena.ptr(), &size); + google::protobuf::FileDescriptorProto google_proto; + google_proto.ParseFromArray(buf, size); + const google::protobuf::FileDescriptor* file_desc = + pool->BuildFile(google_proto); + EXPECT_TRUE(file_desc != nullptr); + return pool->FindMessageTypeByName(msgdef.full_name()); +} + +// Converts a upb `msg` (with type `msgdef`) into a protobuf Message object from +// the given factory and descriptor. +std::unique_ptr ToProto( + const upb_msg* msg, const upb_msgdef* msgdef, + const google::protobuf::Descriptor* desc, + google::protobuf::MessageFactory* factory) { + upb::Arena arena; + EXPECT_TRUE(desc != nullptr); + std::unique_ptr google_msg( + factory->GetPrototype(desc)->New()); + size_t size; + const char* buf = + upb_encode(msg, upb_msgdef_layout(msgdef), arena.ptr(), &size); + google_msg->ParseFromArray(buf, size); + return google_msg; +} + +// A gtest matcher that verifies that a proto is equal to `proto`. Both `proto` +// and `arg` must be messages of type `msgdef_func` (a .upbdefs.h function that +// loads a known msgdef into the given symtab). +MATCHER_P2(EqualsUpbProto, proto, msgdef_func, + negation ? "are not equal" : "are equal") { + upb::SymbolTable symtab; + google::protobuf::DescriptorPool pool; + google::protobuf::DynamicMessageFactory factory; + upb::MessageDefPtr msgdef(msgdef_func(symtab.ptr())); + EXPECT_TRUE(msgdef.ptr() != nullptr); + const google::protobuf::Descriptor* desc = + AddMessageDescriptor(msgdef, &pool); + EXPECT_TRUE(desc != nullptr); + std::unique_ptr m1( + ToProto(proto, msgdef.ptr(), desc, &factory)); + std::unique_ptr m2( + ToProto(arg, msgdef.ptr(), desc, &factory)); + std::string differences; + google::protobuf::util::MessageDifferencer differencer; + differencer.ReportDifferencesToString(&differences); + bool eq = differencer.Compare(*m2, *m1); + if (!eq) { + *result_listener << differences; + } + return eq; +} + +// Verifies that the given upb FileDef can be converted to a proto that matches +// `proto`. +void CheckFile(const upb::FileDefPtr file, + const google_protobuf_FileDescriptorProto* proto) { + upb::Arena arena; + google_protobuf_FileDescriptorProto* proto2 = + upb_FileDef_ToProto(file.ptr(), arena.ptr()); + ASSERT_THAT( + proto, + EqualsUpbProto(proto2, google_protobuf_FileDescriptorProto_getmsgdef)); +} + +// Verifies that upb/util/def_to_proto_test.proto can round-trip: +// serialized descriptor -> upb def -> serialized descriptor +TEST(DefToProto, Test) { + upb::Arena arena; + upb::SymbolTable symtab; + upb_strview test_file_desc = + upb_util_def_to_proto_test_proto_upbdefinit.descriptor; + const auto* file_desc = google_protobuf_FileDescriptorProto_parse( + test_file_desc.data, test_file_desc.size, arena.ptr()); + + upb::MessageDefPtr msgdef(pkg_Message_getmsgdef(symtab.ptr())); + upb::FileDefPtr file = msgdef.file(); + CheckFile(file, file_desc); +} diff --git a/upb/util/def_to_proto_test.proto b/upb/util/def_to_proto_test.proto new file mode 100644 index 0000000000..d7171934d6 --- /dev/null +++ b/upb/util/def_to_proto_test.proto @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2009-2021, Google LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Google LLC nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +syntax = "proto2"; + +import "upb/util/def_to_proto_regular_import_test.proto"; +import public "upb/util/def_to_proto_public_import_test.proto"; +import weak "upb/util/def_to_proto_weak_import_test.proto"; + +package pkg; + +option optimize_for = CODE_SIZE; +option go_package = "foo_go_package"; +option java_package = "bar_java_package"; +option java_outer_classname = "baz_java_outer_classname"; +option csharp_namespace = "quux_csharp_namespace"; +option objc_class_prefix = "the_objc_prefix"; +option cc_enable_arenas = true; + +message Message { + optional int32 a = 1 [default = 3]; + oneof foo { + string oneof_string = 2 [default = "abc\n"]; + string oneof_bool = 3 [default = "true"]; + bytes oneof_bytes = 4 [default = "abc\xef\xfe"]; + } + extensions 1000 to max; + extend Message { + optional int32 ext = 1000; + } + + message NestedMessage {} + message NestedEnum {} + + // TODO: support reserved ranges in defs. + // (At the moment they are ignored and will not round-trip through defs). + // reserved 4, 6 to 8; +} + +enum Enum { + ZERO = 0; + ONE = 1; + NEGATIVE_ONE = -1; +} + +service Service { + rpc Bar(Message) returns (Message); +} + +extend Message { + optional int32 ext = 1001; +} diff --git a/upb/util/def_to_proto_weak_import_test.proto b/upb/util/def_to_proto_weak_import_test.proto new file mode 100644 index 0000000000..10f1c11733 --- /dev/null +++ b/upb/util/def_to_proto_weak_import_test.proto @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2009-2021, Google LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Google LLC nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +syntax = "proto3"; diff --git a/upb/util/def_to_proto_wweak_import_test.proto b/upb/util/def_to_proto_wweak_import_test.proto new file mode 100644 index 0000000000..10f1c11733 --- /dev/null +++ b/upb/util/def_to_proto_wweak_import_test.proto @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2009-2021, Google LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Google LLC nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +syntax = "proto3"; diff --git a/upbc/protoc-gen-upb.cc b/upbc/protoc-gen-upb.cc index 9c23647016..8933cff861 100644 --- a/upbc/protoc-gen-upb.cc +++ b/upbc/protoc-gen-upb.cc @@ -83,12 +83,6 @@ void AddEnums(const protobuf::Descriptor* message, } } -template -void SortDefs(std::vector* defs) { - std::sort(defs->begin(), defs->end(), - [](T a, T b) { return a->full_name() < b->full_name(); }); -} - std::vector SortedEnums( const protobuf::FileDescriptor* file) { std::vector enums; @@ -98,7 +92,6 @@ std::vector SortedEnums( for (int i = 0; i < file->message_type_count(); i++) { AddEnums(file->message_type(i), &enums); } - SortDefs(&enums); return enums; }