Remove struct keyword from all types, use typedef instead.

1 files changed, 118 insertions, 132 deletions

diff --git a/src/upb_def.c b/src/upb_def.c
index 2ab1d11..7c9777d 100644
--- a/src/upb_def.c
+++ b/src/upb_def.c
@@ -56,11 +56,11 @@ static int div_round_up(int numerator, int denominator) {
 // This algorithm is relatively cheap, since it only requires extra work when
 // the external refcount on a cyclic type transitions from 0->1 or 1->0.
 
-static void msgdef_free(struct upb_msgdef *m);
-static void enumdef_free(struct upb_enumdef *e);
-static void unresolveddef_free(struct upb_unresolveddef *u);
+static void msgdef_free(upb_msgdef *m);
+static void enumdef_free(upb_enumdef *e);
+static void unresolveddef_free(struct _upb_unresolveddef *u);
 
-static void def_free(struct upb_def *def)
+static void def_free(upb_def *def)
 {
   switch(def->type) {
     case UPB_DEF_MSG:
@@ -91,9 +91,8 @@ static void def_free(struct upb_def *def)
 // search so we can stop the search if we detect a cycles that do not involve
 // cycle_base.  We can't color the nodes as we go by writing to a member of the
 // def, because another thread could be performing the search concurrently.
-static int cycle_ref_or_unref(struct upb_msgdef *m,
-                              struct upb_msgdef *cycle_base,
-                              struct upb_msgdef **open_defs, int num_open_defs,
+static int cycle_ref_or_unref(upb_msgdef *m, upb_msgdef *cycle_base,
+                              upb_msgdef **open_defs, int num_open_defs,
                               bool ref) {
   bool found = false;
   for(int i = 0; i < num_open_defs; i++) {
@@ -116,10 +115,10 @@ static int cycle_ref_or_unref(struct upb_msgdef *m,
       open_defs[num_open_defs++] = m;
     }
     for(int i = 0; i < m->num_fields; i++) {
-      struct upb_fielddef *f = &m->fields[i];
-      struct upb_def *def = f->def;
+      upb_fielddef *f = &m->fields[i];
+      upb_def *def = f->def;
       if(upb_issubmsg(f) && def->is_cyclic) {
-        struct upb_msgdef *sub_m = upb_downcast_msgdef(def);
+        upb_msgdef *sub_m = upb_downcast_msgdef(def);
         path_count += cycle_ref_or_unref(sub_m, cycle_base, open_defs,
                                          num_open_defs, ref);
       }
@@ -134,22 +133,22 @@ static int cycle_ref_or_unref(struct upb_msgdef *m,
   }
 }
 
-void _upb_def_reftozero(struct upb_def *def) {
+void _upb_def_reftozero(upb_def *def) {
   if(def->is_cyclic) {
-    struct upb_msgdef *m = upb_downcast_msgdef(def);
-    struct upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN];
+    upb_msgdef *m = upb_downcast_msgdef(def);
+    upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN];
     cycle_ref_or_unref(m, NULL, open_defs, 0, false);
   } else {
     def_free(def);
   }
 }
 
-void _upb_def_cyclic_ref(struct upb_def *def) {
-  struct upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN];
+void _upb_def_cyclic_ref(upb_def *def) {
+  upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN];
   cycle_ref_or_unref(upb_downcast_msgdef(def), NULL, open_defs, 0, true);
 }
 
-static void upb_def_init(struct upb_def *def, enum upb_def_type type,
+static void upb_def_init(upb_def *def, enum upb_def_type type,
                          upb_strptr fqname) {
   def->type = type;
   def->is_cyclic = 0;  // We detect this later, after resolving refs.
@@ -158,26 +157,26 @@ static void upb_def_init(struct upb_def *def, enum upb_def_type type,
   upb_atomic_refcount_init(&def->refcount, 1);
 }
 
-static void upb_def_uninit(struct upb_def *def) {
+static void upb_def_uninit(upb_def *def) {
   upb_string_unref(def->fqname);
 }
 
 /* upb_unresolveddef **********************************************************/
 
-struct upb_unresolveddef {
-  struct upb_def base;
+typedef struct _upb_unresolveddef {
+  upb_def base;
   upb_strptr name;
-};
+} upb_unresolveddef;
 
-static struct upb_unresolveddef *upb_unresolveddef_new(upb_strptr str) {
-  struct upb_unresolveddef *def = malloc(sizeof(*def));
+static upb_unresolveddef *upb_unresolveddef_new(upb_strptr str) {
+  upb_unresolveddef *def = malloc(sizeof(*def));
   upb_strptr name = upb_string_getref(str, UPB_REF_THREADUNSAFE_READONLY);
   upb_def_init(&def->base, UPB_DEF_UNRESOLVED, name);
   def->name = name;
   return def;
 }
 
-static void unresolveddef_free(struct upb_unresolveddef *def) {
+static void unresolveddef_free(struct _upb_unresolveddef *def) {
   upb_string_unref(def->name);
   upb_def_uninit(&def->base);
   free(def);
@@ -185,7 +184,7 @@ static void unresolveddef_free(struct upb_unresolveddef *def) {
 
 /* upb_fielddef ***************************************************************/
 
-static void fielddef_init(struct upb_fielddef *f,
+static void fielddef_init(upb_fielddef *f,
                           google_protobuf_FieldDescriptorProto *fd)
 {
   f->type = fd->type;
@@ -201,14 +200,14 @@ static void fielddef_init(struct upb_fielddef *f,
   }
 }
 
-static struct upb_fielddef *fielddef_new(
-    google_protobuf_FieldDescriptorProto *fd) {
-  struct upb_fielddef *f = malloc(sizeof(*f));
+static upb_fielddef *fielddef_new(google_protobuf_FieldDescriptorProto *fd)
+{
+  upb_fielddef *f = malloc(sizeof(*f));
   fielddef_init(f, fd);
   return f;
 }
 
-static void fielddef_uninit(struct upb_fielddef *f)
+static void fielddef_uninit(upb_fielddef *f)
 {
   upb_string_unref(f->name);
   if(upb_hasdef(f) && f->owned) {
@@ -216,12 +215,12 @@ static void fielddef_uninit(struct upb_fielddef *f)
   }
 }
 
-static void fielddef_free(struct upb_fielddef *f) {
+static void fielddef_free(upb_fielddef *f) {
   fielddef_uninit(f);
   free(f);
 }
 
-static void fielddef_copy(struct upb_fielddef *dst, struct upb_fielddef *src)
+static void fielddef_copy(upb_fielddef *dst, upb_fielddef *src)
 {
   *dst = *src;
   dst->name = upb_string_getref(src->name, UPB_REF_FROZEN);
@@ -232,7 +231,7 @@ static void fielddef_copy(struct upb_fielddef *dst, struct upb_fielddef *src)
 }
 
 // Callback for sorting fields.
-static int compare_fields(struct upb_fielddef *f1, struct upb_fielddef *f2) {
+static int compare_fields(upb_fielddef *f1, upb_fielddef *f2) {
   // Required fields go before non-required.
   bool req1 = f1->label == GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_REQUIRED;
   bool req2 = f2->label == GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_REQUIRED;
@@ -250,7 +249,7 @@ static int compare_fielddefs(const void *e1, const void *e2) {
 }
 
 static int compare_fds(const void *e1, const void *e2) {
-  struct upb_fielddef f1, f2;
+  upb_fielddef f1, f2;
   fielddef_init(&f1, *(void**)e1);
   fielddef_init(&f2, *(void**)e2);
   int ret = compare_fields(&f1, &f2);
@@ -264,17 +263,15 @@ void upb_fielddef_sortfds(google_protobuf_FieldDescriptorProto **fds, size_t num
   qsort(fds, num, sizeof(*fds), compare_fds);
 }
 
-static void fielddef_sort(struct upb_fielddef **defs, size_t num)
+static void fielddef_sort(upb_fielddef **defs, size_t num)
 {
   qsort(defs, num, sizeof(*defs), compare_fielddefs);
 }
 
 /* upb_msgdef *****************************************************************/
 
-static struct upb_msgdef *msgdef_new(struct upb_fielddef **fields,
-                                     int num_fields,
-                                     upb_strptr fqname,
-                                     struct upb_status *status)
+static upb_msgdef *msgdef_new(upb_fielddef **fields, int num_fields,
+                              upb_strptr fqname, upb_status *status)
 {
   if(num_fields > UPB_MAX_FIELDS) {
     upb_seterr(status, UPB_STATUS_ERROR,
@@ -282,23 +279,23 @@ static struct upb_msgdef *msgdef_new(struct upb_fielddef **fields,
     free(fields);
     return NULL;
   }
-  struct upb_msgdef *m = malloc(sizeof(*m));
+  upb_msgdef *m = malloc(sizeof(*m));
   upb_def_init(&m->base, UPB_DEF_MSG, fqname);
   upb_atomic_refcount_init(&m->cycle_refcount, 0);
-  upb_inttable_init(&m->itof, num_fields, sizeof(struct upb_itof_ent));
-  upb_strtable_init(&m->ntof, num_fields, sizeof(struct upb_ntof_ent));
+  upb_inttable_init(&m->itof, num_fields, sizeof(upb_itof_ent));
+  upb_strtable_init(&m->ntof, num_fields, sizeof(upb_ntof_ent));
 
   m->num_fields = num_fields;
   m->set_flags_bytes = div_round_up(m->num_fields, 8);
   // These are incremented in the loop.
   m->num_required_fields = 0;
   m->size = m->set_flags_bytes + 4;  // 4 for the refcount.
-  m->fields = malloc(sizeof(struct upb_fielddef) * num_fields);
+  m->fields = malloc(sizeof(upb_fielddef) * num_fields);
 
   size_t max_align = 0;
   for(int i = 0; i < num_fields; i++) {
-    struct upb_fielddef *f = &m->fields[i];
-    struct upb_type_info *type_info = &upb_type_info[fields[i]->type];
+    upb_fielddef *f = &m->fields[i];
+    upb_type_info *type_info = &upb_types[fields[i]->type];
     fielddef_copy(f, fields[i]);
 
     // General alignment rules are: each member must be at an address that is a
@@ -316,8 +313,8 @@ static struct upb_msgdef *msgdef_new(struct upb_fielddef **fields,
     }
 
     // Insert into the tables.
-    struct upb_itof_ent itof_ent = {{f->number, 0}, f};
-    struct upb_ntof_ent ntof_ent = {{f->name, 0}, f};
+    upb_itof_ent itof_ent = {{f->number, 0}, f};
+    upb_ntof_ent ntof_ent = {{f->name, 0}, f};
     upb_inttable_insert(&m->itof, &itof_ent.e);
     upb_strtable_insert(&m->ntof, &ntof_ent.e);
   }
@@ -326,7 +323,7 @@ static struct upb_msgdef *msgdef_new(struct upb_fielddef **fields,
   return m;
 }
 
-static void msgdef_free(struct upb_msgdef *m)
+static void msgdef_free(upb_msgdef *m)
 {
   for (upb_field_count_t i = 0; i < m->num_fields; i++)
     fielddef_uninit(&m->fields[i]);
@@ -337,8 +334,7 @@ static void msgdef_free(struct upb_msgdef *m)
   free(m);
 }
 
-static void upb_msgdef_resolve(struct upb_msgdef *m, struct upb_fielddef *f,
-                               struct upb_def *def) {
+static void upb_msgdef_resolve(upb_msgdef *m, upb_fielddef *f, upb_def *def) {
   (void)m;
   if(f->owned) upb_def_unref(f->def);
   f->def = def;
@@ -349,75 +345,75 @@ static void upb_msgdef_resolve(struct upb_msgdef *m, struct upb_fielddef *f,
 
 /* upb_enumdef ****************************************************************/
 
-struct ntoi_ent {
-  struct upb_strtable_entry e;
+typedef struct {
+  upb_strtable_entry e;
   uint32_t value;
-};
+} ntoi_ent;
 
-struct iton_ent {
-  struct upb_inttable_entry e;
+typedef struct {
+  upb_inttable_entry e;
   upb_strptr string;
-};
+} iton_ent;
 
-static struct upb_enumdef *enumdef_new(google_protobuf_EnumDescriptorProto *ed,
-                                       upb_strptr fqname)
+static upb_enumdef *enumdef_new(google_protobuf_EnumDescriptorProto *ed,
+                                upb_strptr fqname)
 {
-  struct upb_enumdef *e = malloc(sizeof(*e));
+  upb_enumdef *e = malloc(sizeof(*e));
   upb_def_init(&e->base, UPB_DEF_ENUM, fqname);
   int num_values = ed->set_flags.has.value ?
       google_protobuf_EnumValueDescriptorProto_array_len(ed->value) : 0;
-  upb_strtable_init(&e->ntoi, num_values, sizeof(struct ntoi_ent));
-  upb_inttable_init(&e->iton, num_values, sizeof(struct iton_ent));
+  upb_strtable_init(&e->ntoi, num_values, sizeof(ntoi_ent));
+  upb_inttable_init(&e->iton, num_values, sizeof(iton_ent));
 
   for(int i = 0; i < num_values; i++) {
     google_protobuf_EnumValueDescriptorProto *value =
         google_protobuf_EnumValueDescriptorProto_array_get(ed->value, i);
-    struct ntoi_ent ntoi_ent = {{value->name, 0}, value->number};
-    struct iton_ent iton_ent = {{value->number, 0}, value->name};
+    ntoi_ent ntoi_ent = {{value->name, 0}, value->number};
+    iton_ent iton_ent = {{value->number, 0}, value->name};
     upb_strtable_insert(&e->ntoi, &ntoi_ent.e);
     upb_inttable_insert(&e->iton, &iton_ent.e);
   }
   return e;
 }
 
-static void enumdef_free(struct upb_enumdef *e) {
+static void enumdef_free(upb_enumdef *e) {
   upb_strtable_free(&e->ntoi);
   upb_inttable_free(&e->iton);
   upb_def_uninit(&e->base);
   free(e);
 }
 
-static void fill_iter(struct upb_enum_iter *iter, struct ntoi_ent *ent) {
+static void fill_iter(upb_enum_iter *iter, ntoi_ent *ent) {
   iter->state = ent;
   iter->name = ent->e.key;
   iter->val = ent->value;
 }
 
-void upb_enum_begin(struct upb_enum_iter *iter, struct upb_enumdef *e) {
+void upb_enum_begin(upb_enum_iter *iter, upb_enumdef *e) {
   // We could iterate over either table here; the choice is arbitrary.
-  struct ntoi_ent *ent = upb_strtable_begin(&e->ntoi);
+  ntoi_ent *ent = upb_strtable_begin(&e->ntoi);
   iter->e = e;
   fill_iter(iter, ent);
 }
 
-void upb_enum_next(struct upb_enum_iter *iter) {
-  struct ntoi_ent *ent = iter->state;
+void upb_enum_next(upb_enum_iter *iter) {
+  ntoi_ent *ent = iter->state;
   assert(ent);
   ent = upb_strtable_next(&iter->e->ntoi, &ent->e);
   iter->state = ent;
   if(ent) fill_iter(iter, ent);
 }
 
-bool upb_enum_done(struct upb_enum_iter *iter) {
+bool upb_enum_done(upb_enum_iter *iter) {
   return iter->state == NULL;
 }
 
 /* symtab internal  ***********************************************************/
 
-struct symtab_ent {
-  struct upb_strtable_entry e;
-  struct upb_def *def;
-};
+typedef struct {
+  upb_strtable_entry e;
+  upb_def *def;
+} symtab_ent;
 
 /* Search for a character in a string, in reverse. */
 static int my_memrchr(char *data, char c, size_t len)
@@ -429,9 +425,7 @@ static int my_memrchr(char *data, char c, size_t len)
 
 /* Given a symbol and the base symbol inside which it is defined, find the
  * symbol's definition in t. */
-static struct symtab_ent *resolve(struct upb_strtable *t,
-                                  upb_strptr base,
-                                  upb_strptr symbol)
+static symtab_ent *resolve(upb_strtable *t, upb_strptr base, upb_strptr symbol)
 {
   if(upb_strlen(base) + upb_strlen(symbol) + 1 >= UPB_SYMBOL_MAXLEN ||
      upb_strlen(symbol) == 0) return NULL;
@@ -440,7 +434,7 @@ static struct symtab_ent *resolve(struct upb_strtable *t,
     // Symbols starting with '.' are absolute, so we do a single lookup.
     // Slice to omit the leading '.'
     upb_strptr sym_str = upb_strslice(symbol, 1, INT_MAX);
-    struct symtab_ent *e = upb_strtable_lookup(t, sym_str);
+    symtab_ent *e = upb_strtable_lookup(t, sym_str);
     upb_string_unref(sym_str);
     return e;
   } else {
@@ -455,7 +449,7 @@ static struct symtab_ent *resolve(struct upb_strtable *t,
       buf[baselen] = UPB_SYMBOL_SEPARATOR;
       memcpy(buf + baselen + 1, upb_string_getrobuf(symbol), upb_strlen(symbol));
 
-      struct symtab_ent *e = upb_strtable_lookup(t, sym_str);
+      symtab_ent *e = upb_strtable_lookup(t, sym_str);
       if (e) return e;
       else if(baselen == 0) return NULL;  /* No more scopes to try. */
 
@@ -478,8 +472,8 @@ static upb_strptr join(upb_strptr base, upb_strptr name) {
   return joined;
 }
 
-static upb_strptr try_define(struct upb_strtable *t, upb_strptr base,
-                              upb_strptr name, struct upb_status *status)
+static upb_strptr try_define(upb_strtable *t, upb_strptr base,
+                             upb_strptr name, upb_status *status)
 {
   if(upb_string_isnull(name)) {
     upb_seterr(status, UPB_STATUS_ERROR,
@@ -498,26 +492,23 @@ static upb_strptr try_define(struct upb_strtable *t, upb_strptr base,
   return fqname;
 }
 
-static void insert_enum(struct upb_strtable *t,
+static void insert_enum(upb_strtable *t,
                         google_protobuf_EnumDescriptorProto *ed,
-                        upb_strptr base,
-                        struct upb_status *status)
+                        upb_strptr base, upb_status *status)
 {
   upb_strptr name = ed->set_flags.has.name ? ed->name : UPB_STRING_NULL;
   upb_strptr fqname = try_define(t, base, name, status);
   if(upb_string_isnull(fqname)) return;
 
-  struct symtab_ent e;
+  symtab_ent e;
   e.e.key = fqname;
   e.def = UPB_UPCAST(enumdef_new(ed, fqname));
   upb_strtable_insert(t, &e.e);
   upb_string_unref(fqname);
 }
 
-static void insert_message(struct upb_strtable *t,
-                           google_protobuf_DescriptorProto *d,
-                           upb_strptr base, bool sort,
-                           struct upb_status *status)
+static void insert_message(upb_strtable *t, google_protobuf_DescriptorProto *d,
+                           upb_strptr base, bool sort, upb_status *status)
 {
   upb_strptr name = d->set_flags.has.name ? d->name : UPB_STRING_NULL;
   upb_strptr fqname = try_define(t, base, name, status);
@@ -525,11 +516,11 @@ static void insert_message(struct upb_strtable *t,
 
   int num_fields = d->set_flags.has.field ?
       google_protobuf_FieldDescriptorProto_array_len(d->field) : 0;
-  struct symtab_ent e;
+  symtab_ent e;
   e.e.key = fqname;
 
   // Gather our list of fields, sorting if necessary.
-  struct upb_fielddef **fielddefs = malloc(sizeof(*fielddefs) * num_fields);
+  upb_fielddef **fielddefs = malloc(sizeof(*fielddefs) * num_fields);
   for (int i = 0; i < num_fields; i++) {
     google_protobuf_FieldDescriptorProto *fd =
         google_protobuf_FieldDescriptorProto_array_get(d->field, i);
@@ -562,8 +553,7 @@ error:
   upb_string_unref(fqname);
 }
 
-static bool find_cycles(struct upb_msgdef *m, int search_depth,
-                        struct upb_status *status)
+static bool find_cycles(upb_msgdef *m, int search_depth, upb_status *status)
 {
   if(search_depth > UPB_MAX_TYPE_DEPTH) {
     // There are many situations in upb where we recurse over the type tree
@@ -592,10 +582,10 @@ static bool find_cycles(struct upb_msgdef *m, int search_depth,
     UPB_UPCAST(m)->search_depth = ++search_depth;
     bool cycle_found = false;
     for(upb_field_count_t i = 0; i < m->num_fields; i++) {
-      struct upb_fielddef *f = &m->fields[i];
+      upb_fielddef *f = &m->fields[i];
       if(!upb_issubmsg(f)) continue;
-      struct upb_def *sub_def = f->def;
-      struct upb_msgdef *sub_m = upb_downcast_msgdef(sub_def);
+      upb_def *sub_def = f->def;
+      upb_msgdef *sub_m = upb_downcast_msgdef(sub_def);
       if(find_cycles(sub_m, search_depth, status)) {
         cycle_found = true;
         UPB_UPCAST(m)->is_cyclic = true;
@@ -610,9 +600,9 @@ static bool find_cycles(struct upb_msgdef *m, int search_depth,
   }
 }
 
-static void addfd(struct upb_strtable *addto, struct upb_strtable *existingdefs,
+static void addfd(upb_strtable *addto, upb_strtable *existingdefs,
                   google_protobuf_FileDescriptorProto *fd, bool sort,
-                  struct upb_status *status)
+                  upb_status *status)
 {
   upb_strptr pkg;
   if(fd->set_flags.has.package) {
@@ -639,16 +629,16 @@ static void addfd(struct upb_strtable *addto, struct upb_strtable *existingdefs,
   /* TODO: handle extensions and services. */
 
   // Attempt to resolve all references.
-  struct symtab_ent *e;
+  symtab_ent *e;
   for(e = upb_strtable_begin(addto); e; e = upb_strtable_next(addto, &e->e)) {
-    struct upb_msgdef *m = upb_dyncast_msgdef(e->def);
+    upb_msgdef *m = upb_dyncast_msgdef(e->def);
     if(!m) continue;
     upb_strptr base = e->e.key;
     for(upb_field_count_t i = 0; i < m->num_fields; i++) {
-      struct upb_fielddef *f = &m->fields[i];
+      upb_fielddef *f = &m->fields[i];
       if(!upb_hasdef(f)) continue;  // No resolving necessary.
       upb_strptr name = upb_downcast_unresolveddef(f->def)->name;
-      struct symtab_ent *found = resolve(existingdefs, base, name);
+      symtab_ent *found = resolve(existingdefs, base, name);
       if(!found) found = resolve(addto, base, name);
       upb_field_type_t expected = upb_issubmsg(f) ? UPB_DEF_MSG : UPB_DEF_ENUM;
       if(!found) {
@@ -667,33 +657,33 @@ static void addfd(struct upb_strtable *addto, struct upb_strtable *existingdefs,
 
   // Deal with type cycles.
   for(e = upb_strtable_begin(addto); e; e = upb_strtable_next(addto, &e->e)) {
-    struct upb_msgdef *m = upb_dyncast_msgdef(e->def);
+    upb_msgdef *m = upb_dyncast_msgdef(e->def);
     if(!m) continue;
 
     // Do an initial pass over the graph to check that there are no cycles
     // longer than the maximum length.  We also mark all cyclic defs as such,
     // and decrement refs on cyclic defs.
     find_cycles(m, 0, status);
-    struct upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN];
+    upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN];
     cycle_ref_or_unref(m, NULL, open_defs, 0, true);
   }
 }
 
 /* upb_symtab *****************************************************************/
 
-struct upb_symtab *upb_symtab_new()
+upb_symtab *upb_symtab_new()
 {
-  struct upb_symtab *s = malloc(sizeof(*s));
+  upb_symtab *s = malloc(sizeof(*s));
   upb_atomic_refcount_init(&s->refcount, 1);
   upb_rwlock_init(&s->lock);
-  upb_strtable_init(&s->symtab, 16, sizeof(struct symtab_ent));
-  upb_strtable_init(&s->psymtab, 16, sizeof(struct symtab_ent));
+  upb_strtable_init(&s->symtab, 16, sizeof(symtab_ent));
+  upb_strtable_init(&s->psymtab, 16, sizeof(symtab_ent));
 
   // Add descriptor.proto types to private symtable so we can parse descriptors.
   // We know there is only 1.
   google_protobuf_FileDescriptorProto *fd =
       google_protobuf_FileDescriptorProto_array_get(upb_file_descriptor_set->file, 0);
-  struct upb_status status = UPB_STATUS_INIT;
+  upb_status status = UPB_STATUS_INIT;
   addfd(&s->psymtab, &s->symtab, fd, false, &status);
   if(!upb_ok(&status)) {
     fprintf(stderr, "Failed to initialize upb: %s.\n", status.msg);
@@ -703,21 +693,21 @@ struct upb_symtab *upb_symtab_new()
   upb_static_string name =
       UPB_STATIC_STRING_INIT("google.protobuf.FileDescriptorSet");
   upb_strptr nameptr = UPB_STATIC_STRING_PTR_INIT(name);
-  struct symtab_ent *e = upb_strtable_lookup(&s->psymtab, nameptr);
+  symtab_ent *e = upb_strtable_lookup(&s->psymtab, nameptr);
   assert(e);
   s->fds_msgdef = upb_downcast_msgdef(e->def);
   return s;
 }
 
-static void free_symtab(struct upb_strtable *t)
+static void free_symtab(upb_strtable *t)
 {
-  struct symtab_ent *e = upb_strtable_begin(t);
-  for(; e; e = upb_strtable_next(t, &e->e))
+  symtab_ent *e;
+  for(e = upb_strtable_begin(t); e; e = upb_strtable_next(t, &e->e))
     upb_def_unref(e->def);
   upb_strtable_free(t);
 }
 
-void _upb_symtab_free(struct upb_symtab *s)
+void _upb_symtab_free(upb_symtab *s)
 {
   free_symtab(&s->symtab);
   free_symtab(&s->psymtab);
@@ -725,18 +715,17 @@ void _upb_symtab_free(struct upb_symtab *s)
   free(s);
 }
 
-struct upb_def **upb_symtab_getdefs(struct upb_symtab *s, int *count,
-                                    upb_def_type_t type)
+upb_def **upb_symtab_getdefs(upb_symtab *s, int *count, upb_def_type_t type)
 {
   upb_rwlock_rdlock(&s->lock);
   int total = upb_strtable_count(&s->symtab);
   // We may only use part of this, depending on how many symbols are of the
   // correct type.
-  struct upb_def **defs = malloc(sizeof(*defs) * total);
-  struct symtab_ent *e = upb_strtable_begin(&s->symtab);
+  upb_def **defs = malloc(sizeof(*defs) * total);
+  symtab_ent *e = upb_strtable_begin(&s->symtab);
   int i = 0;
   for(; e; e = upb_strtable_next(&s->symtab, &e->e)) {
-    struct upb_def *def = e->def;
+    upb_def *def = e->def;
     assert(def);
     if(type == UPB_DEF_ANY || def->type == type)
       defs[i++] = def;
@@ -748,11 +737,11 @@ struct upb_def **upb_symtab_getdefs(struct upb_symtab *s, int *count,
   return defs;
 }
 
-struct upb_def *upb_symtab_lookup(struct upb_symtab *s, upb_strptr sym)
+upb_def *upb_symtab_lookup(upb_symtab *s, upb_strptr sym)
 {
   upb_rwlock_rdlock(&s->lock);
-  struct symtab_ent *e = upb_strtable_lookup(&s->symtab, sym);
-  struct upb_def *ret = NULL;
+  symtab_ent *e = upb_strtable_lookup(&s->symtab, sym);
+  upb_def *ret = NULL;
   if(e) {
     ret = e->def;
     upb_def_ref(ret);
@@ -762,11 +751,10 @@ struct upb_def *upb_symtab_lookup(struct upb_symtab *s, upb_strptr sym)
 }
 
 
-struct upb_def *upb_symtab_resolve(struct upb_symtab *s, upb_strptr base,
-                                   upb_strptr symbol) {
+upb_def *upb_symtab_resolve(upb_symtab *s, upb_strptr base, upb_strptr symbol) {
   upb_rwlock_rdlock(&s->lock);
-  struct symtab_ent *e = resolve(&s->symtab, base, symbol);
-  struct upb_def *ret = NULL;
+  symtab_ent *e = resolve(&s->symtab, base, symbol);
+  upb_def *ret = NULL;
   if(e) {
     ret = e->def;
     upb_def_ref(ret);
@@ -775,15 +763,14 @@ struct upb_def *upb_symtab_resolve(struct upb_symtab *s, upb_strptr base,
   return ret;
 }
 
-void upb_symtab_addfds(struct upb_symtab *s,
-                        google_protobuf_FileDescriptorSet *fds,
-                        struct upb_status *status)
+void upb_symtab_addfds(upb_symtab *s, google_protobuf_FileDescriptorSet *fds,
+                       upb_status *status)
 {
   if(fds->set_flags.has.file) {
     // Insert new symbols into a temporary table until we have verified that
     // the descriptor is valid.
-    struct upb_strtable tmp;
-    upb_strtable_init(&tmp, 0, sizeof(struct symtab_ent));
+    upb_strtable tmp;
+    upb_strtable_init(&tmp, 0, sizeof(symtab_ent));
 
     {  // Read lock scope
       upb_rwlock_rdlock(&s->lock);
@@ -801,7 +788,7 @@ void upb_symtab_addfds(struct upb_symtab *s,
     // Everything was successfully added, copy from the tmp symtable.
     {  // Write lock scope
       upb_rwlock_wrlock(&s->lock);
-      struct symtab_ent *e;
+      symtab_ent *e;
       for(e = upb_strtable_begin(&tmp); e; e = upb_strtable_next(&tmp, &e->e)) {
         // We checked for duplicates when we had only the read lock, but it is
         // theoretically possible that a duplicate symbol when we dropped the
@@ -825,8 +812,7 @@ void upb_symtab_addfds(struct upb_symtab *s,
   return;
 }
 
-void upb_symtab_add_desc(struct upb_symtab *s, upb_strptr desc,
-                         struct upb_status *status)
+void upb_symtab_add_desc(upb_symtab *s, upb_strptr desc, upb_status *status)
 {
   upb_msg *fds = upb_msg_new(s->fds_msgdef);
   upb_msg_decodestr(fds, s->fds_msgdef, desc, status);