Added upb::FileDef, which represents the file defs are declared in.

It is entirely optional: MessageDef/EnumDef can still exist
on their own.  But this can represent a def's file when it is
desirable to do so (eg. for code generators).

This approach will require that we change the way we handle
extensions.  But I think it will be a good change overall.

Specifically, we previously handled extensions by duplicating
the extended message and then adding the extension as a regular
field to the duplicated message.  This required also duplicating
any messages that could reach the extended message.

In the new world we will need a way of declaring and looking up
extensions separately from the message being extended.

This change also involves some notable changes to the generated
code:

- files are now called foo.upbdefs.h instead of foo.upb.h.
  This reflects the fact that we might possibly generate several
  different output files for a .proto file, and this one is just
  for defs.

- we no longer generate selectors in the .h file.

- the upbdefs.c no longer vends a SymbolTable.  Now it vends the
  individual messages (and possibly a FileDef later).  I think this
  will compose better once we can generate files where one
  generated files imports another.

We also make the descriptor reader vend a list of FileDefs now.
This is the best conceptual match for parsing a FileDescriptorSet.

4 files changed, 73 insertions, 13 deletions

diff --git a/tests/pb/test_encoder.cc b/tests/pb/test_encoder.cc
index 8a222f4..6dd10ba 100644
--- a/tests/pb/test_encoder.cc
+++ b/tests/pb/test_encoder.cc
@@ -1,11 +1,31 @@
 
 #include "tests/upb_test.h"
 #include "upb/bindings/stdc++/string.h"
-#include "upb/descriptor/descriptor.upb.h"
+#include "upb/descriptor/descriptor.upbdefs.h"
 #include "upb/pb/decoder.h"
 #include "upb/pb/encoder.h"
 #include "upb/pb/glue.h"
 
