// 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 <algorithm>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <iterator>
#include <limits>
#include <map>
#include <string>
#include <utility>
#include <vector>

#include "absl/base/macros.h"
#include "absl/container/flat_hash_set.h"
#include "absl/log/absl_check.h"
#include "absl/memory/memory.h"
#include "absl/strings/escaping.h"
#include "absl/strings/match.h"
#include "absl/strings/numbers.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/string_view.h"
#include "absl/strings/substitute.h"
#include "absl/types/span.h"
#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/compiler/plugin.h"
#include "google/protobuf/io/printer.h"
#include "upb/base/descriptor_constants.h"
#include "upb/base/string_view.h"
#include "upb/mem/arena.hpp"
#include "upb/mini_table/field.h"
#include "upb/reflection/def.hpp"
#include "upb_generator/c/names.h"
#include "upb_generator/c/names_internal.h"
#include "upb_generator/common.h"
#include "upb_generator/common/names.h"
#include "upb_generator/file_layout.h"
#include "upb_generator/minitable/names.h"
#include "upb_generator/minitable/names_internal.h"
#include "upb_generator/plugin.h"

// Must be last.
#include "upb/port/def.inc"

namespace upb {
namespace generator {
namespace {

using Printer = google::protobuf::io::Printer;
using Sub = google::protobuf::io::Printer::Sub;

struct Options {
  int bootstrap_stage = -1;  // -1 means not bootstrapped.
  bool strip_nonfunctional_codegen = false;
};

class Context {
 public:
  Context(const DefPoolPair& pools, const Options& options,
          google::protobuf::io::Printer& printer)
      : pools_(pools), options_(options), printer_(printer) {}

  const DefPoolPair& pools() const { return pools_; }
  const Options& options() const { return options_; }

  // A few convenience wrappers so that users can write `ctx.Emit()` instead of
  // `ctx.printer().Emit()`.
  void Emit(absl::Span<const google::protobuf::io::Printer::Sub> vars,
            absl::string_view format,
            Printer::SourceLocation loc = Printer::SourceLocation::current()) {
    printer_.Emit(vars, format, loc);
  }

  void Emit(absl::string_view format,
            Printer::SourceLocation loc = Printer::SourceLocation::current()) {
    printer_.Emit(format, loc);
  }

