Test for def_to_proto is working.

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;

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 **************************************************************/
 

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<upb_symtab, decltype(&upb_symtab_free)> ptr_;
 };
 
+inline FileDefPtr MessageDefPtr::file() const {
+  return FileDefPtr(upb_msgdef_file(ptr_));
+}
+
 inline MessageDefPtr FieldDefPtr::message_subdef() const {
   return MessageDefPtr(upb_fielddef_msgsubdef(ptr_));
 }

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",

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;
 }
 

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";

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";

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<google::protobuf::Message> 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::protobuf::Message> 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<google::protobuf::Message> m1(
+      ToProto(proto, msgdef.ptr(), desc, &factory));
+  std::unique_ptr<google::protobuf::Message> 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);
+}

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;
+}

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";

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";

upbc/protoc-gen-upb.cc

@@ -83,12 +83,6 @@ void AddEnums(const protobuf::Descriptor* message,
   }
 }
 
-template <class T>
-void SortDefs(std::vector<T>* defs) {
-  std::sort(defs->begin(), defs->end(),
-            [](T a, T b) { return a->full_name() < b->full_name(); });
-}
-
 std::vector<const protobuf::EnumDescriptor*> SortedEnums(
     const protobuf::FileDescriptor* file) {
   std::vector<const protobuf::EnumDescriptor*> enums;
@@ -98,7 +92,6 @@ std::vector<const protobuf::EnumDescriptor*> SortedEnums(
   for (int i = 0; i < file->message_type_count(); i++) {
     AddEnums(file->message_type(i), &enums);
   }
-  SortDefs(&enums);
   return enums;
 }