+static char *upb_readfile(const char *filename, size_t *len) {
+  long size;
+  char *buf;
+  FILE *f = fopen(filename, "rb");
+  if(!f) return NULL;
+  if(fseek(f, 0, SEEK_END) != 0) goto error;
+  size = ftell(f);
+  if(size < 0) goto error;
+  if(fseek(f, 0, SEEK_SET) != 0) goto error;
+  buf = (char*)malloc(size + 1);
+  if(size && fread(buf, size, 1, f) != 1) goto error;
+  fclose(f);
+  if (len) *len = size;
+  return buf;
+
+error:
+  fclose(f);
+  return NULL;
+}
+
 std::string read_string(const char *filename) {
   size_t len;
   char *str = upb_readfile(filename, &len);
@@ -18,7 +38,7 @@ std::string read_string(const char *filename) {
 
 void test_pb_roundtrip() {
   upb::reffed_ptr<const upb::MessageDef> md(
-      upbdefs::google::protobuf::FileDescriptorSet::MessageDef());
+      upbdefs::google::protobuf::FileDescriptorSet::get());
   upb::reffed_ptr<const upb::Handlers> encoder_handlers(
       upb::pb::Encoder::NewHandlers(md.get()));
   upb::reffed_ptr<const upb::pb::DecoderMethod> method(
diff --git a/tests/test_cpp.cc b/tests/test_cpp.cc
index 48f0a3f..c27526b 100644
--- a/tests/test_cpp.cc
+++ b/tests/test_cpp.cc
@@ -6,6 +6,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <fstream>
 #include <iostream>
 #include <set>
 #include <sstream>
@@ -144,12 +145,22 @@ static void TestCastsConst10() {
 }
 
 static void TestSymbolTable(const char *descriptor_file) {
-  upb::reffed_ptr<upb::SymbolTable> s(upb::SymbolTable::New());
   upb::Status status;
-  if (!upb::LoadDescriptorFileIntoSymtab(s.get(), descriptor_file, &status)) {
+  std::ifstream file_in(descriptor_file, std::ios::binary);
+  std::string descriptor((std::istreambuf_iterator<char>(file_in)),
+                         (std::istreambuf_iterator<char>()));
+  std::vector<upb::reffed_ptr<upb::FileDef> > files;
+  if (!upb::LoadDescriptor(descriptor, &status, &files)) {
     std::cerr << "Couldn't load descriptor: " << status.error_message();
     exit(1);
   }
+
+  upb::reffed_ptr<upb::SymbolTable> s(upb::SymbolTable::New());
+
+  for (size_t i = 0; i < files.size(); i++) {
+    ASSERT(s->AddFile(files[i].get(), &status));
+  }
+
   ASSERT(!s->IsFrozen());
   s->Freeze();
   ASSERT(s->IsFrozen());
diff --git a/tests/test_def.c b/tests/test_def.c
index 52d780b..6f3fb8f 100644
--- a/tests/test_def.c
+++ b/tests/test_def.c
@@ -38,15 +38,45 @@ static void test_noreftracking() {
   upb_msgdef_unref(md, &md);
 }
 
+static char *upb_readfile(const char *filename, size_t *len) {
+  long size;
+  char *buf;
+  FILE *f = fopen(filename, "rb");
+  if(!f) return NULL;
+  if(fseek(f, 0, SEEK_END) != 0) goto error;
+  size = ftell(f);
+  if(size < 0) goto error;
+  if(fseek(f, 0, SEEK_SET) != 0) goto error;
+  buf = malloc(size + 1);
+  if(size && fread(buf, size, 1, f) != 1) goto error;
+  fclose(f);
+  if (len) *len = size;
+  return buf;
+
+error:
+  fclose(f);
+  return NULL;
+}
+
 static upb_symtab *load_test_proto(void *owner) {
   upb_symtab *s = upb_symtab_new(owner);
   upb_status status = UPB_STATUS_INIT;
+  size_t len;
+  char *data = upb_readfile(descriptor_file, &len);
+  upb_filedef **files;
   ASSERT(s);
-  if (!upb_load_descriptor_file_into_symtab(s, descriptor_file, &status)) {
-    fprintf(stderr, "Error loading descriptor file: %s\n",
-            upb_status_errmsg(&status));
-    ASSERT(false);
+  ASSERT(data);
+  files = upb_loaddescriptor(data, len, &files, &status);
+  ASSERT(files);
+  free(data);
+
+  while (*files) {
+    bool ok = upb_symtab_addfile(s, *files, &status);
+    ASSERT(ok);
+    upb_filedef_unref(*files, &files);
+    files++;
   }
+
   ASSERT(!upb_symtab_isfrozen(s));
   upb_symtab_freeze(s);
   ASSERT(upb_symtab_isfrozen(s));
diff --git a/tests/test_handlers.c b/tests/test_handlers.c
index b591ad2..fe6fb82 100644
--- a/tests/test_handlers.c
+++ b/tests/test_handlers.c
@@ -1,6 +1,6 @@
 
 #include "upb/handlers.h"
-#include "upb/descriptor/descriptor.upb.h"
+#include "upb/descriptor/descriptor.upbdefs.h"
 #include "upb_test.h"
 #include <stdlib.h>
 #include <string.h>
@@ -13,10 +13,9 @@ static bool startmsg(void *c, const void *hd) {
 
 static void test_error() {
   /* Test creating handlers of a static msgdef. */
-  const upb_symtab *s = upbdefs_google_protobuf_descriptor(&s);
-  upb_handlers *h =
-      upb_handlers_new(upbdefs_google_protobuf_DescriptorProto(s), &h);
-  upb_symtab_unref(s, &s);
+  const upb_msgdef *m = upbdefs_google_protobuf_DescriptorProto_get(&m);
+  upb_handlers *h = upb_handlers_new(m, &h);
+  upb_msgdef_unref(m, &m);
 
   /* Attempt to set the same handler twice causes error. */
   ASSERT(upb_ok(upb_handlers_status(h)));