 private:
  const DefPoolPair& pools_;
  const Options& options_;
  Printer& printer_;
};

// Local convenience aliases for the public names.h header files.

std::string ExtensionIdentBase(upb::FieldDefPtr field) {
  return CApiExtensionIdentBase(field.full_name());
}

std::string MessageType(upb::MessageDefPtr descriptor) {
  return CApiMessageType(descriptor.full_name());
}

std::string EnumType(upb::EnumDefPtr descriptor) {
  return CApiEnumType(descriptor.full_name());
}

std::string EnumValueSymbol(upb::EnumValDefPtr value) {
  return CApiEnumValueSymbol(value.full_name());
}

std::string SourceFilename(upb::FileDefPtr file) {
  return StripExtension(file.name()) + ".upb.c";
}

std::string MessageMiniTableRef(upb::MessageDefPtr descriptor,
                                const Options& options) {
  if (options.bootstrap_stage == 0) {
    return absl::StrCat(MiniTableMessageVarName(descriptor.full_name()), "()");
  } else {
    return absl::StrCat("&", MiniTableMessageVarName(descriptor.full_name()));
  }
}

std::string EnumMiniTableRef(upb::EnumDefPtr descriptor,
                             const Options& options) {
  if (options.bootstrap_stage == 0) {
    return absl::StrCat(MiniTableEnumVarName(descriptor.full_name()), "()");
  } else {
    return absl::StrCat("&", MiniTableEnumVarName(descriptor.full_name()));
  }
}

std::string CTypeInternal(upb::FieldDefPtr field, bool is_const) {
  std::string maybe_const = is_const ? "const " : "";
  switch (field.ctype()) {
    case kUpb_CType_Message: {
      std::string maybe_struct =
          field.file() != field.message_type().file() ? "struct " : "";
      return maybe_const + maybe_struct + MessageType(field.message_type()) +
             "*";
    }
    case kUpb_CType_Bool:
      return "bool";
    case kUpb_CType_Float:
      return "float";
    case kUpb_CType_Int32:
    case kUpb_CType_Enum:
      return "int32_t";
    case kUpb_CType_UInt32:
      return "uint32_t";
    case kUpb_CType_Double:
      return "double";
    case kUpb_CType_Int64:
      return "int64_t";
    case kUpb_CType_UInt64:
      return "uint64_t";
    case kUpb_CType_String:
    case kUpb_CType_Bytes:
      return "upb_StringView";
    default:
      abort();
  }
}

std::string FloatToCLiteral(float value) {
  if (value == std::numeric_limits<float>::infinity()) {
    return "kUpb_FltInfinity";
  } else if (value == -std::numeric_limits<float>::infinity()) {
    return "-kUpb_FltInfinity";
  } else if (std::isnan(value)) {
    return "kUpb_NaN";
  } else {
    return absl::StrCat(value);
  }
}

std::string DoubleToCLiteral(double value) {
  if (value == std::numeric_limits<double>::infinity()) {
    return "kUpb_Infinity";
  } else if (value == -std::numeric_limits<double>::infinity()) {
    return "-kUpb_Infinity";
  } else if (std::isnan(value)) {
    return "kUpb_NaN";
  } else {
    return absl::StrCat(value);
  }
}

// Escape trigraphs by escaping question marks to \?
std::string EscapeTrigraphs(absl::string_view to_escape) {
  return absl::StrReplaceAll(to_escape, {{"?", "\\?"}});
}

std::string FieldDefault(upb::FieldDefPtr field) {
  switch (field.ctype()) {
    case kUpb_CType_Message:
      return "NULL";
    case kUpb_CType_Bytes:
    case kUpb_CType_String: {
      upb_StringView str = field.default_value().str_val;
      return absl::Substitute("upb_StringView_FromString(\"$0\")",
                              EscapeTrigraphs(absl::CEscape(
                                  absl::string_view(str.data, str.size))));
    }
    case kUpb_CType_Int32:
      return absl::Substitute("(int32_t)$0", field.default_value().int32_val);
    case kUpb_CType_Int64:
      if (field.default_value().int64_val == INT64_MIN) {
        // Special-case to avoid:
        //   integer literal is too large to be represented in a signed integer
        //   type, interpreting as unsigned
        //   [-Werror,-Wimplicitly-unsigned-literal]
        //   int64_t default_val = (int64_t)-9223372036854775808ll;
        //
        // More info here: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52661
        return "INT64_MIN";
      } else {
        return absl::Substitute("(int64_t)$0ll",
                                field.default_value().int64_val);
      }
    case kUpb_CType_UInt32:
      return absl::Substitute("(uint32_t)$0u",
                              field.default_value().uint32_val);
    case kUpb_CType_UInt64:
      return absl::Substitute("(uint64_t)$0ull",
                              field.default_value().uint64_val);
    case kUpb_CType_Float:
      return FloatToCLiteral(field.default_value().float_val);
    case kUpb_CType_Double:
      return DoubleToCLiteral(field.default_value().double_val);
    case kUpb_CType_Bool:
      return field.default_value().bool_val ? "true" : "false";
    case kUpb_CType_Enum:
      // Use a number instead of a symbolic name so that we don't require
      // this enum's header to be included.
      return absl::StrCat(field.default_value().int32_val);
  }
  ABSL_ASSERT(false);
  return "XXX";
}

std::string CType(upb::FieldDefPtr field) {
  return CTypeInternal(field, false);
}

std::string CTypeConst(upb::FieldDefPtr field) {
  return CTypeInternal(field, true);
}

std::string MapKeyCType(upb::FieldDefPtr map_field) {
  return CType(map_field.message_type().map_key());
}

std::string MapValueCType(upb::FieldDefPtr map_field) {
  return CType(map_field.message_type().map_value());
}

std::string MapValueCTypeConst(upb::FieldDefPtr map_field) {
  return CTypeConst(map_field.message_type().map_value());
}

std::string MapKeyValueSize(upb_CType ctype, absl::string_view expr) {
  return ctype == kUpb_CType_String || ctype == kUpb_CType_Bytes
             ? "0"
             : absl::StrCat("sizeof(", expr, ")");
}

std::string MapKeySize(upb::FieldDefPtr map_field, absl::string_view expr) {
  const upb_CType ctype = map_field.message_type().map_key().ctype();
  return MapKeyValueSize(ctype, expr);
}

std::string MapValueSize(upb::FieldDefPtr map_field, absl::string_view expr) {
  const upb_CType ctype = map_field.message_type().map_value().ctype();
  return MapKeyValueSize(ctype, expr);
}

std::string FieldInitializer(const DefPoolPair& pools, upb::FieldDefPtr field,
                             const Options& options);
std::string FieldInitializerStrong(const DefPoolPair& pools,
                                   upb::FieldDefPtr field,
                                   const Options& options);

void DumpEnumValues(Context& c, upb::EnumDefPtr desc) {
  std::vector<upb::EnumValDefPtr> values;
  values.reserve(desc.value_count());
  for (int i = 0; i < desc.value_count(); i++) {
    values.push_back(desc.value(i));
  }
  std::stable_sort(values.begin(), values.end(),
                   [](upb::EnumValDefPtr a, upb::EnumValDefPtr b) {
                     return a.number() < b.number();
                   });

  for (size_t i = 0; i < values.size(); i++) {
    auto value = values[i];
    c.Emit(
        {
            {"name", EnumValueSymbol(value)},
            {"number", absl::StrCat(value.number())},
            {"comma", i == values.size() - 1 ? "" : ","},
        },
        R"cc(
          $name$ = $number$$comma$
        )cc");
  }
}

std::string GetFieldRep(const DefPoolPair& pools, upb::FieldDefPtr field) {
  return upb::generator::GetFieldRep(pools.GetField32(field),
                                     pools.GetField64(field));
}

void GenerateExtensionInHeader(Context& c, upb::FieldDefPtr ext) {
  c.Emit(
      {
          {"ident_base", ExtensionIdentBase(ext)},
          {"name", ext.name()},
          {"ctype", MessageType(ext.containing_type())},
          {"ext_var", MiniTableExtensionVarName(ext.full_name())},
      },
      R"cc(
        UPB_INLINE bool $ident_base$_has_$name$(const struct $ctype$* msg) {
          return upb_Message_HasExtension((upb_Message*)msg, &$ext_var$);
        }

        UPB_INLINE void $ident_base$_clear_$name$(struct $ctype$* msg) {
          upb_Message_ClearExtension((upb_Message*)msg, &$ext_var$);
        }
      )cc");

  if (ext.IsSequence()) {
    // TODO: We need generated accessors for repeated extensions.
  } else {
    c.Emit(
        {
            {"ctype_const", CTypeConst(ext)},
            {"ident_base", ExtensionIdentBase(ext)},
            {"name", ext.name()},
            {"ctype", MessageType(ext.containing_type())},
            {"ext_var", MiniTableExtensionVarName(ext.full_name())},
            {"rep", GetFieldRep(c.pools(), ext)},
            {"default", FieldDefault(ext)},
        },
        R"cc(
          UPB_INLINE $ctype_const$
          $ident_base$_$name$(const struct $ctype$* msg) {
            const upb_MiniTableExtension* ext = &$ext_var$;
            UPB_ASSUME(upb_MiniTableField_IsScalar(&ext->UPB_PRIVATE(field)));
            UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(
                           &ext->UPB_PRIVATE(field)) == $rep$);
            $ctype_const$ default_val = $default$;
            $ctype_const$ ret;
            _upb_Message_GetExtensionField((upb_Message*)msg, ext, &default_val, &ret);
            return ret;
          }

          UPB_INLINE void $ident_base$_set_$name$(struct $ctype$* msg,
                                                  $ctype_const$ val,
                                                  upb_Arena* arena) {
            const upb_MiniTableExtension* ext = &$ext_var$;
            UPB_ASSUME(upb_MiniTableField_IsScalar(&ext->UPB_PRIVATE(field)));
            UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(
                           &ext->UPB_PRIVATE(field)) == $rep$);
            bool ok = upb_Message_SetExtension((upb_Message*)msg, ext, &val, arena);
            UPB_ASSERT(ok);
          }
        )cc");

