Make it a runtime flag whether we treat closed enums as open.

PiperOrigin-RevId: 850517623

Author: haberman

ruby/ext/google/protobuf_c/defs.c

@@ -114,6 +114,10 @@ static VALUE DescriptorPool_alloc(VALUE klass) {
 
   RB_OBJ_WRITE(ret, &self->def_to_descriptor, rb_hash_new());
   self->symtab = upb_DefPool_New();
+
+  // Ruby treats all enums as open.
+  upb_DefPool_DisableClosedEnumChecking(self->symtab);
+
   return ObjectCache_TryAdd(self->symtab, ret);
 }
 

ruby/lib/google/protobuf/ffi/descriptor_pool.rb

@@ -12,6 +12,7 @@ class FFI
       attach_function :add_serialized_file,   :upb_DefPool_AddFile,            [:DefPool, :FileDescriptorProto, Status.by_ref], :FileDef
       attach_function :free_descriptor_pool,  :upb_DefPool_Free,               [:DefPool], :void
       attach_function :create_descriptor_pool,:upb_DefPool_New,                [], :DefPool
+      attach_function :disable_closed_enum_checking, :upb_DefPool_DisableClosedEnumChecking, [:DefPool], :void
       attach_function :get_extension_registry,:upb_DefPool_ExtensionRegistry,  [:DefPool],  :ExtensionRegistry
       attach_function :lookup_enum,           :upb_DefPool_FindEnumByName,     [:DefPool, :string], EnumDescriptor
       attach_function :lookup_extension,      :upb_DefPool_FindExtensionByName,[:DefPool, :string], FieldDescriptor
@@ -30,6 +31,9 @@ def initialize
         @descriptor_pool = ::FFI::AutoPointer.new(Google::Protobuf::FFI.create_descriptor_pool, Google::Protobuf::FFI.method(:free_descriptor_pool))
         @descriptor_class_by_def = {}
 
+        # Ruby treats all enums as open.
+        Google::Protobuf::FFI.disable_closed_enum_checking(@descriptor_pool)
+
         # Should always be the last expression of the initializer to avoid
         # leaking references to this object before construction is complete.
         Google::Protobuf::OBJECT_CACHE.try_add @descriptor_pool.address, self

upb/bazel/amalgamate.py

@@ -52,10 +52,6 @@ def amalgamate(self, h_files, c_files):
     self.h_files = set(h_files)
     self.output_c.write("/* Amalgamated source file */\n")
     self.output_c.write('#include "%s"\n' % (self.h_out))
-    if self.h_out == "ruby-upb.h":
-      self.output_h.write("// Ruby is still using proto3 enum semantics for proto2\n")
-      self.output_h.write("#define UPB_DISABLE_CLOSED_ENUM_CHECKING\n")
-
     self.output_h.write("/* Amalgamated source file */\n")
 
     port_def = self._find_include_file("upb/port/def.inc")

upb/port/def.inc

@@ -501,14 +501,6 @@ Error, UINTPTR_MAX is undefined
 
 #undef UPB_FASTTABLE_SUPPORTED
 
-/* Disable proto2 arena behavior (TEMPORARY) **********************************/
-
-#ifdef UPB_DISABLE_CLOSED_ENUM_CHECKING
-#define UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN 1
-#else
-#define UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN 0
-#endif
-
 #if defined(__cplusplus)
 #if defined(__clang__) || UPB_GNUC_MIN(6, 0)
 // https://gcc.gnu.org/gcc-6/changes.html

upb/port/undef.inc

@@ -59,7 +59,6 @@
 #undef UPB_MSAN
 #undef UPB_MALLOC_ALIGN
 #undef UPB_TSAN
-#undef UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN
 #undef UPB_DEPRECATED
 #undef UPB_GNUC_MIN
 #undef UPB_DESCRIPTOR_UPB_H_FILENAME

upb/reflection/def_pool.c