    // Message extensions also have a Msg_mutable_foo() accessor that will
    // create the sub-message if it doesn't already exist.
    if (ext.IsSubMessage()) {
      c.Emit(
          {
              {"sub_ctype", MessageType(ext.message_type())},
              {"ident_base", ExtensionIdentBase(ext)},
              {"name", ext.name()},
              {"ctype", MessageType(ext.containing_type())},
              {"mini_table",
               MessageMiniTableRef(ext.message_type(), c.options())},
          },
          R"cc(
            UPB_INLINE struct $sub_ctype$* $ident_base$_mutable_$name$(
                struct $ctype$* msg, upb_Arena* arena) {
              struct $sub_ctype$* sub = (struct $sub_ctype$*)$ident_base$_$name$(msg);
              if (sub == NULL) {
                sub = (struct $sub_ctype$*)_upb_Message_New($mini_table$, arena);
                if (sub) $ident_base$_set_$name$(msg, sub, arena);
              }
              return sub;
            }
          )cc");
    }
  }
}

void GenerateMessageFunctionsInHeader(Context& c, upb::MessageDefPtr message) {
  // TODO: The generated code here does not check the return values
  // from upb_Encode(). How can we even fix this without breaking other things?
  c.Emit(
      {
          {"msg_type", MessageType(message)},
          {"mini_table", MessageMiniTableRef(message, c.options())},
      },
      R"cc(
        UPB_INLINE $msg_type$* $msg_type$_new(upb_Arena* arena) {
          return ($msg_type$*)_upb_Message_New($mini_table$, arena);
        }
        UPB_INLINE $msg_type$* $msg_type$_parse(const char* buf, size_t size,
                                                upb_Arena* arena) {
          $msg_type$* ret = $msg_type$_new(arena);
          if (!ret) return NULL;
          if (upb_Decode(buf, size, UPB_UPCAST(ret), $mini_table$, NULL, 0,
                         arena) != kUpb_DecodeStatus_Ok) {
            return NULL;
          }
          return ret;
        }
        UPB_INLINE $msg_type$* $msg_type$_parse_ex(
            const char* buf, size_t size, const upb_ExtensionRegistry* extreg,
            int options, upb_Arena* arena) {
          $msg_type$* ret = $msg_type$_new(arena);
          if (!ret) return NULL;
          if (upb_Decode(buf, size, UPB_UPCAST(ret), $mini_table$, extreg,
                         options, arena) != kUpb_DecodeStatus_Ok) {
            return NULL;
          }
          return ret;
        }
        UPB_INLINE char* $msg_type$_serialize(const $msg_type$* msg,
                                              upb_Arena* arena, size_t* len) {
          char* ptr;
          (void)upb_Encode(UPB_UPCAST(msg), $mini_table$, 0, arena, &ptr, len);
          return ptr;
        }
        UPB_INLINE char* $msg_type$_serialize_ex(const $msg_type$* msg,
                                                 int options, upb_Arena* arena,
                                                 size_t* len) {
          char* ptr;
          (void)upb_Encode(UPB_UPCAST(msg), $mini_table$, options, arena, &ptr, len);
          return ptr;
        }
      )cc");
}

void GenerateOneofCases(Context& c, upb::OneofDefPtr oneof) {
  std::string base = CApiOneofIdentBase(oneof.full_name());
  for (int i = 0; i < oneof.field_count(); i++) {
    upb::FieldDefPtr field = oneof.field(i);
    c.Emit(
        {
            {"base", base},
            {"name", field.name()},
            {"number", absl::StrCat(field.number())},
        },
        R"cc(
          $base$_$name$ = $number$,
        )cc");
  }
}

void GenerateOneofInHeader(Context& c, upb::OneofDefPtr oneof,
                           absl::string_view msg_name) {
  c.Emit(
      {
          {"fullname", CApiOneofIdentBase(oneof.full_name())},
          {"msg_name", msg_name},
          {"oneof_name", oneof.name()},
          {"field_init",
           FieldInitializer(c.pools(), oneof.field(0), c.options())},
          {"mini_table",
           MessageMiniTableRef(oneof.containing_type(), c.options())},
          Sub("cases", [&]() { GenerateOneofCases(c, oneof); }).WithSuffix(","),
      },
      R"cc(
        typedef enum {
          $cases$,
          $fullname$_NOT_SET = 0
        } $fullname$_oneofcases;

        UPB_INLINE $fullname$_oneofcases
        $msg_name$_$oneof_name$_case(const $msg_name$* msg) {
          const upb_MiniTableField field = $field_init$;
          return ($fullname$_oneofcases)upb_Message_WhichOneofFieldNumber(
              UPB_UPCAST(msg), &field);
        }
        UPB_INLINE void $msg_name$_clear_$oneof_name$($msg_name$* msg) {
          const upb_MiniTableField field = $field_init$;
          upb_Message_ClearOneof(UPB_UPCAST(msg), $mini_table$, &field);
        }
      )cc");
}

void GenerateHazzer(Context& c, upb::FieldDefPtr field,
                    absl::string_view msg_name, const NameMangler& mangler) {
  std::string resolved_name = mangler.ResolveFieldName(field.name());
  if (field.has_presence()) {
    c.Emit(
        {
            {"msg_name", msg_name},
            {"name", resolved_name},
            {"field_init", FieldInitializer(c.pools(), field, c.options())},
        },
        R"cc(
          UPB_INLINE bool $msg_name$_has_$name$(const $msg_name$* msg) {
            const upb_MiniTableField field = $field_init$;
            return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
          }
        )cc");
  }
}

void GenerateClear(Context& c, upb::FieldDefPtr field,
                   absl::string_view msg_name, const NameMangler& mangler) {
  if (field == field.containing_type().map_key() ||
      field == field.containing_type().map_value()) {
    // Cannot be cleared.
    return;
  }
  c.Emit(
      {
          {"msg_name", msg_name},
          {"name", mangler.ResolveFieldName(field.name())},
          {"field_init", FieldInitializer(c.pools(), field, c.options())},
      },
      R"cc(
        UPB_INLINE void $msg_name$_clear_$name$($msg_name$* msg) {
          const upb_MiniTableField field = $field_init$;
          upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
        }
      )cc");
}

void GenerateMapGetters(Context& c, upb::FieldDefPtr field,
                        absl::string_view msg_name,
                        const NameMangler& mangler) {
  c.Emit(
      {
          {"msg_name", msg_name},
          {"name", mangler.ResolveFieldName(field.name())},
          {"key_type", MapKeyCType(field)},
          {"val_type", MapValueCType(field)},
          {"val_type_const", MapValueCTypeConst(field)},
          {"key_size", MapKeySize(field, MapKeyCType(field))},
          {"val_size", MapValueSize(field, MapValueCType(field))},
          {"field_init", FieldInitializerStrong(c.pools(), field, c.options())},
          {"map_getter", kMapGetterPostfix},
          {"mutable_map_getter", kMutableMapGetterPostfix},
      },
      R"cc(
        UPB_INLINE size_t $msg_name$_$name$_size(const $msg_name$* msg) {
          const upb_MiniTableField field = $field_init$;
          const upb_Map* map = upb_Message_GetMap(UPB_UPCAST(msg), &field);
          return map ? _upb_Map_Size(map) : 0;
        }

        UPB_INLINE bool $msg_name$_$name$_get(const $msg_name$* msg,
                                              $key_type$ key, $val_type$* val) {
          const upb_MiniTableField field = $field_init$;
          const upb_Map* map = upb_Message_GetMap(UPB_UPCAST(msg), &field);
          if (!map) return false;
          return _upb_Map_Get(map, &key, $key_size$, val, $val_size$);
        }

        UPB_INLINE bool $msg_name$_$name$_next(const $msg_name$* msg,
                                               $key_type$* key,
                                               $val_type_const$* val,
                                               size_t* iter) {
          const upb_MiniTableField field = $field_init$;
          const upb_Map* map = upb_Message_GetMap(UPB_UPCAST(msg), &field);
          if (!map) return false;
          upb_MessageValue k;
          upb_MessageValue v;
          if (!upb_Map_Next(map, &k, &v, iter)) return false;
          memcpy(key, &k, sizeof(*key));
          memcpy(val, &v, sizeof(*val));
          return true;
        }

        //~ Generate private getter returning a upb_Map or NULL for immutable
        // and ~ a upb_Map for mutable.
        //
        //~ Example:
        //~   UPB_INLINE const upb_Map* _name_immutable_upb_map(Foo* msg)
        //~   UPB_INLINE upb_Map* _name_mutable_upb_map(Foo* msg, upb_Arena* a)
        UPB_INLINE const upb_Map* _$msg_name$_$name$_$map_getter$($msg_name$* msg) {
          const upb_MiniTableField field = $field_init$;
          return upb_Message_GetMap(UPB_UPCAST(msg), &field);
        }

        UPB_INLINE upb_Map* _$msg_name$_$name$_$mutable_map_getter$(
            $msg_name$* msg, upb_Arena* a) {
          const upb_MiniTableField field = $field_init$;
          return _upb_Message_GetOrCreateMutableMap(UPB_UPCAST(msg), &field,
                                                    $key_size$, $val_size$, a);
        }
      )cc");
}

void GenerateRepeatedGetters(Context& c, upb::FieldDefPtr field,
                             absl::string_view msg_name,
                             const NameMangler& mangler) {
  c.Emit(
      {
          {"msg_name", msg_name},
          {"name", mangler.ResolveFieldName(field.name())},
          {"ctype_const", CTypeConst(field)},
          {"field_init", FieldInitializerStrong(c.pools(), field, c.options())},
          {"array_getter", kRepeatedFieldArrayGetterPostfix},
          {"mutable_array_getter", kRepeatedFieldMutableArrayGetterPostfix},
      },
      R"cc(
        //~ Generate getter returning first item and size.
        //~
        //~ Example:
        //~   UPB_INLINE const struct Bar* const* name(const Foo* msg,
        //~                                            size_t* size)
        UPB_INLINE $ctype_const$ const* $msg_name$_$name$(const $msg_name$* msg,
                                                          size_t* size) {
          const upb_MiniTableField field = $field_init$;
          const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
          if (arr) {
            if (size) *size = arr->UPB_PRIVATE(size);
            return ($ctype_const$ const*)upb_Array_DataPtr(arr);
          } else {
            if (size) *size = 0;
            return NULL;
          }
        }

        //~ Generate private getter returning array or NULL for immutable and
        //~ upb_Array for mutable.
        //
        //~ Example:
        //~   UPB_INLINE const upb_Array* _name_upbarray(size_t* size)
        //~   UPB_INLINE upb_Array* _name_mutable_upbarray(size_t* size)
        UPB_INLINE const upb_Array* _$msg_name$_$name$_$array_getter$(
            const $msg_name$* msg, size_t* size) {
          const upb_MiniTableField field = $field_init$;
          const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
          if (size) {
            *size = arr ? arr->UPB_PRIVATE(size) : 0;
          }
          return arr;
        }

        UPB_INLINE upb_Array* _$msg_name$_$name$_$mutable_array_getter$(
            $msg_name$* msg, size_t* size, upb_Arena* arena) {
          const upb_MiniTableField field = $field_init$;
          upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
                                                               &field, arena);
          if (size) {
            *size = arr ? arr->UPB_PRIVATE(size) : 0;
          }
          return arr;
        }
      )cc");
}

void GenerateScalarGetters(Context& c, upb::FieldDefPtr field,
                           absl::string_view msg_name,
                           const NameMangler& mangler) {
  std::string field_name = mangler.ResolveFieldName(field.name());
  c.Emit(
      {
          {"ctype_const", CTypeConst(field)},
          {"msg_name", msg_name},
          {"name", field_name},
          {"default", FieldDefault(field)},
          {"field_init", FieldInitializerStrong(c.pools(), field, c.options())},
      },
      R"cc(
        UPB_INLINE $ctype_const$ $msg_name$_$name$(const $msg_name$* msg) {
          $ctype_const$ default_val = $default$;
          $ctype_const$ ret;
          const upb_MiniTableField field = $field_init$;
          _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
                                            &default_val, &ret);
          return ret;
        }
      )cc");
}

void GenerateGetters(Context& c, upb::FieldDefPtr field,
                     absl::string_view msg_name, const NameMangler& mangler) {
  if (field.IsMap()) {
    GenerateMapGetters(c, field, msg_name, mangler);
  } else if (field.IsSequence()) {
    GenerateRepeatedGetters(c, field, msg_name, mangler);
  } else {
    GenerateScalarGetters(c, field, msg_name, mangler);
  }
}

void GenerateMapSetters(Context& c, upb::FieldDefPtr field,
                        absl::string_view msg_name,
                        const NameMangler& mangler) {
  c.Emit(
      {
          {"msg_name", msg_name},
          {"name", mangler.ResolveFieldName(field.name())},
          {"key_type", MapKeyCType(field)},
          {"val_type", MapValueCType(field)},
          {"field_init", FieldInitializerStrong(c.pools(), field, c.options())},
          {"key_size", MapKeySize(field, "key")},
          {"val_size", MapValueSize(field, "val")},
      },
      R"cc(
        UPB_INLINE void $msg_name$_$name$_clear($msg_name$* msg) {
          const upb_MiniTableField field = $field_init$;
          upb_Map* map = (upb_Map*)upb_Message_GetMap(UPB_UPCAST(msg), &field);
          if (!map) return;
          _upb_Map_Clear(map);
        }

        UPB_INLINE bool $msg_name$_$name$_set($msg_name$* msg, $key_type$ key,
                                              $val_type$ val, upb_Arena* a) {
          const upb_MiniTableField field = $field_init$;
          upb_Map* map = _upb_Message_GetOrCreateMutableMap(
              UPB_UPCAST(msg), &field, $key_size$, $val_size$, a);
          return _upb_Map_Insert(map, &key, $key_size$, &val, $val_size$, a) !=
                 kUpb_MapInsertStatus_OutOfMemory;
        }

        UPB_INLINE bool $msg_name$_$name$_delete($msg_name$* msg, $key_type$ key) {
          const upb_MiniTableField field = $field_init$;
          upb_Map* map = (upb_Map*)upb_Message_GetMap(UPB_UPCAST(msg), &field);
          if (!map) return false;
          return _upb_Map_Delete(map, &key, $key_size$, NULL);
        }
      )cc");
}