@@ -50,6 +50,7 @@ struct upb_DefPool {
   void* scratch_data;
   size_t scratch_size;
   size_t bytes_loaded;
+  bool disable_closed_enum_checking;
 };
 
 void upb_DefPool_Free(upb_DefPool* s) {
@@ -67,6 +68,7 @@ upb_DefPool* upb_DefPool_New(void) {
 
   s->arena = upb_Arena_New();
   s->bytes_loaded = 0;
+  s->disable_closed_enum_checking = false;
 
   s->scratch_size = 240;
   s->scratch_data = upb_gmalloc(s->scratch_size);
@@ -99,6 +101,15 @@ upb_DefPool* upb_DefPool_New(void) {
   return NULL;
 }
 
+void upb_DefPool_DisableClosedEnumChecking(upb_DefPool* s) {
+  UPB_ASSERT(upb_strtable_count(&s->files) == 0);
+  s->disable_closed_enum_checking = true;
+}
+
+bool upb_DefPool_ClosedEnumCheckingDisabled(const upb_DefPool* s) {
+  return s->disable_closed_enum_checking;
+}
+
 const UPB_DESC(FeatureSetDefaults) *
     upb_DefPool_FeatureSetDefaults(const upb_DefPool* s) {
   return s->feature_set_defaults;

upb/reflection/def_pool.h

@@ -86,6 +86,20 @@ const upb_FieldDef** upb_DefPool_GetAllExtensions(const upb_DefPool* s,
                                                   const upb_MessageDef* m,
                                                   size_t* count);
 
+// If called, closed enums will be treated as open enums. This is non-standard
+// behavior and will cause conformance tests to fail, but it is more useful
+// behavior overall and can be used in situations where where the
+// non-conformance is acceptable.
+//
+// This function may only be called immediately after upb_DefPool_New().
+// It is an error to call it on an existing def pool or after defs have
+// already been added to the pool.
+//
+// Note: we still require that implicit presence fields have zero as their
+// default value.
+UPB_API void upb_DefPool_DisableClosedEnumChecking(upb_DefPool* s);
+bool upb_DefPool_ClosedEnumCheckingDisabled(const upb_DefPool* s);
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

upb/reflection/enum_def.c

@@ -167,7 +167,7 @@ static bool upb_EnumDef_IsSpecifiedAsClosed(const upb_EnumDef* e) {
 }
 
 bool upb_EnumDef_IsClosed(const upb_EnumDef* e) {
-  if (UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN) return false;
+  if (_upb_FileDef_ClosedEnumCheckingDisabled(e->file)) return false;
   return upb_EnumDef_IsSpecifiedAsClosed(e);
 }
 

upb/reflection/file_def.c

@@ -115,6 +115,10 @@ const int32_t* _upb_FileDef_WeakDependencyIndexes(const upb_FileDef* f) {
   return f->weak_deps;
 }
 
+bool _upb_FileDef_ClosedEnumCheckingDisabled(const upb_FileDef* f) {
+  return upb_DefPool_ClosedEnumCheckingDisabled(f->symtab);
+}
+
 int upb_FileDef_TopLevelEnumCount(const upb_FileDef* f) {
   return f->top_lvl_enum_count;
 }

upb/reflection/internal/file_def.h

@@ -21,6 +21,7 @@ const upb_MiniTableExtension* _upb_FileDef_ExtensionMiniTable(
     const upb_FileDef* f, int i);
 const int32_t* _upb_FileDef_PublicDependencyIndexes(const upb_FileDef* f);
 const int32_t* _upb_FileDef_WeakDependencyIndexes(const upb_FileDef* f);
+bool _upb_FileDef_ClosedEnumCheckingDisabled(const upb_FileDef* f);
 
 // upb_FileDef_Package() returns "" if f->package is NULL, this does not.
 const char* _upb_FileDef_RawPackage(const upb_FileDef* f);