void GenerateRepeatedSetters(Context& c, upb::FieldDefPtr field,
                             absl::string_view msg_name,
                             const NameMangler& mangler) {
  c.Emit(
      {
          {"ctype", CType(field)},
          {"msg_name", msg_name},
          {"name", mangler.ResolveFieldName(field.name())},
          {"field_init", FieldInitializerStrong(c.pools(), field, c.options())},
      },
      R"cc(
        UPB_INLINE $ctype$* $msg_name$_mutable_$name$($msg_name$* msg,
                                                      size_t* size) {
          upb_MiniTableField field = $field_init$;
          upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
          if (arr) {
            if (size) *size = arr->UPB_PRIVATE(size);
            return ($ctype$*)upb_Array_MutableDataPtr(arr);
          } else {
            if (size) *size = 0;
            return NULL;
          }
        }

        UPB_INLINE $ctype$* $msg_name$_resize_$name$($msg_name$* msg,
                                                     size_t size,
                                                     upb_Arena* arena) {
          upb_MiniTableField field = $field_init$;
          return ($ctype$*)upb_Message_ResizeArrayUninitialized(
              UPB_UPCAST(msg), &field, size, arena);
        }
      )cc");

  if (field.ctype() == kUpb_CType_Message) {
    c.Emit(
        {
            {"sub_ctype", MessageType(field.message_type())},
            {"msg_name", msg_name},
            {"name", mangler.ResolveFieldName(field.name())},
            {"sub_mini_table",
             MessageMiniTableRef(field.message_type(), c.options())},
            {"field_init",
             FieldInitializerStrong(c.pools(), field, c.options())},
        },
        R"cc(
          UPB_INLINE struct $sub_ctype$* $msg_name$_add_$name$(
              $msg_name$* msg, upb_Arena* arena) {
            upb_MiniTableField field = $field_init$;
            upb_Array* arr = upb_Message_GetOrCreateMutableArray(
                UPB_UPCAST(msg), &field, arena);
            if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
                            arr, arr->UPB_PRIVATE(size) + 1, arena)) {
              return NULL;
            }
            struct $sub_ctype$* sub =
                (struct $sub_ctype$*)_upb_Message_New($sub_mini_table$, arena);
            if (!arr || !sub) return NULL;
            UPB_PRIVATE(_upb_Array_Set)
            (arr, arr->UPB_PRIVATE(size) - 1, &sub, sizeof(sub));
            return sub;
          }
        )cc");
  } else {
    c.Emit(
        {{"ctype", CType(field)},
         {"msg_name", msg_name},
         {"name", mangler.ResolveFieldName(field.name())},
         {"field_init", FieldInitializerStrong(c.pools(), field, c.options())}},
        R"cc(
          UPB_INLINE bool $msg_name$_add_$name$($msg_name$* msg, $ctype$ val,
                                                upb_Arena* arena) {
            upb_MiniTableField field = $field_init$;
            upb_Array* arr = upb_Message_GetOrCreateMutableArray(
                UPB_UPCAST(msg), &field, arena);
            if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
                            arr, arr->UPB_PRIVATE(size) + 1, arena)) {
              return false;
            }
            UPB_PRIVATE(_upb_Array_Set)
            (arr, arr->UPB_PRIVATE(size) - 1, &val, sizeof(val));
            return true;
          }
        )cc");
  }
}

void GenerateNonRepeatedSetters(Context& c, upb::FieldDefPtr field,
                                absl::string_view msg_name,
                                const NameMangler& mangler) {
  std::string field_name = mangler.ResolveFieldName(field.name());

  c.Emit(
      {{"msg_name", msg_name},
       {"name", field_name},
       {"ctype", CType(field)},
       {"field_init", FieldInitializerStrong(c.pools(), field, c.options())}},
      R"cc(
        UPB_INLINE void $msg_name$_set_$name$($msg_name$* msg, $ctype$ value) {
          const upb_MiniTableField field = $field_init$;
          upb_Message_SetBaseField((upb_Message*)msg, &field, &value);
        }
      )cc");

  // Message fields also have a Msg_mutable_foo() accessor that will create
  // the sub-message if it doesn't already exist.
  if (field.IsSubMessage()) {
    c.Emit({{"sub_ctype", MessageType(field.message_type())},
            {"msg_name", msg_name},
            {"name", field_name},
            {"sub_mini_table",
             MessageMiniTableRef(field.message_type(), c.options())}},
           R"cc(
             UPB_INLINE struct $sub_ctype$* $msg_name$_mutable_$name$(
                 $msg_name$* msg, upb_Arena* arena) {
               struct $sub_ctype$* sub = (struct $sub_ctype$*)$msg_name$_$name$(msg);
               if (sub == NULL) {
                 sub = (struct $sub_ctype$*)_upb_Message_New($sub_mini_table$, arena);
                 if (sub) $msg_name$_set_$name$(msg, sub);
               }
               return sub;
             }
           )cc");
  }
}

void GenerateSetters(Context& c, upb::FieldDefPtr field,
                     absl::string_view msg_name, const NameMangler& mangler) {
  if (field.IsMap()) {
    GenerateMapSetters(c, field, msg_name, mangler);
  } else if (field.IsSequence()) {
    GenerateRepeatedSetters(c, field, msg_name, mangler);
  } else {
    GenerateNonRepeatedSetters(c, field, msg_name, mangler);
  }
}

void GenerateMessageInHeader(Context& c, upb::MessageDefPtr message) {
  c.Emit({{"fullname", message.full_name()}}, R"cc(/* $fullname$ */
  )cc");
  std::string msg_name = MessageType(message);
  GenerateMessageFunctionsInHeader(c, message);

  for (int i = 0; i < message.real_oneof_count(); i++) {
    GenerateOneofInHeader(c, message.oneof(i), msg_name);
  }

  NameMangler mangler(GetUpbFields(message));
  for (auto field : FieldNumberOrder(message)) {
    GenerateClear(c, field, msg_name, mangler);
    GenerateGetters(c, field, msg_name, mangler);
    GenerateHazzer(c, field, msg_name, mangler);
  }

  c.Emit("\n");

  for (auto field : FieldNumberOrder(message)) {
    GenerateSetters(c, field, msg_name, mangler);
  }

  c.Emit("\n");
}

std::vector<upb::MessageDefPtr> SortedForwardMessages(
    const std::vector<upb::MessageDefPtr>& this_file_messages,
    const std::vector<upb::FieldDefPtr>& this_file_exts) {
  std::map<std::string, upb::MessageDefPtr> forward_messages;
  for (auto message : this_file_messages) {
    for (int i = 0; i < message.field_count(); i++) {
      upb::FieldDefPtr field = message.field(i);
      if (field.ctype() == kUpb_CType_Message &&
          field.file() != field.message_type().file()) {
        forward_messages[field.message_type().full_name()] =
            field.message_type();
      }
    }
  }
  for (auto ext : this_file_exts) {
    if (ext.file() != ext.containing_type().file()) {
      forward_messages[ext.containing_type().full_name()] =
          ext.containing_type();
    }
  }
  std::vector<upb::MessageDefPtr> ret;
  ret.reserve(forward_messages.size());
  for (const auto& pair : forward_messages) {
    ret.push_back(pair.second);
  }
  return ret;
}

void WriteHeader(Context& c, upb::FileDefPtr file) {
  const DefPoolPair& pools = c.pools();
  const Options& options = c.options();
  const std::vector<upb::MessageDefPtr> sorted_messages = SortedMessages(file);

  // Filter out map entries.
  std::vector<upb::MessageDefPtr> this_file_messages;
  std::copy_if(
      sorted_messages.begin(), sorted_messages.end(),
      std::back_inserter(this_file_messages),
      [](const upb::MessageDefPtr& message) { return !message.mapentry(); });

  const std::vector<upb::FieldDefPtr> this_file_exts = SortedExtensions(file);
  std::vector<upb::EnumDefPtr> this_file_enums = SortedEnums(file, kAllEnums);
  std::vector<upb::MessageDefPtr> forward_messages =
      SortedForwardMessages(this_file_messages, this_file_exts);

  c.Emit(FileWarning(file.name()));
  c.Emit({{"include_guard", IncludeGuard(file.name())}},
         R"cc(#ifndef $include_guard$_UPB_H_
#define $include_guard$_UPB_H_

#include "upb/generated_code_support.h"
         )cc");

  for (int i = 0; i < file.public_dependency_count(); i++) {
    if (i == 0) {
      c.Emit(R"cc(/* Public Imports. */
      )cc");
    }
    c.Emit({{"header", CApiHeaderFilename(file.public_dependency(i).name(),
                                          options.bootstrap_stage >= 0)}},
           R"cc(#include "$header$"
           )cc");
  }
  if (file.public_dependency_count() > 0) {
    c.Emit("\n");
  }

  if (options.bootstrap_stage != 0) {
    c.Emit({{"header", MiniTableHeaderFilename(file.name(),
                                               options.bootstrap_stage >= 0)}},
           R"cc(#include "$header$"
           )cc");
    for (int i = 0; i < file.dependency_count(); i++) {
      if (options.strip_nonfunctional_codegen &&
          google::protobuf::compiler::IsKnownFeatureProto(file.dependency(i).name())) {
        // Strip feature imports for editions codegen tests.
        continue;
      }
      c.Emit(
          {{"header", MiniTableHeaderFilename(file.dependency(i).name(),
                                              options.bootstrap_stage >= 0)}},
          R"cc(#include "$header$"
          )cc");
    }
    c.Emit("\n");
  }

  c.Emit(R"cc(
    // Must be last.
#include "upb/port/def.inc"

#ifdef __cplusplus
    extern "C" {
#endif
  )cc");

  if (options.bootstrap_stage == 0) {
    for (auto message : this_file_messages) {
      c.Emit(
          {
              {"name", MiniTableMessageVarName(message.full_name())},
          },
          R"cc(
            extern const upb_MiniTable* $name$(void);
          )cc");
    }
    for (auto message : forward_messages) {
      c.Emit(
          {
              {"name", MiniTableMessageVarName(message.full_name())},
          },
          R"cc(
            extern const upb_MiniTable* $name$(void);
          )cc");
    }
    for (auto enumdesc : this_file_enums) {
      c.Emit(
          {
              {"name", MiniTableEnumVarName(enumdesc.full_name())},
          },
          R"cc(
            extern const upb_MiniTableEnum* $name$(void);
          )cc");
    }
    c.Emit("\n");
  }

  // Forward-declare types defined in this file.
  for (auto message : this_file_messages) {
    c.Emit(
        {
            {"msg_type", MessageType(message)},
        },
        R"cc(
          typedef struct $msg_type$ {
            upb_Message UPB_PRIVATE(base);
          } $msg_type$;
        )cc");
    c.Emit("\n");
  }

  // Forward-declare types not in this file, but used as submessages.
  // Order by full name for consistent ordering.
  for (auto msg : forward_messages) {
    c.Emit({{"msg_type", MessageType(msg)}}, R"cc(struct $msg_type$;
    )cc");
  }

  if (!this_file_messages.empty()) {
    c.Emit("\n");
  }

  for (auto enumdesc : this_file_enums) {
    c.Emit({{"enum_type", EnumType(enumdesc)},
            Sub("enum_values", [&] { DumpEnumValues(c, enumdesc); })},
           // Avoiding R"cc( here because clang-format does really weird things
           // with it.
           R"(
             typedef enum {
               $enum_values$;
             } $enum_type$;
           )");
    c.Emit("\n");
  }

  c.Emit("\n");

  c.Emit("\n");
  for (auto message : this_file_messages) {
    GenerateMessageInHeader(c, message);
  }

  for (auto ext : this_file_exts) {
    GenerateExtensionInHeader(c, ext);
  }

  if (absl::string_view(file.name()) == "google/protobuf/descriptor.proto" ||
      absl::string_view(file.name()) == "net/proto2/proto/descriptor.proto") {
    // This is gratuitously inefficient with how many times it rebuilds
    // MessageLayout objects for the same message. But we only do this for one
    // proto (descriptor.proto) so we don't worry about it.
    upb::MessageDefPtr max32_message;
    upb::MessageDefPtr max64_message;
    size_t max32 = 0;
    size_t max64 = 0;
    for (const auto message : this_file_messages) {
      if (absl::EndsWith(message.name(), "Options")) {
        size_t size32 = pools.GetMiniTable32(message)->UPB_PRIVATE(size);
        size_t size64 = pools.GetMiniTable64(message)->UPB_PRIVATE(size);
        if (size32 > max32) {
          max32 = size32;
          max32_message = message;
        }
        if (size64 > max64) {
          max64 = size64;
          max64_message = message;
        }
      }
    }

    c.Emit(
        {
            {"max_name_32", max32_message.full_name()},
            {"max_name_64", max64_message.full_name()},
            {"max_size_32", absl::StrCat(max32)},
            {"max_size_64", absl::StrCat(max64)},
        },
        R"(
          /* Max size 32 is $max_name_32$ */
          /* Max size 64 is $max_name_64$ */
          #define _UPB_MAXOPT_SIZE UPB_SIZE($max_size_32$, $max_size_64$)
        )");
  }

  c.Emit({{"include_guard", IncludeGuard(file.name())}},
         R"cc(#ifdef __cplusplus
              } /* extern "C" */
#endif

#include "upb/port/undef.inc"

#endif /* $include_guard$_UPB_H_ */
         )cc");
}

std::string FieldInitializer(upb::FieldDefPtr field,
                             const upb_MiniTableField* field64,
                             const upb_MiniTableField* field32,
                             const Options& options) {
  if (options.bootstrap_stage == 0) {
    ABSL_CHECK(!field.is_extension());
    return absl::Substitute(
        "*upb_MiniTable_FindFieldByNumber($0, $1)",
        MessageMiniTableRef(field.containing_type(), options), field.number());
  } else {
    return upb::generator::FieldInitializer(field, field64, field32);
  }
}

std::string StrongReferenceSingle(upb::FieldDefPtr field) {
  if (!field.message_type()) return "";
  return absl::Substitute(
      "  UPB_PRIVATE(_upb_MiniTable_StrongReference)(&$0)",
      MiniTableMessageVarName(field.message_type().full_name()));
}

std::string StrongReference(upb::FieldDefPtr field) {
  if (field.IsMap() &&
      field.message_type().FindFieldByNumber(2).IsSubMessage()) {
    return StrongReferenceSingle(field) + ";\n" +
           StrongReferenceSingle(field.message_type().FindFieldByNumber(2));
  } else {
    return StrongReferenceSingle(field);
  }
}
std::string FieldInitializerStrong(const DefPoolPair& pools,
                                   upb::FieldDefPtr field,
                                   const Options& options) {
  std::string ret = FieldInitializer(pools, field, options);
  if (options.bootstrap_stage != 0 && field.IsSubMessage()) {
    ret += ";\n" + StrongReference(field);
  }
  return ret;
}

std::string FieldInitializer(const DefPoolPair& pools, upb::FieldDefPtr field,
                             const Options& options) {
  return FieldInitializer(field, pools.GetField64(field),
                          pools.GetField32(field), options);
}

void WriteResolveCalls(Context& c, upb::MessageDefPtr msg) {
  for (int i = 0; i < msg.field_count(); i++) {
    upb::FieldDefPtr field = msg.field(i);
    if (!field.message_type() && !field.enum_subdef()) continue;
    if (field.message_type()) {
      c.Emit(
          {{"number", absl::StrCat(field.number())},
           {"msg_mini_table",
            MessageMiniTableRef(field.message_type(), c.options())}},
          R"cc(
            upb_MiniTable_SetSubMessage(
                mini_table,
                (upb_MiniTableField*)upb_MiniTable_FindFieldByNumber(mini_table,
                                                                     $number$),
                $msg_mini_table$);
          )cc");
    } else if (field.enum_subdef() && field.enum_subdef().is_closed()) {
      c.Emit(
          {{"number", absl::StrCat(field.number())},
           {"enum_mini_table",
            EnumMiniTableRef(field.enum_subdef(), c.options())}},
          R"cc(
            upb_MiniTable_SetSubEnum(
                mini_table,
                (upb_MiniTableField*)upb_MiniTable_FindFieldByNumber(mini_table,
                                                                     $number$),
                $enum_mini_table$);
          )cc");
    }
  }
}

void WriteMessageMiniDescriptorInitializer(Context& c, upb::MessageDefPtr msg) {
  c.Emit({{"name", MiniTableMessageVarName(msg.full_name())},
          {"mini_descriptor", msg.MiniDescriptorEncode()},
          {"resolve_calls", [&] { WriteResolveCalls(c, msg); }}},
         R"cc(
           const upb_MiniTable* $name$() {
             static upb_MiniTable* mini_table = NULL;
             static const char* mini_descriptor = "$mini_descriptor$";
             if (mini_table) return mini_table;
             upb_Status status;
             mini_table =
                 upb_MiniTable_Build(mini_descriptor, strlen(mini_descriptor),
                                     upb_BootstrapArena(), &status);
             if (!mini_table) {
               fprintf(stderr, "Failed to build mini_table for $name$: %s\n",
                       upb_Status_ErrorMessage(&status));
               abort();
             }
             $resolve_calls$ return mini_table;
           }
         )cc");
  c.Emit("\n");
}

void WriteEnumMiniDescriptorInitializer(Context& c, upb::EnumDefPtr enum_def) {
  c.Emit({{"name", MiniTableEnumVarName(enum_def.full_name())},
          {"mini_descriptor", enum_def.MiniDescriptorEncode()}},
         R"cc(
           const upb_MiniTableEnum* $name$() {
             static const upb_MiniTableEnum* mini_table = NULL;
             static const char* mini_descriptor = "$mini_descriptor$";
             if (mini_table) return mini_table;
             mini_table = upb_MiniTableEnum_Build(mini_descriptor,
                                                  strlen(mini_descriptor),
                                                  upb_BootstrapArena(), NULL);
             return mini_table;
           }
         )cc");
  c.Emit("\n");
}

void WriteMiniDescriptorSource(Context& c, upb::FileDefPtr file) {
  const Options& options = c.options();
  c.Emit({{"header",
           CApiHeaderFilename(file.name(), options.bootstrap_stage >= 0)}},
         "#include <stddef.h>\n"
         "#include \"upb/generated_code_support.h\"\n"
         "#include \"$header$\"\n\n");

  for (int i = 0; i < file.dependency_count(); i++) {
    if (options.strip_nonfunctional_codegen &&
        google::protobuf::compiler::IsKnownFeatureProto(file.dependency(i).name())) {
      continue;
    }
    c.Emit({{"header", CApiHeaderFilename(file.dependency(i).name(),
                                          options.bootstrap_stage >= 0)}},
           "#include \"$header$\"\n");
  }

  c.Emit(
      R"cc(
        static upb_Arena* upb_BootstrapArena() {
          static upb_Arena* arena = NULL;
          if (!arena) arena = upb_Arena_New();
          return arena;
        }
      )cc");

  c.Emit("\n");

  for (const auto msg : SortedMessages(file)) {
    WriteMessageMiniDescriptorInitializer(c, msg);
  }

  for (const auto msg : SortedEnums(file, kClosedEnums)) {
    WriteEnumMiniDescriptorInitializer(c, msg);
  }
}

void GenerateFile(const DefPoolPair& pools, upb::FileDefPtr file,
                  const Options& options,
                  google::protobuf::compiler::GeneratorContext* context) {
  {
    auto stream =
        absl::WrapUnique(context->Open(CApiHeaderFilename(file.name(), false)));
    google::protobuf::io::Printer printer(stream.get());
    Context c(pools, options, printer);
    WriteHeader(c, file);
  }

  if (options.bootstrap_stage == 0) {
    auto stream = absl::WrapUnique(context->Open(SourceFilename(file)));
    google::protobuf::io::Printer printer(stream.get());
    Context c(pools, options, printer);
    WriteMiniDescriptorSource(c, file);
  } else {
    // TODO: remove once we can figure out how to make both Blaze
    // and Bazel happy with header-only libraries.

    auto stream = absl::WrapUnique(context->Open(SourceFilename(file)));
    ABSL_CHECK(stream->WriteCord(absl::Cord("\n")));
  }
}

bool ParseOptions(absl::string_view parameter, Options* options,
                  std::string* error) {
  for (const auto& pair : ParseGeneratorParameter(parameter)) {
    if (pair.first == "bootstrap_stage") {
      if (!absl::SimpleAtoi(pair.second, &options->bootstrap_stage)) {
        *error = absl::Substitute("Bad stage: $0", pair.second);
        return false;
      }
    } else if (pair.first == "experimental_strip_nonfunctional_codegen") {
      options->strip_nonfunctional_codegen = true;
    } else {
      *error = absl::Substitute("Unknown parameter: $0", pair.first);
      return false;
    }
  }

  return true;
}

class CGenerator : public google::protobuf::compiler::CodeGenerator {
  bool Generate(const google::protobuf::FileDescriptor* file,
                const std::string& parameter,
                google::protobuf::compiler::GeneratorContext* generator_context,
                std::string* error) const override {
    std::vector<const google::protobuf::FileDescriptor*> files{file};
    return GenerateAll(files, parameter, generator_context, error);
  }

  bool GenerateAll(const std::vector<const google::protobuf::FileDescriptor*>& files,
                   const std::string& parameter,
                   google::protobuf::compiler::GeneratorContext* generator_context,
                   std::string* error) const override {
    Options options;
    if (!ParseOptions(parameter, &options, error)) {
      return false;
    }

    upb::Arena arena;
    DefPoolPair pools;
    absl::flat_hash_set<std::string> files_seen;
    for (const auto* file : files) {
      PopulateDefPool(file, &arena, &pools, &files_seen);
      upb::FileDefPtr upb_file = pools.GetFile(file->name());
      GenerateFile(pools, upb_file, options, generator_context);
    }

    return true;
  }

  uint64_t GetSupportedFeatures() const override {
    return FEATURE_PROTO3_OPTIONAL | FEATURE_SUPPORTS_EDITIONS;
  }
  google::protobuf::Edition GetMinimumEdition() const override {
    return google::protobuf::Edition::EDITION_PROTO2;
  }
  google::protobuf::Edition GetMaximumEdition() const override {
    return google::protobuf::Edition::EDITION_2024;
  }
};

}  // namespace

}  // namespace generator
}  // namespace upb

int main(int argc, char** argv) {
  upb::generator::CGenerator generator;
  return google::protobuf::compiler::PluginMain(argc, argv, &generator);
}